本文整理汇总了Python中raiden.utils.pex函数的典型用法代码示例。如果您正苦于以下问题:Python pex函数的具体用法?Python pex怎么用?Python pex使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了pex函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _receive_delivered
def _receive_delivered(self, delivered: Delivered):
# FIXME: The signature doesn't seem to be verified - check in UDPTransport as well
self._raiden_service.handle_state_change(
ReceiveDelivered(delivered.delivered_message_identifier),
)
async_result = self._messageids_to_asyncresult.pop(
delivered.delivered_message_identifier,
None,
)
if async_result is not None:
async_result.set(True)
self.log.debug(
'DELIVERED MESSAGE RECEIVED',
node=pex(self._raiden_service.address),
receiver=pex(delivered.sender),
message_identifier=delivered.delivered_message_identifier,
)
else:
self.log.debug(
'DELIVERED MESSAGE UNKNOWN',
node=pex(self._raiden_service.address),
message_identifier=delivered.delivered_message_identifier,
)
示例2: __repr__
def __repr__(self):
return '<{} [hashlock:{} amount:{} hash:{}]>'.format(
self.__class__.__name__,
pex(self.hashlock),
self.amount,
pex(self.hash),
)
示例3: transfer
def transfer(self, to_address, amount):
log_details = {
'node': pex(self.node_address),
'contract': pex(self.address),
'to_address': pex(to_address),
'amount': amount,
}
log.debug('transfer called', **log_details)
startgas = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL
transaction_hash = self.proxy.transact(
'transfer',
safe_gas_limit(startgas),
to_checksum_address(to_address),
amount,
)
self.client.poll(transaction_hash)
receipt_or_none = check_transaction_threw(self.client, transaction_hash)
if receipt_or_none:
log.critical('transfer failed', **log_details)
raise TransactionThrew('Transfer', receipt_or_none)
# TODO: check Transfer event (issue: #2598)
log.info('transfer successful', **log_details)
示例4: register_transfer
def register_transfer(self, block_number, transfer):
""" Register a signed transfer, updating the channel's state accordingly. """
if transfer.sender == self.our_state.address:
self.register_transfer_from_to(
block_number,
transfer,
from_state=self.our_state,
to_state=self.partner_state,
)
self.sent_transfers.append(transfer)
elif transfer.sender == self.partner_state.address:
self.register_transfer_from_to(
block_number,
transfer,
from_state=self.partner_state,
to_state=self.our_state,
)
self.received_transfers.append(transfer)
else:
if log.isEnabledFor(logging.WARN):
log.warn(
'Received a transfer from party that is not a part of the channel',
node=self.our_state.address,
from_=pex(transfer.sender),
channel=pex(transfer.channel)
)
raise UnknownAddress(transfer)
示例5: unlock
def unlock(self, our_address, unlock_proofs):
# force a list to get the length (could be a generator)
unlock_proofs = list(unlock_proofs)
log.info(
'%s locks to unlock',
len(unlock_proofs),
contract=pex(self.address),
)
for merkle_proof, locked_encoded, secret in unlock_proofs:
if isinstance(locked_encoded, messages.Lock):
raise ValueError('unlock must be called with a lock encoded `.as_bytes`')
merkleproof_encoded = ''.join(merkle_proof)
transaction_hash = self.proxy.unlock.transact(
locked_encoded,
merkleproof_encoded,
secret,
startgas=self.startgas,
gasprice=self.gasprice,
)
self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout)
# TODO: check if the ChannelSecretRevealed event was emitted and if
# it wasn't raise an error
# if log.getEffectiveLevel() >= logging.INFO: # only decode the lock if need to
lock = messages.Lock.from_bytes(locked_encoded)
log.info(
'unlock called',
contract=pex(self.address),
lock=lock,
secret=encode_hex(secret),
)
示例6: register_locked_transfer
def register_locked_transfer(self, locked_transfer):
if not isinstance(locked_transfer, LockedTransfer):
raise ValueError('transfer must be LockedTransfer')
lock = locked_transfer.lock
lockhashed = sha3(lock.as_bytes)
if self.is_known(lock.hashlock):
raise ValueError('hashlock is already registered')
merkletree = self.unclaimed_merkletree()
merkletree.append(lockhashed)
new_locksroot = merkleroot(merkletree)
if locked_transfer.locksroot != new_locksroot:
raise ValueError(
'locksroot mismatch expected:{} got:{}'.format(
pex(new_locksroot),
pex(locked_transfer.locksroot),
)
)
self.hashlock_pendinglocks[lock.hashlock] = PendingLock(lock, lockhashed)
self.transfer = locked_transfer
self.hashlock_unlockedlocks = dict()
示例7: receive
def receive(self, data):
# ignore large packets
if len(data) > self.max_message_size:
log.error('receive packet larger than maximum size', length=len(data))
return
msghash = sha3(data)
# check if we handled this message already, if so repeat Ack
if msghash in self.sent_acks:
return self.send_ack(*self.sent_acks[msghash])
# We ignore the sending endpoint as this can not be known w/ UDP
msg = messages.decode(data)
if isinstance(msg, Ack):
# we might receive the same Ack more than once
if msg.echo in self.number_of_tries:
log.debug('ACK RECEIVED {} [echo={}]'.format(
pex(self.raiden.address),
pex(msg.echo)
))
del self.number_of_tries[msg.echo]
else:
log.debug('DUPLICATED ACK RECEIVED {} [echo={}]'.format(
pex(self.raiden.address),
pex(msg.echo)
))
else:
assert isinstance(msg, Secret) or msg.sender
self.raiden.on_message(msg, msghash)
示例8: _repeat_until_ack
def _repeat_until_ack(self, receiver_address, msg):
data = msg.encode()
host_port = self.discovery.get(receiver_address)
# msghash is removed from the `number_of_tries` once a Ack is
# received, resend until we receive it or give up
msghash = sha3(data)
self.number_of_tries[msghash] = 0
log.info('SENDING {} > {} : [{}] {}'.format(
pex(self.raiden.address),
pex(receiver_address),
pex(msghash),
msg,
))
while msghash in self.number_of_tries:
if self.number_of_tries[msghash] > self.max_tries:
# FIXME: suspend node + recover from the failure
raise Exception('DEACTIVATED MSG resents {} {}'.format(
pex(receiver_address),
msg,
))
self.number_of_tries[msghash] += 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
示例9: _run
def _run(self): # pylint: disable=method-hidden
transfer = self.originating_transfer
assetmanager = self.transfermanager.assetmanager
raiden = assetmanager.raiden
transfer_details = '{} -> {} hash:{}'.format(
pex(transfer.target),
pex(transfer.initiator),
pex(transfer.hash),
)
log.debug('END MEDIATED TRANSFER {}'.format(transfer_details))
secret_request = SecretRequest(transfer.lock.hashlock)
raiden.sign(secret_request)
raiden.send(transfer.initiator, secret_request)
self.event = AsyncResult()
response = self.event.wait(raiden.config['msg_timeout'])
if response is None:
log.error('SECRETREQUEST TIMED OUT!')
self.transfermanager.on_hashlock_result(transfer.hashlock, False)
return
if not isinstance(response, Secret):
raise Exception('Invalid message received.')
if sha3(response.secret) != transfer.lock.hashlock:
raise Exception('Invalid secret received.')
# update all channels and propagate the secret
assetmanager.register_secret(response.secret)
self.transfermanager.on_hashlock_result(transfer.lock.hashlock, True)
示例10: register_endpoint
def register_endpoint(self, node_address, endpoint):
if node_address != self.client.address:
raise ValueError("node_address doesnt match this node's address")
log_details = {
'node': pex(self.node_address),
'node_address': pex(node_address),
'endpoint': endpoint,
}
log.debug('registerEndpoint called', **log_details)
transaction_hash = self.proxy.transact(
'registerEndpoint',
safe_gas_limit(GAS_REQUIRED_FOR_ENDPOINT_REGISTER),
endpoint,
)
self.client.poll(transaction_hash)
receipt_or_none = check_transaction_threw(self.client, transaction_hash)
if receipt_or_none:
log.critical('registerEndpoint failed', **log_details)
raise TransactionThrew('Register Endpoint', receipt_or_none)
log.debug('registerEndpoint successful', **log_details)
示例11: receive
def receive(self, messagedata: bytes):
""" Handle an UDP packet. """
# pylint: disable=unidiomatic-typecheck
if len(messagedata) > self.UDP_MAX_MESSAGE_SIZE:
log.error(
'INVALID MESSAGE: Packet larger than maximum size',
node=pex(self.raiden.address),
message=hexlify(messagedata),
length=len(messagedata),
)
return
message = decode(messagedata)
if type(message) == Pong:
self.receive_pong(message)
elif type(message) == Ping:
self.receive_ping(message)
elif type(message) == Delivered:
self.receive_delivered(message)
elif message is not None:
self.receive_message(message)
else:
log.error(
'INVALID MESSAGE: Unknown cmdid',
node=pex(self.raiden.address),
message=hexlify(messagedata),
)
示例12: __repr__
def __repr__(self):
return '<ReceiveSecretRequest paymentid:{} amount:{} secrethash:{} sender:{}>'.format(
self.payment_identifier,
self.amount,
pex(self.secrethash),
pex(self.sender),
)
示例13: __init__
def __init__(self, expected_locksroot, got_locksroot):
msg = 'Locksroot mismatch. Expected {} but got {}'.format(
pex(expected_locksroot),
pex(got_locksroot),
)
super(InvalidLocksRoot, self).__init__(msg)
示例14: join_channel
def join_channel(self, partner_address, partner_deposit):
"""Will be called, when we were selected as channel partner by another
node. It will fund the channel with up to the partners deposit, but
not more than remaining funds or the initial funding per channel.
If the connection manager has no funds, this is a noop.
"""
with self.lock:
joining_funds = min(
partner_deposit,
self._funds_remaining,
self._initial_funding_per_partner,
)
if joining_funds <= 0 or self._leaving_state:
return
self.api.set_total_channel_deposit(
self.registry_address,
self.token_address,
partner_address,
joining_funds,
)
log.debug(
'joined a channel!',
funds=joining_funds,
me=pex(self.raiden.address),
partner=pex(partner_address),
)
示例15: add_token
def add_token(self, token_address):
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
transaction_hash = estimate_and_transact(
self.proxy,
'addToken',
self.startgas,
self.gasprice,
token_address,
)
self.client.poll(unhexlify(transaction_hash), timeout=self.poll_timeout)
receipt_or_none = check_transaction_threw(self.client, transaction_hash)
if receipt_or_none:
raise TransactionThrew('AddToken', receipt_or_none)
manager_address = self.manager_address_by_token(token_address)
if manager_address is None:
log.error('Transaction failed and check_transaction_threw didnt detect it')
raise RuntimeError('channelManagerByToken failed')
if log.isEnabledFor(logging.INFO):
log.info(
'add_token called',
token_address=pex(token_address),
registry_address=pex(self.address),
manager_address=pex(manager_address),
)
return manager_address