def run_test_locked_transfer_secret_registered_onchain(raiden_network,
token_addresses,
secret_registry_address,
retry_timeout):
app0 = raiden_network[0]
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state, payment_network_id, token_address)
amount = 1
target = factories.UNIT_TRANSFER_INITIATOR
identifier = 1
transfer_secret = sha3(target + b"1")
secret_registry_proxy = app0.raiden.chain.secret_registry(
secret_registry_address)
secret_registry_proxy.register_secret(secret=transfer_secret)
# Wait until our node has processed the block that the secret registration was mined at
block_number = app0.raiden.get_block_number()
wait_for_block(
raiden=app0.raiden,
block_number=block_number + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
retry_timeout=retry_timeout,
)
# Test that sending a transfer with a secret already registered on-chain fails
with pytest.raises(RaidenUnrecoverableError):
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_identifier,
amount=amount,
fee=0,
target=target,
identifier=identifier,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
secret=transfer_secret,
)
# Test that receiving a transfer with a secret already registered on chain fails
expiration = 9999
locked_transfer = factories.create(
factories.LockedTransferProperties(
amount=amount,
target=app0.raiden.address,
expiration=expiration,
secret=transfer_secret,
))
message_handler = MessageHandler()
message_handler.handle_message_lockedtransfer(app0.raiden, locked_transfer)
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(
0, "latest")
transfer_statechange_dispatched = search_for_item(
state_changes, ActionInitMediator, {}) or search_for_item(
state_changes, ActionInitTarget, {})
assert not transfer_statechange_dispatched
def test_locked_transfer_secret_registered_onchain(
raiden_network, token_addresses, secret_registry_address, retry_timeout
):
app0 = raiden_network[0]
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address
)
amount = TokenAmount(1)
target = factories.UNIT_TRANSFER_INITIATOR
identifier = PaymentID(1)
transfer_secret = make_secret()
secret_registry_proxy = app0.raiden.proxy_manager.secret_registry(
secret_registry_address, block_identifier=chain_state.block_hash
)
secret_registry_proxy.register_secret(secret=transfer_secret)
# Wait until our node has processed the block that the secret registration was mined at
block_number = app0.raiden.get_block_number()
wait_for_block(
raiden=app0.raiden,
block_number=block_number + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
retry_timeout=retry_timeout,
)
# Test that sending a transfer with a secret already registered on-chain fails
with pytest.raises(RaidenUnrecoverableError):
app0.raiden.start_mediated_transfer_with_secret(
token_network_address=token_network_address,
amount=amount,
target=target,
identifier=identifier,
secret=transfer_secret,
)
# Test that receiving a transfer with a secret already registered on chain fails
expiration = BlockExpiration(9999)
locked_transfer = factories.create(
factories.LockedTransferProperties(
amount=amount,
target=app0.raiden.address,
expiration=expiration,
secret=transfer_secret,
)
)
message_handler = MessageHandler()
message_handler.handle_message_lockedtransfer(app0.raiden, locked_transfer)
state_changes = app0.raiden.wal.storage.get_statechanges_by_range(RANGE_ALL_STATE_CHANGES)
transfer_statechange_dispatched = search_for_item(
state_changes, ActionInitMediator, {}
) or search_for_item(state_changes, ActionInitTarget, {})
assert not transfer_statechange_dispatched
def test_locked_transfer_secret_registered_onchain(
raiden_network,
token_addresses,
secret_registry_address,
):
app0 = raiden_network[0]
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
amount = 1
target = UNIT_TRANSFER_INITIATOR
identifier = 1
transfer_secret = sha3(target + b'1')
secret_registry_proxy = app0.raiden.chain.secret_registry(
secret_registry_address,
)
secret_registry_proxy.register_secret(transfer_secret)
# Test that sending a transfer with a secret already registered on-chain fails
with pytest.raises(RaidenUnrecoverableError):
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
amount,
target,
identifier,
transfer_secret,
)
expiration = 9999
transfer = make_signed_transfer(
amount,
UNIT_TRANSFER_INITIATOR,
app0.raiden.address,
expiration,
transfer_secret,
)
message_handler = MessageHandler()
message_handler.handle_message_lockedtransfer(
app0.raiden,
transfer,
)
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(0, 'latest')
transfer_statechange_dispatched = (
must_contain_entry(state_changes, ActionInitMediator, {}) or
must_contain_entry(state_changes, ActionInitTarget, {})
)
assert not transfer_statechange_dispatched
def test_locked_transfer_secret_registered_onchain(
raiden_network,
token_addresses,
secret_registry_address,
):
app0 = raiden_network[0]
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
amount = 1
target = UNIT_TRANSFER_INITIATOR
identifier = 1
transfer_secret = sha3(target + b'1')
secret_registry_proxy = app0.raiden.chain.secret_registry(
secret_registry_address,
)
secret_registry_proxy.register_secret(transfer_secret)
# Test that sending a transfer with a secret already registered on-chain fails
with pytest.raises(RaidenUnrecoverableError):
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
amount,
target,
identifier,
transfer_secret,
)
expiration = 9999
transfer = make_signed_transfer(
amount,
UNIT_TRANSFER_INITIATOR,
app0.raiden.address,
expiration,
transfer_secret,
)
message_handler = MessageHandler()
message_handler.handle_message_lockedtransfer(
app0.raiden,
transfer,
)
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(0, 'latest')
transfer_statechange_dispatched = (
must_contain_entry(state_changes, ActionInitMediator, {}) or
must_contain_entry(state_changes, ActionInitTarget, {})
)
assert not transfer_statechange_dispatched
def test_locked_transfer_secret_registered_onchain(
raiden_network,
token_addresses,
secret_registry_address,
retry_timeout,
):
app0 = raiden_network[0]
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
amount = 1
target = UNIT_TRANSFER_INITIATOR
identifier = 1
transfer_secret = sha3(target + b'1')
secret_registry_proxy = app0.raiden.chain.secret_registry(
secret_registry_address, )
secret_registry_proxy.register_secret(secret=transfer_secret,
given_block_identifier='latest')
# Wait until our node has processed the block that the secret registration was mined at
block_number = app0.raiden.get_block_number()
wait_for_block(
raiden=app0.raiden,
block_number=block_number + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
retry_timeout=retry_timeout,
)
# Test that sending a transfer with a secret already registered on-chain fails
with pytest.raises(RaidenUnrecoverableError):
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier,
amount,
target,
identifier,
transfer_secret,
)
# Test that receiving a transfer with a secret already registered on chain fails
expiration = 9999
transfer = make_signed_transfer(
amount,
UNIT_TRANSFER_INITIATOR,
app0.raiden.address,
expiration,
transfer_secret,
)
message_handler = MessageHandler()
message_handler.handle_message_lockedtransfer(
app0.raiden,
transfer,
)
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(
0, 'latest')
transfer_statechange_dispatched = (
search_for_item(state_changes, ActionInitMediator, {})
or search_for_item(state_changes, ActionInitTarget, {}))
assert not transfer_statechange_dispatched
