def test_decode_direct_transfer(private_keys, settle_timeout, tester_state,
tester_token, tester_events, tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
dtester = deploy_decoder_tester(tester_token.address, address0, address1,
settle_timeout)
locksroot = sha3("Waldemarstr")
message = DirectTransfer(identifier=1,
nonce=2,
asset=tester_token.address,
transferred_amount=1337,
recipient=address1,
locksroot=locksroot)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode()) is True
assert dtester.decodedNonce() == 2
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == 1337
assert dtester.decodedLocksroot() == locksroot
def test_decode_refund_transfer(settle_timeout, tester_state, tester_token):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = tester.k1
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
dtester = deploy_decoder_tester(tester_state, tester_token.address,
address0, address1, settle_timeout)
locksroot = sha3('Mainz')
amount = 1337
expiration = 19
lock = Lock(amount, expiration, locksroot)
message = RefundTransfer(identifier=321313,
nonce=4242452,
token=tester_token.address,
transferred_amount=amount,
recipient=address1,
locksroot=locksroot,
lock=lock)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode(),
sender=privatekey1) is True
assert dtester.decodedNonce() == 4242452
assert dtester.decodedToken() == tester_token.address.encode('hex')
assert dtester.decodedLocksroot() == locksroot
def decode(cls, data):
result = messages.wrap_and_validate(data)
if result is None:
return
packed, public_key = result
message = cls.unpack(packed) # pylint: disable=no-member
message.sender = signing.address_from_key(public_key)
return message
def decode(cls, data):
result = messages.wrap_and_validate(data)
if result is None:
return
packed, public_key = result
message = cls.unpack(packed) # pylint: disable=no-member
message.sender = signing.address_from_key(public_key)
return message
def sign(self, private_key):
""" Sign message using `private_key`. """
packed = self.packed()
field = packed.fields_spec[-1]
assert field.name == 'signature', 'signature is not the last field'
message_data = packed.data[:-field.size_bytes]
signature, public_key = signing.sign(message_data, private_key)
packed.signature = signature
self.sender = signing.address_from_key(public_key)
self.signature = packed.signature
def sign(self, private_key):
""" Sign message using `private_key`. """
packed = self.packed()
field = packed.fields_spec[-1]
assert field.name == 'signature', 'signature is not the last field'
message_data = packed.data[:-field.size_bytes]
signature, public_key = signing.sign(message_data, private_key)
packed.signature = signature
self.sender = signing.address_from_key(public_key)
self.signature = packed.signature
def test_decode_mediated_transfer(
private_keys,
settle_timeout,
tester_state,
tester_token,
tester_events,
tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
address2 = privatekey_to_address(private_keys[2])
dtester = deploy_decoder_tester(tester_token.address, address0, address1, settle_timeout)
locksroot = sha3("Sikorka")
amount = 1337
expiration = 5
lock = Lock(amount, expiration, locksroot)
message = MediatedTransfer(
identifier=313151,
nonce=88924902,
asset=tester_token.address,
transferred_amount=amount,
recipient=address1,
locksroot=locksroot,
lock=lock,
target=address2,
initiator=address0
)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode()) is True
assert dtester.decodedNonce() == 88924902
assert dtester.decodedExpiration() == expiration
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == amount
assert dtester.decodedLocksroot() == locksroot
def test_decode_mediated_transfer(private_keys, settle_timeout, tester_state,
tester_token, tester_events,
tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = tester.k1
privatekey2 = tester.k2
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
address2 = privatekey_to_address(privatekey2)
dtester = deploy_decoder_tester(tester_state, tester_token.address,
address0, address1, settle_timeout)
locksroot = sha3("Sikorka")
amount = 1337
expiration = 5
lock = Lock(amount, expiration, locksroot)
message = MediatedTransfer(identifier=313151,
nonce=88924902,
token=tester_token.address,
transferred_amount=amount,
recipient=address1,
locksroot=locksroot,
lock=lock,
target=address2,
initiator=address0)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode(),
sender=privatekey1) is True
assert dtester.decodedNonce() == 88924902
assert dtester.decodedExpiration() == expiration
assert dtester.decodedToken() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == amount
assert dtester.decodedLocksroot() == locksroot
def test_decode_direct_transfer(
private_keys,
settle_timeout,
tester_state,
tester_token,
tester_events,
tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
dtester = deploy_decoder_tester(tester_token.address, address0, address1, settle_timeout)
locksroot = sha3("Waldemarstr")
message = DirectTransfer(
identifier=1,
nonce=2,
asset=tester_token.address,
transferred_amount=1337,
recipient=address1,
locksroot=locksroot
)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode()) is True
assert dtester.decodedNonce() == 2
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == 1337
assert dtester.decodedLocksroot() == locksroot
def test_ncc():
token_library_path = get_contract_path('StandardToken.sol')
token_path = get_contract_path('HumanStandardToken.sol')
s = tester.state()
assert s.block.number < 1150000
s.block.number = 1158001
assert s.block.number > 1150000
# Token creation
lib_token = s.abi_contract(None, path=token_library_path, language="solidity")
token = s.abi_contract(None, path=token_path, language="solidity", libraries={'StandardToken': lib_token.address.encode('hex')}, constructor_parameters=[10000, "raiden", 0, "rd"])
# Getter creation
lib_getter = s.abi_contract(None, path=decode_lib, language="solidity")
getter = s.abi_contract(None, path=getter_path, language="solidity", libraries={'Decoder': lib_getter.address.encode('hex')})
INITIATOR_PRIVKEY = tester.k0
INITIATOR_ADDRESS = privtoaddr(INITIATOR_PRIVKEY)
RECIPIENT_PRIVKEY = tester.k1
RECIPIENT_ADDRESS = privtoaddr(RECIPIENT_PRIVKEY)
ASSET_ADDRESS = token.address
HASHLOCK = sha3(INITIATOR_PRIVKEY)
LOCK_AMOUNT = 29
LOCK_EXPIRATION = 31
LOCK = Lock(LOCK_AMOUNT, LOCK_EXPIRATION, HASHLOCK)
LOCKSROOT = merkleroot([
sha3(LOCK.as_bytes), ]) # print direct_transfer.encode('hex')
nonce = 1
asset = ASSET_ADDRESS
balance = 1
recipient = RECIPIENT_ADDRESS
locksroot = LOCKSROOT
msg = DirectTransfer(
nonce,
asset,
balance,
recipient,
locksroot,
).sign(INITIATOR_PRIVKEY)
packed = msg.packed()
direct_transfer = str(packed.data)
# pure python recover
sen = recover_publickey(direct_transfer[:148], str(packed.signature))
assert address_from_key(sen) == tester.a0
# addr = getter.ecTest(direct_transfer[:148], sig)
# assert addr == INITIATOR_ADDRESS.encode('hex')
sender = getter.getSender(direct_transfer)
assert sender == tester.a0.encode('hex')
# with sigSplit directly in Getters.sol
r, s, v = getter.sigSplit(str(packed.signature))
assert r == str(packed.signature[:32])
assert s == str(packed.signature[32:64])
assert v == packed.signature[64] + 27
sender = getter.getSender(direct_transfer)
assert sender == tester.a0.encode('hex')
