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_mediated_transfer():
nonce = balance = 1
asset = recipient = target = initiator = address
hashlock = locksroot = sha3(address)
amount = expiration = 1
lock = Lock(amount, expiration, hashlock)
d = lock.encode()
assert Lock.decode(d) == lock
msg = MediatedTransfer(nonce, asset, balance, recipient, locksroot,
lock, target, initiator, fee=0)
msg.sign(privkey)
dm = msg.encode()
msg2 = decode(dm)
assert msg2 == msg
assert msg2.lock == lock
def test_mediated_transfer():
nonce = balance = 1
asset = recipient = target = initiator = ADDRESS
hashlock = locksroot = sha3(ADDRESS)
amount = expiration = 1
fee = 0
lock = Lock(amount, expiration, hashlock)
mediated_transfer = MediatedTransfer(
nonce,
asset,
balance,
recipient,
locksroot,
lock,
target,
initiator,
fee,
)
mediated_transfer.sign(PRIVKEY)
decoded_mediated_transfer = decode(mediated_transfer.encode())
assert decoded_mediated_transfer == mediated_transfer
def test_mediated_transfer():
nonce = balance = 1
asset = recipient = target = initiator = address
hashlock = locksroot = sha3(address)
amount = expiration = 1
lock = Lock(amount, expiration, hashlock)
d = lock.encode()
assert Lock.decode(d) == lock
msg = MediatedTransfer(nonce,
asset,
balance,
recipient,
locksroot,
lock,
target,
initiator,
fee=0)
msg.sign(privkey)
dm = msg.encode()
msg2 = decode(dm)
assert msg2 == msg
assert msg2.lock == lock
def test_regression_multiple_revealsecret(raiden_network, token_addresses):
""" Multiple RevealSecret messages arriving at the same time must be
handled properly.
Secret handling followed these steps:
The Secret message arrives
The secret is registered
The channel is updated and the correspoding lock is removed
* A balance proof for the new channel state is created and sent to the
payer
The channel is unregistered for the given secrethash
The step marked with an asterisk above introduced a context-switch. This
allowed a second Reveal Secret message to be handled before the channel was
unregistered. And because the channel was already updated an exception was raised
for an unknown secret.
"""
app0, app1 = raiden_network
token = token_addresses[0]
channelstate_0_1 = get_channelstate(app0, app1, token)
identifier = 1
secret = sha3(b'test_regression_multiple_revealsecret')
secrethash = sha3(secret)
expiration = app0.raiden.get_block_number() + 100
amount = 10
lock = Lock(
amount,
expiration,
secrethash,
)
nonce = 1
transferred_amount = 0
mediated_transfer = MediatedTransfer(
identifier,
nonce,
token,
channelstate_0_1.identifier,
transferred_amount,
app1.raiden.address,
lock.secrethash,
lock,
app1.raiden.address,
app0.raiden.address,
)
app0.raiden.sign(mediated_transfer)
message_data = mediated_transfer.encode()
app1.raiden.protocol.receive(message_data)
reveal_secret = RevealSecret(secret)
app0.raiden.sign(reveal_secret)
reveal_secret_data = reveal_secret.encode()
secret = Secret(
identifier=identifier,
nonce=mediated_transfer.nonce + 1,
channel=channelstate_0_1.identifier,
transferred_amount=amount,
locksroot=EMPTY_MERKLE_ROOT,
secret=secret,
)
app0.raiden.sign(secret)
secret_data = secret.encode()
messages = [
secret_data,
reveal_secret_data,
]
wait = [
gevent.spawn_later(
.1,
app1.raiden.protocol.receive,
data,
) for data in messages
]
gevent.joinall(wait)
