本文整理汇总了Python中raiden.transfer.views.get_token_network_identifier_by_token_address函数的典型用法代码示例。如果您正苦于以下问题:Python get_token_network_identifier_by_token_address函数的具体用法?Python get_token_network_identifier_by_token_address怎么用?Python get_token_network_identifier_by_token_address使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了get_token_network_identifier_by_token_address函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_receive_directtransfer_invalidnonce
def test_receive_directtransfer_invalidnonce(raiden_network, deposit, token_addresses):
app0, app1 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
transferred_amount = 10
same_payment_identifier = 1
message_identifier = random.randint(0, UINT64_MAX)
event = channel.send_directtransfer(
channel0,
transferred_amount,
message_identifier,
same_payment_identifier,
)
direct_transfer_message = DirectTransfer.from_event(event)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# Send a *different* direct transfer with the *same nonce*
invalid_transferred_amount = transferred_amount // 2
message_identifier = random.randint(0, UINT64_MAX)
invalid_direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=same_payment_identifier,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=invalid_transferred_amount,
locked_amount=0,
recipient=app1.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
invalid_direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit - transferred_amount, [],
app1, deposit + transferred_amount, [],
)
示例2: test_regression_unfiltered_routes
def test_regression_unfiltered_routes(
raiden_network,
token_addresses,
settle_timeout,
deposit,
):
""" The transfer should proceed without triggering an assert.
Transfers failed in networks where two or more paths to the destination are
possible but they share same node as a first hop.
"""
app0, app1, app2, app3, app4 = raiden_network
token = token_addresses[0]
registry_address = app0.raiden.default_registry.address
# Topology:
#
# 0 -> 1 -> 2 -> 4
# | ^
# +--> 3 ---+
app_channels = [
(app0, app1),
(app1, app2),
(app1, app3),
(app3, app4),
(app2, app4),
]
greenlets = []
for first_app, second_app in app_channels:
greenlets.append(gevent.spawn(
payment_channel_open_and_deposit,
first_app,
second_app,
token,
deposit,
settle_timeout,
))
gevent.wait(greenlets)
wait_for_channels(
app_channels,
registry_address,
[token],
deposit,
)
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token,
)
transfer = app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=1,
target=app4.raiden.address,
identifier=1,
)
assert transfer.wait()
示例3: test_failsfast_lockedtransfer_exceeding_distributable
def test_failsfast_lockedtransfer_exceeding_distributable(
raiden_network,
token_addresses,
deposit,
):
app0, app1 = raiden_network
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
result = app0.raiden.mediated_transfer_async(
token_network_identifier,
deposit * 2,
app1.raiden.address,
identifier=1,
)
assert result.successful()
assert result.get_nowait() is False
assert_synced_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
示例4: token_network_connect
def token_network_connect(
self,
registry_address,
token_address,
funds,
initial_channel_target=3,
joinable_funds_target=.4,
):
"""Automatically maintain channels open for the given token network.
Args:
token_address (bin): the ERC20 token network to connect to.
funds (int): the amount of funds that can be used by the ConnectionMananger.
initial_channel_target (int): number of channels to open proactively.
joinable_funds_target (float): fraction of the funds that will be used to join
channels opened by other participants.
"""
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
connection_manager.connect(
funds,
initial_channel_target=initial_channel_target,
joinable_funds_target=joinable_funds_target,
)
示例5: test_close_channel_lack_of_balance_proof
def test_close_channel_lack_of_balance_proof(raiden_chain, deposit, token_addresses):
app0, app1 = raiden_chain
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
token_proxy = app0.raiden.chain.token(token_address)
initial_balance0 = token_proxy.balance_of(app0.raiden.address)
initial_balance1 = token_proxy.balance_of(app1.raiden.address)
amount = 100
identifier = 1
secret = pending_mediated_transfer(
raiden_chain,
token_network_identifier,
amount,
identifier,
)
# Stop app0 to avoid sending the unlock
app0.raiden.transport.stop_and_wait()
reveal_secret = RevealSecret(
random.randint(0, UINT64_MAX),
secret,
)
app0.raiden.sign(reveal_secret)
message_handler.on_message(app1.raiden, reveal_secret)
RaidenAPI(app0.raiden).channel_close(
app0.raiden.default_registry.address,
token_address,
app1.raiden.address,
)
channel_state = get_channelstate(app0, app1, token_network_identifier)
waiting.wait_for_settle(
app0.raiden,
app0.raiden.default_registry.address,
token_address,
[channel_state.identifier],
app0.raiden.alarm.sleep_time,
)
# wait for the node to call batch unlock
with gevent.Timeout(10):
wait_for_batch_unlock(
app0,
token_network_identifier,
channel_state.partner_state.address,
channel_state.our_state.address,
)
expected_balance0 = initial_balance0 + deposit - amount
expected_balance1 = initial_balance1 + deposit + amount
assert token_proxy.balance_of(app0.raiden.address) == expected_balance0
assert token_proxy.balance_of(app1.raiden.address) == expected_balance1
示例6: test_direct_transfer
def test_direct_transfer(raiden_network, token_addresses, deposit, network_wait):
token_address = token_addresses[0]
app0, app1 = raiden_network
amount = 10
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,
)
direct_transfer(
app0,
app1,
token_network_identifier,
amount,
timeout=network_wait,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit - amount, [],
app1, deposit + amount, [],
)
示例7: token_network_leave
def token_network_leave(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
) -> typing.List[NettingChannelState]:
""" Close all channels and wait for settlement. """
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address not in self.get_tokens_list(registry_address):
raise UnknownTokenAddress('token_address unknown')
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
return connection_manager.leave(registry_address)
示例8: test_mediated_transfer_events
def test_mediated_transfer_events(raiden_network, number_of_nodes, token_addresses, network_wait):
app0, app1, app2 = raiden_network
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 = 10
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
def test_initiator_events():
initiator_blockevents = app0.raiden.wal.storage.get_events_by_identifier(
from_identifier=0,
to_identifier='latest',
)
initiator_events = [blocknumber_event[1] for blocknumber_event in initiator_blockevents]
return (
must_contain_entry(initiator_events, SendRevealSecret, {}) and
must_contain_entry(initiator_events, EventUnlockSuccess, {})
)
assert wait_until(test_initiator_events, network_wait)
def test_mediator_events():
mediator_blockevents = app1.raiden.wal.storage.get_events_by_identifier(
from_identifier=0,
to_identifier='latest',
)
mediator_events = [blocknumber_event[1] for blocknumber_event in mediator_blockevents]
return (
must_contain_entry(mediator_events, EventUnlockSuccess, {}) and
must_contain_entry(mediator_events, EventUnlockClaimSuccess, {})
)
assert wait_until(test_mediator_events, network_wait)
def test_target_events():
target_blockevents = app2.raiden.wal.storage.get_events_by_identifier(
from_identifier=0,
to_identifier='latest',
)
target_events = [blocknumber_event[1] for blocknumber_event in target_blockevents]
return (
must_contain_entry(target_events, SendSecretRequest, {}) and
must_contain_entry(target_events, SendRevealSecret, {}) and
must_contain_entry(target_events, EventUnlockClaimSuccess, {})
)
assert wait_until(test_target_events, network_wait)
示例9: test_refund_messages
def test_refund_messages(raiden_chain, token_addresses, deposit):
# The network has the following topology:
#
# App0 <---> App1 <---> App2
app0, app1, app2 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = token_addresses[0]
payment_network_identifier = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
payment_network_identifier,
token_address,
)
# Exhaust the channel App1 <-> App2 (to force the refund transfer)
exhaust_amount = deposit
mediated_transfer(
initiator_app=app1,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=exhaust_amount,
identifier=1,
)
refund_amount = deposit // 2
identifier = 1
async_result = app0.raiden.mediated_transfer_async(
token_network_identifier,
refund_amount,
app2.raiden.address,
identifier,
)
assert async_result.wait() is False, 'Must fail, there are no routes available'
# The transfer from app0 to app2 failed, so the balances did change.
# Since the refund is not unlocked both channels have the corresponding
# amount locked (issue #1091)
send_lockedtransfer = raiden_events_must_contain_entry(
app0.raiden,
SendLockedTransfer,
{'transfer': {'lock': {'amount': refund_amount}}},
)
assert send_lockedtransfer
send_refundtransfer = raiden_events_must_contain_entry(app1.raiden, SendRefundTransfer, {})
assert send_refundtransfer
assert_synced_channel_state(
token_network_identifier,
app0, deposit, [send_lockedtransfer.transfer.lock],
app1, deposit, [send_refundtransfer.transfer.lock],
)
# This channel was exhausted to force the refund transfer
assert_synced_channel_state(
token_network_identifier,
app1, 0, [],
app2, deposit * 2, [],
)
示例10: test_receive_secrethashtransfer_unknown
def test_receive_secrethashtransfer_unknown(raiden_network, token_addresses):
app0 = raiden_network[0]
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
other_key = HOP1_KEY
other_address = HOP1
channel_identifier = make_channel_identifier()
amount = 10
refund_transfer_message = make_refund_transfer(
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel_identifier,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
amount=amount,
secrethash=UNIT_SECRETHASH,
)
sign_and_inject(refund_transfer_message, other_key, other_address, app0)
secret = Secret(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
channel_identifier=channel_identifier,
token_network_address=token_network_identifier,
transferred_amount=amount,
locked_amount=0,
locksroot=UNIT_SECRETHASH,
secret=UNIT_SECRET,
)
sign_and_inject(secret, other_key, other_address, app0)
secret_request_message = SecretRequest(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
secrethash=UNIT_SECRETHASH,
amount=1,
expiration=refund_transfer_message.lock.expiration,
)
sign_and_inject(secret_request_message, other_key, other_address, app0)
reveal_secret_message = RevealSecret(
message_identifier=random.randint(0, UINT64_MAX),
secret=UNIT_SECRET,
)
sign_and_inject(reveal_secret_message, other_key, other_address, app0)
示例11: channel_batch_close
def channel_batch_close(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_addresses: typing.List[typing.Address],
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
):
"""Close a channel opened with `partner_address` for the given
`token_address`.
Race condition, this can fail if channel was closed externally.
"""
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel close')
if not all(map(is_binary_address, partner_addresses)):
raise InvalidAddress('Expected binary address format for partner in channel close')
valid_tokens = views.get_token_network_addresses_for(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
)
if token_address not in valid_tokens:
raise UnknownTokenAddress('Token address is not known.')
chain_state = views.state_from_raiden(self.raiden)
channels_to_close = views.filter_channels_by_partneraddress(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_addresses=partner_addresses,
)
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
for channel_state in channels_to_close:
channel_close = ActionChannelClose(
token_network_identifier=token_network_identifier,
channel_identifier=channel_state.identifier,
)
self.raiden.handle_state_change(channel_close)
channel_ids = [channel_state.identifier for channel_state in channels_to_close]
waiting.wait_for_close(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
channel_ids=channel_ids,
retry_timeout=retry_timeout,
)
示例12: test_settle_is_automatically_called
def test_settle_is_automatically_called(raiden_network, token_addresses, deposit):
"""Settle is automatically called by one of the nodes."""
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
app0.raiden.default_registry.address,
token_address,
)
channel_identifier = get_channelstate(app0, app1, token_network_identifier).identifier
# A ChannelClose event will be generated, this will be polled by both apps
# and each must start a task for calling settle
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
waiting.wait_for_settle(
app0.raiden,
registry_address,
token_address,
[channel_identifier],
app0.raiden.alarm.sleep_time,
)
assert_synched_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
state_changes = app0.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
channel_state = get_channelstate(app0, app1, token_network_identifier)
assert channel_state.close_transaction.finished_block_number
assert channel_state.settle_transaction.finished_block_number
assert must_contain_entry(state_changes, ContractReceiveChannelClosed, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel_identifier,
'closing_address': app1.raiden.address,
'closed_block_number': channel_state.close_transaction.finished_block_number,
})
assert must_contain_entry(state_changes, ContractReceiveChannelSettled, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel_identifier,
'settle_block_number': channel_state.settle_transaction.finished_block_number,
})
示例13: test_locked_transfer_secret_registered_onchain
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
示例14: test_received_directtransfer_closedchannel
def test_received_directtransfer_closedchannel(raiden_network, token_addresses, deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
registry_address = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
registry_address,
token_address,
)
channel0 = get_channelstate(app0, app1, token_network_identifier)
RaidenAPI(app1.raiden).channel_close(
registry_address,
token_address,
app0.raiden.address,
)
wait_until_block(
app0.raiden.chain,
app0.raiden.chain.block_number() + 1,
)
# Now receive one direct transfer for the closed channel
message_identifier = random.randint(0, UINT64_MAX)
direct_transfer_message = DirectTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=message_identifier,
payment_identifier=1,
nonce=1,
token_network_address=token_network_identifier,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=10,
locked_amount=0,
recipient=app0.raiden.address,
locksroot=EMPTY_MERKLE_ROOT,
)
sign_and_inject(
direct_transfer_message,
app0.raiden.private_key,
app0.raiden.address,
app1,
)
# The local state must not change since the channel is already closed
assert_synched_channel_state(
token_network_identifier,
app0, deposit, [],
app1, deposit, [],
)
示例15: transfer_async
def transfer_async(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
amount: typing.TokenAmount,
target: typing.Address,
identifier: typing.PaymentID = None,
):
if not isinstance(amount, int):
raise InvalidAmount('Amount not a number')
if amount <= 0:
raise InvalidAmount('Amount negative')
if not is_binary_address(token_address):
raise InvalidAddress('token address is not valid.')
if not is_binary_address(target):
raise InvalidAddress('target address is not valid.')
valid_tokens = views.get_token_network_addresses_for(
views.state_from_raiden(self.raiden),
registry_address,
)
if token_address not in valid_tokens:
raise UnknownTokenAddress('Token address is not known.')
log.debug(
'Initiating transfer',
initiator=pex(self.raiden.address),
target=pex(target),
token=pex(token_address),
amount=amount,
identifier=identifier,
)
payment_network_identifier = self.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=payment_network_identifier,
token_address=token_address,
)
async_result = self.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=target,
identifier=identifier,
)
return async_result