def _(properties, defaults=None) -> LockedTransferUnsignedState:
defaults = defaults or LOCKED_TRANSFER_DEFAULTS
parameters = _properties_to_dict(properties, defaults)
lock = HashTimeLockState(
amount=parameters.pop('amount'),
expiration=parameters.pop('expiration'),
secrethash=sha3(parameters.pop('secret')),
)
balance_proof_parameters = _properties_to_dict(
parameters.pop('balance_proof'),
defaults.balance_proof,
)
balance_proof_parameters['canonical_identifier'] = CanonicalIdentifier(
chain_identifier=balance_proof_parameters.pop('chain_id'),
token_network_address=balance_proof_parameters.pop(
'token_network_identifier'),
channel_identifier=balance_proof_parameters.pop('channel_identifier'),
)
if balance_proof_parameters['locksroot'] == EMPTY_MERKLE_ROOT:
balance_proof_parameters['locksroot'] = lock.lockhash
balance_proof = BalanceProofUnsignedState(**balance_proof_parameters)
return LockedTransferUnsignedState(balance_proof=balance_proof,
lock=lock,
**parameters)
def make_transfer(
amount: typing.TokenAmount = EMPTY,
initiator: typing.InitiatorAddress = EMPTY,
target: typing.TargetAddress = EMPTY,
expiration: typing.BlockExpiration = EMPTY,
secret: typing.Secret = EMPTY,
identifier: typing.PaymentID = EMPTY,
nonce: typing.Nonce = EMPTY,
transferred_amount: typing.TokenAmount = EMPTY,
locked_amount: typing.TokenAmount = EMPTY,
token_network_identifier: typing.TokenNetworkID = EMPTY,
channel_identifier: typing.ChannelID = EMPTY,
locksroot: typing.Locksroot = EMPTY,
token: typing.TargetAddress = EMPTY,
) -> LockedTransferUnsignedState:
amount = if_empty(amount, UNIT_TRANSFER_AMOUNT)
initiator = if_empty(initiator, make_address())
target = if_empty(target, make_address())
expiration = if_empty(expiration, UNIT_REVEAL_TIMEOUT)
secret = if_empty(secret, make_secret())
identifier = if_empty(identifier, 1)
nonce = if_empty(nonce, 1)
transferred_amount = if_empty(transferred_amount, 0)
token_network_identifier = if_empty(token_network_identifier,
UNIT_TOKEN_NETWORK_ADDRESS)
channel_identifier = if_empty(channel_identifier, UNIT_CHANNEL_ID)
token = if_empty(token, UNIT_TOKEN_ADDRESS)
secrethash = sha3(secret)
lock = HashTimeLockState(
amount=amount,
expiration=expiration,
secrethash=secrethash,
)
if locksroot is EMPTY:
locksroot = lock.lockhash
locked_amount = amount
else:
assert locked_amount
unsigned_balance_proof = BalanceProofUnsignedState(
nonce=nonce,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=locksroot,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
chain_id=UNIT_CHAIN_ID,
)
return LockedTransferUnsignedState(
payment_identifier=identifier,
token=token,
balance_proof=unsigned_balance_proof,
lock=lock,
initiator=initiator,
target=target,
)
def create_sendmediatedtransfer(channel_state, initiator, target, amount,
identifier, expiration, secrethash):
our_state = channel_state.our_state
partner_state = channel_state.partner_state
our_balance_proof = our_state.balance_proof
msg = 'caller must make sure there is enough balance'
assert amount <= get_distributable(our_state, partner_state), msg
msg = 'caller must make sure the channel is open'
assert get_status(channel_state) == CHANNEL_STATE_OPENED, msg
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
merkletree = compute_merkletree_with(
channel_state.our_state.merkletree,
lock.lockhash,
)
# The caller must ensure the same lock is not being used twice
assert merkletree, 'lock is already registered'
locksroot = merkleroot(merkletree)
if our_balance_proof:
transferred_amount = our_balance_proof.transferred_amount
else:
transferred_amount = 0
token = channel_state.token_address
nonce = get_next_nonce(channel_state.our_state)
recipient = channel_state.partner_state.address
balance_proof = BalanceProofUnsignedState(
nonce,
transferred_amount,
locksroot,
channel_state.identifier,
)
locked_transfer = LockedTransferUnsignedState(
identifier,
token,
balance_proof,
lock,
initiator,
target,
)
mediatedtransfer = SendMediatedTransfer(
locked_transfer,
recipient,
)
return mediatedtransfer, merkletree
def make_transfer(
amount,
initiator,
target,
expiration,
secret,
identifier=1,
nonce=1,
transferred_amount=0,
locked_amount=None,
token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS,
channel_identifier=UNIT_CHANNEL_ID,
locksroot=None,
token=UNIT_TOKEN_ADDRESS,
):
secrethash = sha3(secret)
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
if locksroot is None:
locksroot = lock.lockhash
locked_amount = amount
else:
assert locked_amount
unsigned_balance_proof = BalanceProofUnsignedState(
nonce=nonce,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=locksroot,
token_network_identifier=token_network_identifier,
channel_address=channel_identifier,
chain_id=UNIT_CHAIN_ID,
)
transfer_state = LockedTransferUnsignedState(
identifier,
token,
unsigned_balance_proof,
lock,
initiator,
target,
)
return transfer_state
def _(properties, defaults=None) -> LockedTransferUnsignedState:
transfer: LockedTransferUnsignedStateProperties = create_properties(
properties, defaults)
lock = HashTimeLockState(amount=transfer.amount,
expiration=transfer.expiration,
secrethash=sha3(transfer.secret))
if transfer.locksroot == EMPTY_MERKLE_ROOT:
transfer = replace(transfer, locksroot=lock.lockhash)
return LockedTransferUnsignedState(
balance_proof=create(transfer.extract(BalanceProofProperties)),
lock=lock,
**transfer.partial_dict("initiator", "target", "payment_identifier",
"token"),
)
def make_transfer(amount,
initiator,
target,
expiration,
secret,
identifier=1,
nonce=1,
transferred_amount=0,
locked_amount=None,
channel_identifier=UNIT_CHANNEL_ADDRESS,
locksroot=None,
token=UNIT_TOKEN_ADDRESS):
secrethash = sha3(secret)
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
if locksroot is None:
locksroot = lock.lockhash
locked_amount = amount
else:
assert locked_amount
unsigned_balance_proof = BalanceProofUnsignedState(
nonce,
transferred_amount,
locked_amount,
locksroot,
channel_identifier,
)
transfer_state = LockedTransferUnsignedState(
identifier,
UNIT_REGISTRY_IDENTIFIER,
token,
unsigned_balance_proof,
lock,
initiator,
target,
)
return transfer_state
def _(properties, defaults=None) -> LockedTransferUnsignedState:
defaults = defaults or LOCKED_TRANSFER_DEFAULTS
parameters = _properties_to_dict(properties, defaults)
lock = HashTimeLockState(
amount=parameters.pop('amount'),
expiration=parameters.pop('expiration'),
secrethash=sha3(parameters.pop('secret')),
)
balance_proof_parameters = _properties_to_dict(
parameters.pop('balance_proof'),
defaults.balance_proof,
)
if balance_proof_parameters['locksroot'] == EMPTY_MERKLE_ROOT:
balance_proof_parameters['locksroot'] = lock.lockhash
balance_proof = BalanceProofUnsignedState(**balance_proof_parameters)
return LockedTransferUnsignedState(balance_proof=balance_proof,
lock=lock,
**parameters)
def create_sendlockedtransfer(
channel_state: NettingChannelState,
initiator: typing.InitiatorAddress,
target: typing.TargetAddress,
amount: typing.PaymentAmount,
message_identifier: typing.MessageID,
payment_identifier: typing.PaymentID,
expiration: typing.BlockExpiration,
secrethash: typing.SecretHash,
) -> SendLockedTransfer:
our_state = channel_state.our_state
partner_state = channel_state.partner_state
our_balance_proof = our_state.balance_proof
msg = 'caller must make sure there is enough balance'
assert amount <= get_distributable(our_state, partner_state), msg
msg = 'caller must make sure the channel is open'
assert get_status(channel_state) == CHANNEL_STATE_OPENED, msg
lock = HashTimeLockState(
amount,
expiration,
secrethash,
)
merkletree = compute_merkletree_with(
channel_state.our_state.merkletree,
lock.lockhash,
)
# The caller must ensure the same lock is not being used twice
assert merkletree, 'lock is already registered'
locksroot = merkleroot(merkletree)
if our_balance_proof:
transferred_amount = our_balance_proof.transferred_amount
else:
transferred_amount = 0
token = channel_state.token_address
nonce = get_next_nonce(channel_state.our_state)
recipient = channel_state.partner_state.address
locked_amount = get_amount_locked(
our_state) + amount # the new lock is not registered yet
balance_proof = BalanceProofUnsignedState(
nonce,
transferred_amount,
locked_amount,
locksroot,
channel_state.token_network_identifier,
channel_state.identifier,
)
locked_transfer = LockedTransferUnsignedState(
payment_identifier,
token,
balance_proof,
lock,
initiator,
target,
)
queue_name = channel_state.identifier
lockedtransfer = SendLockedTransfer(
recipient,
queue_name,
message_identifier,
locked_transfer,
)
return lockedtransfer, merkletree
def test_pfs_global_messages(
matrix_transports,
monkeypatch,
):
"""
Test that `update_pfs` from `RaidenEventHandler` sends balance proof updates to the global
PATH_FINDING_BROADCASTING_ROOM room on Send($BalanceProof)* events, i.e. events, that send
a new balance proof to the channel partner.
"""
transport = matrix_transports[0]
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# create mock events that should trigger a send
lock = make_lock()
hash_time_lock = HashTimeLockState(lock.amount, lock.expiration,
lock.secrethash)
def make_unsigned_balance_proof(nonce):
return BalanceProofUnsignedState.from_dict(
make_balance_proof(nonce=nonce,
signer=LocalSigner(HOP1_KEY),
amount=1).to_dict(), )
transfer1 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=1),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
transfer2 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=2),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
send_balance_proof_events = [
SendLockedTransfer(HOP1, 1, 1, transfer1),
SendRefundTransfer(HOP1, 1, 1, transfer2),
SendBalanceProof(HOP1, 1, 1, 1, b'1', b'x' * 32,
make_unsigned_balance_proof(nonce=3)),
SendLockExpired(HOP1, 1, make_unsigned_balance_proof(nonce=4),
b'x' * 32),
]
for num, event in enumerate(send_balance_proof_events):
assert event.balance_proof.nonce == num + 1
# make sure we cover all configured event types
assert all(event in [type(event) for event in send_balance_proof_events]
for event in SEND_BALANCE_PROOF_EVENTS)
event_handler = raiden_event_handler.RaidenEventHandler()
# let our mock objects pass validation
channelstate_mock = Mock()
channelstate_mock.reveal_timeout = 1
monkeypatch.setattr(
raiden_event_handler,
'get_channelstate_by_token_network_and_partner',
lambda *args, **kwargs: channelstate_mock,
)
monkeypatch.setattr(raiden_event_handler, 'state_from_raiden',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_lockedtransfer',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_refundtransfer',
lambda *args, **kwargs: 1)
# handle the events
for event in send_balance_proof_events:
event_handler.on_raiden_event(
raiden_service,
event,
)
gevent.idle()
# ensure all events triggered a send for their respective balance_proof
# matrix transport may concatenate multiple messages send in one interval
assert pfs_room.send_text.call_count >= 1
concatenated_call_args = ' '.join(
str(arg) for arg in pfs_room.send_text.call_args_list)
assert all(f'"nonce": {i + 1}' in concatenated_call_args
for i in range(len(SEND_BALANCE_PROOF_EVENTS)))
transport.stop()
transport.get()
