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_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 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