def _(properties, defaults=None) -> RefundTransfer:
params, signer = prepare_locked_transfer(properties, defaults)
transfer = RefundTransfer(**params)
transfer.sign(signer)
assert params["sender"] == transfer.sender
return transfer
def test_cancel_transfer(iterations=ITERATIONS):
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
nonce = 1
asset = ADDRESS
balance = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
msg = RefundTransfer(nonce, asset, balance, recipient, locksroot, lock)
msg.sign(PRIVKEY)
run_timeit('RefundTransfer', msg, iterations=iterations)
def test_cancel_transfer(iterations=ITERATIONS):
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
nonce = 1
asset = ADDRESS
balance = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
msg = RefundTransfer(nonce, asset, balance, recipient, locksroot, lock)
msg.sign(PRIVKEY)
run_timeit('RefundTransfer', msg, iterations=iterations)
def test_receive_hashlocktransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
token_manager0 = app0.raiden.managers_by_token_address.values()[0]
other_key = PrivateKey(HASH2, ctx=GLOBAL_CTX, raw=True)
other_address = privatekey_to_address(other_key.private_key)
amount = 10
lock = Lock(amount, 1, HASH)
refund_transfer = RefundTransfer(identifier=1,
nonce=1,
token=token_manager0.token_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=HASH,
lock=lock)
sign_and_send(refund_transfer, other_key, other_address, app0)
transfer_timeout = TransferTimeout(HASH, HASH)
sign_and_send(transfer_timeout, other_key, other_address, app0)
secret = Secret(1, HASH, token_manager0.token_address)
sign_and_send(secret, other_key, other_address, app0)
secret_request = SecretRequest(1, HASH, 1)
sign_and_send(secret_request, other_key, other_address, app0)
reveal_secret = RevealSecret(HASH)
sign_and_send(reveal_secret, other_key, other_address, app0)
# Whenever processing of ConfirmTransfer is implemented test it here
# too by removing the expectation of an exception
with pytest.raises(KeyError):
confirm_transfer = ConfirmTransfer(HASH)
sign_and_send(confirm_transfer, other_key, other_address, app0)
def make_refund_transfer(identifier=0,
nonce=1,
token=ADDRESS,
channel=ADDRESS,
transferred_amount=0,
amount=1,
locksroot=EMPTY_MERKLE_ROOT,
recipient=ADDRESS,
target=ADDRESS,
initiator=ADDRESS,
fee=0,
secrethash=VALID_SECRETHASHES[0]):
return RefundTransfer(
identifier,
nonce,
token,
channel,
transferred_amount,
recipient,
locksroot,
make_lock(amount=amount, secrethash=secrethash),
target,
initiator,
fee,
)
def make_refund_transfer(identifier=0,
nonce=1,
token=ADDRESS,
channel=ADDRESS,
transferred_amount=0,
amount=1,
locksroot='',
recipient=ADDRESS,
target=ADDRESS,
initiator=ADDRESS,
fee=0,
hashlock=VALID_HASHLOCKS[0]):
return RefundTransfer(
identifier,
nonce,
token,
channel,
transferred_amount,
recipient,
locksroot,
make_lock(amount=amount, hashlock=hashlock),
target,
initiator,
fee,
)
def test_receive_hashlocktransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
graph0 = app0.raiden.channelgraphs.values()[0]
other_key = PrivateKey(HASH2)
other_address = privatekey_to_address(HASH2)
amount = 10
lock = Lock(amount, 1, HASH)
refund_transfer = RefundTransfer(
identifier=1,
nonce=1,
token=graph0.token_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=HASH,
lock=lock
)
sign_and_send(refund_transfer, other_key, other_address, app0)
secret = Secret(1, HASH, graph0.token_address)
sign_and_send(secret, other_key, other_address, app0)
secret_request = SecretRequest(1, HASH, 1)
sign_and_send(secret_request, other_key, other_address, app0)
reveal_secret = RevealSecret(HASH)
sign_and_send(reveal_secret, other_key, other_address, app0)
def make_refund_transfer(message_identifier=None,
payment_identifier=0,
nonce=1,
registry_address=ADDRESS,
token=ADDRESS,
channel=ADDRESS,
transferred_amount=0,
amount=1,
locksroot=EMPTY_MERKLE_ROOT,
recipient=ADDRESS,
target=ADDRESS,
initiator=ADDRESS,
fee=0,
secrethash=VALID_SECRETHASHES[0]):
if message_identifier is None:
message_identifier = random.randint(0, UINT64_MAX)
return RefundTransfer(
message_identifier,
payment_identifier,
nonce,
registry_address,
token,
channel,
transferred_amount,
recipient,
locksroot,
make_lock(amount=amount, secrethash=secrethash),
target,
initiator,
fee,
)
def test_receive_hashlocktransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
token_manager0 = app0.raiden.managers_by_token_address.values()[0]
other_key = PrivateKey(HASH2, ctx=GLOBAL_CTX, raw=True)
other_address = privatekey_to_address(other_key.private_key)
amount = 10
lock = Lock(amount, 1, HASH)
refund_transfer = RefundTransfer(identifier=1,
nonce=1,
token=token_manager0.token_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=HASH,
lock=lock)
sign_and_send(refund_transfer, other_key, other_address, app0)
secret = Secret(1, HASH, token_manager0.token_address)
sign_and_send(secret, other_key, other_address, app0)
secret_request = SecretRequest(1, HASH, 1)
sign_and_send(secret_request, other_key, other_address, app0)
reveal_secret = RevealSecret(HASH)
sign_and_send(reveal_secret, other_key, other_address, app0)
def handle_send_refundtransfer(
raiden: 'RaidenService',
refund_transfer_event: SendRefundTransfer):
refund_transfer_message = RefundTransfer.from_event(refund_transfer_event)
raiden.sign(refund_transfer_message)
raiden.send_async(
refund_transfer_event.recipient,
refund_transfer_message,
)
def test_refund_transfer_min_max(amount, payment_identifier, nonce, transferred_amount):
refund_transfer = make_refund_transfer(
amount=amount,
payment_identifier=payment_identifier,
nonce=nonce,
transferred_amount=transferred_amount,
)
refund_transfer.sign(PRIVKEY)
assert RefundTransfer.from_dict(refund_transfer.to_dict()) == refund_transfer
def decode_transfer(transfer_encoded):
if transfer_encoded[0] == DIRECTTRANSFER:
return DirectTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == MEDIATEDTRANSFER:
return MediatedTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == REFUNDTRANSFER:
return RefundTransfer.decode(transfer_encoded)
else:
raise ValueError('invalid transfer type {}'.format(
type(transfer_encoded[0])))
def test_refund_transfer_min_max(amount, payment_identifier, nonce, transferred_amount):
refund_transfer = make_refund_transfer(
amount=amount,
payment_identifier=payment_identifier,
nonce=nonce,
transferred_amount=transferred_amount,
)
refund_transfer.sign(signer)
assert RefundTransfer.from_dict(refund_transfer.to_dict()) == refund_transfer
def test_decode_refund_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("Mainz")
amount = 1337
expiration = 19
lock = Lock(amount, expiration, locksroot)
message = RefundTransfer(
identifier=321313,
nonce=4242452,
asset=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()) is True
assert dtester.decodedNonce() == 4242452
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_refund_transfer_min_max(amount, payment_identifier, nonce,
transferred_amount):
refund_transfer = factories.create(
factories.RefundTransferProperties(
amount=amount,
payment_identifier=payment_identifier,
nonce=nonce,
transferred_amount=transferred_amount,
))
assert RefundTransfer.from_dict(
refund_transfer.to_dict()) == refund_transfer
def test_refund_transfer_min_max(amount, payment_identifier, nonce, transferred_amount):
refund_transfer = factories.create(
factories.RefundTransferProperties(
amount=amount,
payment_identifier=payment_identifier,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
nonce=nonce,
transferred_amount=transferred_amount,
)
)
assert RefundTransfer.from_dict(refund_transfer.to_dict()) == refund_transfer
def test_refund_transfer_min_max(amount, identifier, nonce,
transferred_amount):
refund_transfer = make_refund_transfer(
amount=amount,
identifier=identifier,
nonce=nonce,
transferred_amount=transferred_amount,
)
refund_transfer.sign(PRIVKEY, ADDRESS)
assert RefundTransfer.from_dict(
refund_transfer.to_dict()) == refund_transfer
def decode_transfer(transfer_encoded):
if transfer_encoded[0] == DIRECTTRANSFER:
return DirectTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == MEDIATEDTRANSFER:
return MediatedTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == REFUNDTRANSFER:
return RefundTransfer.decode(transfer_encoded)
# convinience for testing only (LockedTransfer are not exchanged between nodes)
elif transfer_encoded[0] == LOCKEDTRANSFER:
return LockedTransfer.decode(transfer_encoded)
else:
raise ValueError("invalid transfer type {}".format(type(transfer_encoded[0])))
def decode_transfer(transfer_encoded):
if transfer_encoded[0] == DIRECTTRANSFER:
return DirectTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == MEDIATEDTRANSFER:
return MediatedTransfer.decode(transfer_encoded)
elif transfer_encoded[0] == REFUNDTRANSFER:
return RefundTransfer.decode(transfer_encoded)
# convinience for testing only (LockedTransfer are not exchanged between nodes)
elif transfer_encoded[0] == LOCKEDTRANSFER:
return LockedTransfer.decode(transfer_encoded)
else:
raise ValueError('invalid transfer type {}'.format(type(transfer_encoded[0])))
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 test_cancel_transfer(iterations=ITERATIONS):
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
identifier = 1
nonce = 1
asset = ADDRESS
transferred_amount = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
msg = RefundTransfer(
identifier,
nonce,
asset,
transferred_amount,
recipient,
locksroot,
lock,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('RefundTransfer', msg, iterations=iterations)
def test_cancel_transfer(iterations=ITERATIONS):
amount = 1
expiration = 1
hashlock = sha3(ADDRESS)
lock = Lock(amount, expiration, hashlock)
identifier = 1
nonce = 1
asset = ADDRESS
transferred_amount = 1
recipient = ADDRESS
locksroot = sha3(ADDRESS)
msg = RefundTransfer(
identifier,
nonce,
asset,
transferred_amount,
recipient,
locksroot,
lock,
)
msg.sign(PRIVKEY, ADDRESS)
run_timeit('RefundTransfer', msg, iterations=iterations)
def make_refund_transfer(identifier=0,
nonce=1,
token=ADDRESS,
transferred_amount=0,
amount=1,
locksroot='',
recipient=ADDRESS):
return RefundTransfer(
identifier,
nonce,
token,
transferred_amount,
recipient,
locksroot,
make_lock(amount=amount),
)
def make_refund_transfer(
message_identifier=None,
payment_identifier=0,
nonce=1,
token_network_address=ADDRESS,
token=ADDRESS,
channel_identifier=UNIT_CHANNEL_ID,
transferred_amount=0,
locked_amount=None,
amount=1,
locksroot=EMPTY_MERKLE_ROOT,
recipient=ADDRESS,
target=ADDRESS,
initiator=ADDRESS,
fee=0,
secrethash=VALID_SECRETHASHES[0],
):
if message_identifier is None:
message_identifier = random.randint(0, UINT64_MAX)
if locked_amount is None:
locked_amount = amount
else:
assert locked_amount >= amount
return RefundTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=token_network_address,
token=token,
channel_identifier=channel_identifier,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
recipient=recipient,
locksroot=locksroot,
lock=make_lock(amount=amount, secrethash=secrethash),
target=target,
initiator=initiator,
fee=fee,
)
def message_from_sendevent(send_event: SendMessageEvent) -> Message:
if type(send_event) == SendLockedTransfer:
assert isinstance(send_event, SendLockedTransfer), MYPY_ANNOTATION
message = LockedTransfer.from_event(send_event)
elif type(send_event) == SendLockedTransferLight:
assert isinstance(send_event, SendLockedTransferLight), MYPY_ANNOTATION
message = send_event.signed_locked_transfer
elif type(send_event) == SendSecretReveal:
assert isinstance(send_event, SendSecretReveal), MYPY_ANNOTATION
message = RevealSecret.from_event(send_event)
elif type(send_event) == SendSecretRevealLight:
assert isinstance(send_event, SendSecretRevealLight), MYPY_ANNOTATION
message = send_event.signed_secret_reveal
elif type(send_event) == SendBalanceProof:
assert isinstance(send_event, SendBalanceProof), MYPY_ANNOTATION
message = Unlock.from_event(send_event)
elif type(send_event) == SendBalanceProofLight:
assert isinstance(send_event, SendBalanceProofLight), MYPY_ANNOTATION
message = send_event.signed_balance_proof
elif type(send_event) == SendSecretRequest:
assert isinstance(send_event, SendSecretRequest), MYPY_ANNOTATION
message = SecretRequest.from_event(send_event)
elif type(send_event) == SendSecretRequestLight:
assert isinstance(send_event, SendSecretRequestLight), MYPY_ANNOTATION
message = send_event.signed_secret_request
elif type(send_event) == SendRefundTransfer:
assert isinstance(send_event, SendRefundTransfer), MYPY_ANNOTATION
message = RefundTransfer.from_event(send_event)
elif type(send_event) == SendLockExpired:
assert isinstance(send_event, SendLockExpired), MYPY_ANNOTATION
message = LockExpired.from_event(send_event)
elif type(send_event) == SendProcessed:
assert isinstance(send_event, SendProcessed), MYPY_ANNOTATION
message = Processed.from_event(send_event)
else:
raise ValueError(f"Unknown event type {send_event}")
return message
