def __init__(
self,
config: Dict,
chain: BlockChainService,
default_registry: Registry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
try:
self.raiden = RaidenService(
chain,
default_registry,
default_secret_registry,
unhexlify(config['privatekey_hex']),
transport,
config,
discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(
self.config['privatekey_hex'])), )
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}', )
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
if config.get('socket'):
transport = transport_class(
None,
None,
socket=config['socket'],
)
else:
transport = transport_class(
config['host'],
config['port'],
)
transport.throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'])
self.raiden = RaidenService(
chain,
decode_hex(config['privatekey_hex']),
transport,
discovery,
config,
)
self.start_console = self.config['console']
def handle_message_crosstransaction(raiden: RaidenService,
message: Crosstransaction):
cross_type = message.cross_type
if cross_type == 1:
raiden.wal.create_crosstransactiontry(
message.initiator_address, message.target_address,
message.token_network_identifier, message.sendETH_amount,
message.sendBTC_amount, message.receiveBTC_address,
message.identifier)
raiden.wal.change_crosstransaction_status(message.identifier, 2)
accept = 1
acceptcross = AcceptCross(random.randint(0, UINT64_MAX),
message.initiator_address,
message.target_address, message.identifier,
accept)
raiden.sign(acceptcross)
raiden.transport.send_async(
message.initiator_address,
bytes("123", 'utf-8'),
acceptcross,
)
else:
message.cross_type = 1
async_result = raiden.start_crosstransaction(
message.token_network_identifier, message.initiator_address,
message.target_address, message.sendETH_amount,
message.sendBTC_amount, message.receiveBTC_address,
message.cross_type, message.identifier)
def start(
self,
raiden: RaidenService,
queueids_to_queues: typing.Dict[typing.QueueIdentifier,
typing.List[Event]],
):
self.raiden = raiden
self.queueids_to_queues = dict()
# server.stop() clears the handle. Since this may be a restart the
# handle must always be set
self.server.set_handle(self._receive)
for queue_identifier, queue in queueids_to_queues.items():
encoded_queue = list()
for sendevent in queue:
message = message_from_sendevent(sendevent, raiden.address)
raiden.sign(message)
encoded = message.encode()
encoded_queue.append((encoded, sendevent.message_identifier))
self.init_queue_for(queue_identifier, encoded_queue)
self.server.start()
def start(
self,
raiden: RaidenService,
queueids_to_queues: typing.Dict[QueueIdentifier, typing.List[Event]],
):
if not self.event_stop.ready():
raise RuntimeError('UDPTransport started while running')
self.event_stop.clear()
self.raiden = raiden
self.queueids_to_queues = dict()
# server.stop() clears the handle. Since this may be a restart the
# handle must always be set
self.server.set_handle(self._receive)
for queue_identifier, queue in queueids_to_queues.items():
encoded_queue = list()
for sendevent in queue:
message = message_from_sendevent(sendevent, raiden.address)
raiden.sign(message)
encoded = message.encode()
encoded_queue.append((encoded, sendevent.message_identifier))
self.init_queue_for(queue_identifier, encoded_queue)
self.server.start()
super().start()
def __init__(self, config, chain, default_registry, discovery, transport):
self.config = config
self.discovery = discovery
try:
self.raiden = RaidenService(
chain,
default_registry,
unhexlify(config['privatekey_hex']),
transport,
discovery,
config,
)
except filelock.Timeout:
pubkey = privatekey_to_address(
unhexlify(self.config['privatekey_hex']))
print(
'FATAL: Another Raiden instance already running for account 0x%s'
% hexlify(str(pubkey)))
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
message.sender,
routes,
from_transfer,
secret,
)
else:
state_change = ReceiveTransferRefund(
message.sender,
from_transfer,
routes,
)
raiden.handle_state_change(state_change)
def __init__(self, config, chain, default_registry, transport, discovery=None):
register_error_handler(greenlet_error_handler)
self.config = config
self.discovery = discovery
try:
self.raiden = RaidenService(
chain,
default_registry,
unhexlify(config['privatekey_hex']),
transport,
config,
discovery,
)
except filelock.Timeout:
pubkey = address_encoder(
privatekey_to_address(unhexlify(self.config['privatekey_hex']))
)
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}'
)
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def handle_message_crosslockedtransfer(raiden: RaidenService,
message: CrossLockedTransfer):
locked_transfer_message = LockedTransfer(
message.chain_id, message.message_identifier,
message.payment_identifier, message.nonce,
message.token_network_address, message.token, message.channel,
message.transferred_amount, message.locked_amount, message.recipient,
message.locksroot, message.lock, message.target, message.initiator,
message.fee)
#locked_transfer_message.sender = message.sender
locked_transfer_message.signature = message.locked_transfer_signature
if message.target == raiden.address:
raiden.cross_handle_recieved_locked_transfer(locked_transfer_message,
message.cross_id)
raiden.wal.change_crosstransaction_status(message.cross_id, 4)
raiden.wal.storage.change_crosstransaction_r(
message.cross_id,
encode_hex(locked_transfer_message.lock.secrethash), "")
#to do send lnd string to lnd
lnd_string = message.lnd_string.decode('utf-8')
raiden.send_payment_request(lnd_string)
else:
handle_message_lockedtransfer(raiden, locked_transfer_message)
def handle_message_refundtransfer(self, raiden: RaidenService,
message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
routes=routes,
transfer=from_transfer,
secret=secret,
)
else:
state_change = ReceiveTransferRefund(
transfer=from_transfer,
routes=routes,
)
raiden.handle_state_change(state_change)
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
if config.get('socket'):
transport = transport_class(
None,
None,
socket=config['socket'],
)
else:
transport = transport_class(
config['host'],
config['port'],
)
transport.throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'])
self.raiden = RaidenService(
chain,
decode_hex(config['privatekey_hex']),
transport,
discovery,
config,
)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
class App(object): # pylint: disable=too-few-public-methods
default_config = dict(
host='',
port=INITIAL_PORT,
privatekey_hex='',
# number of blocks that a node requires to learn the secret before the lock expires
reveal_timeout=DEFAULT_REVEAL_TIMEOUT,
settle_timeout=DEFAULT_SETTLE_TIMEOUT,
# how long to wait for a transfer until TimeoutTransfer is sent (time in milliseconds)
msg_timeout=100.00,
)
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
self.transport = transport_class(config['host'], config['port'])
self.raiden = RaidenService(
chain,
decode_hex(config['privatekey_hex']),
self.transport,
discovery,
config,
)
self.services = {'raiden': self.raiden}
self.start_console = True
def __repr__(self):
return '<{} {}>'.format(
self.__class__.__name__,
pex(self.raiden.address),
)
def stop(self):
self.transport.stop()
self.raiden.stop()
def start(
self,
raiden: RaidenService,
queueids_to_queues: typing.List[SendMessageEvent],
):
self.raiden = raiden
self.queueids_to_queues = dict()
# server.stop() clears the handle. Since this may be a restart the
# handle must always be set
self.server.set_handle(self._receive)
for (recipient, queue_name), queue in queueids_to_queues.items():
encoded_queue = list()
for sendevent in queue:
message = message_from_sendevent(sendevent, raiden.address)
raiden.sign(message)
encoded = message.encode()
encoded_queue.append((encoded, sendevent.message_identifier))
self.init_queue_for(recipient, queue_name, encoded_queue)
self.server.start()
def handle_tokennetwork_new(raiden: RaidenService, event: Event):
""" Handles a `TokenNetworkCreated` event. """
data = event.event_data
args = data['args']
block_number = data['block_number']
token_network_address = args['token_network_address']
token_address = typing.TokenAddress(args['token_address'])
token_network_proxy = raiden.chain.token_network(token_network_address)
raiden.blockchain_events.add_token_network_listener(
token_network_proxy=token_network_proxy,
contract_manager=raiden.contract_manager,
from_block=block_number,
)
token_network_state = TokenNetworkState(
token_network_address,
token_address,
)
transaction_hash = event.event_data['transaction_hash']
new_token_network = ContractReceiveNewTokenNetwork(
transaction_hash=transaction_hash,
payment_network_identifier=event.originating_contract,
token_network=token_network_state,
block_number=block_number,
)
raiden.handle_state_change(new_token_network)
def handle_channel_closed(raiden: RaidenService, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
block_number = data['block_number']
args = data['args']
channel_identifier = args['channel_identifier']
transaction_hash = data['transaction_hash']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=args['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
route_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(route_closed)
class App(object): # pylint: disable=too-few-public-methods
default_config = dict(
host='',
port=INITIAL_PORT,
privatekey_hex='',
# number of blocks that a node requires to learn the secret before the lock expires
reveal_timeout=DEFAULT_REVEAL_TIMEOUT,
settle_timeout=DEFAULT_SETTLE_TIMEOUT,
# how long to wait for a transfer until TimeoutTransfer is sent (time in milliseconds)
msg_timeout=100.00,
)
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
self.transport = transport_class(config['host'], config['port'])
self.raiden = RaidenService(
chain,
config['privatekey_hex'].decode('hex'),
self.transport,
discovery,
config,
)
self.services = {'raiden': self.raiden}
self.start_console = True
def __repr__(self):
return '<{} {}>'.format(
self.__class__.__name__,
pex(self.raiden.address),
)
def stop(self):
self.transport.stop()
self.raiden.stop()
def handle_message_revealsecret(self, raiden: RaidenService,
message: RevealSecret):
state_change = ReceiveSecretReveal(
message.secret,
message.sender,
)
raiden.handle_state_change(state_change)
def handle_message_lockedtransfer(raiden: RaidenService,
message: LockedTransfer):
secret_hash = message.lock.secrethash
# We must check if the secret was registered against the latest block,
# even if the block is forked away and the transaction that registers
# the secret is removed from the blockchain. The rationale here is that
# someone else does know the secret, regardless of the chain state, so
# the node must not use it to start a payment.
#
# For this particular case, it's preferable to use `latest` instead of
# having a specific block_hash, because it's preferable to know if the secret
# was ever known, rather than having a consistent view of the blockchain.
registered = raiden.default_secret_registry.is_secret_registered(
secrethash=secret_hash,
block_identifier='latest',
)
if registered:
log.warning(
f'Ignoring received locked transfer with secrethash {pex(secret_hash)} '
f'since it is already registered in the secret registry', )
return
if message.target == raiden.address:
raiden.target_mediated_transfer(message)
else:
raiden.mediate_mediated_transfer(message)
class App(object): # pylint: disable=too-few-public-methods
default_config = dict(
host='',
port=INITIAL_PORT,
privatekey_hex='',
# number of blocks that a node requires to learn the secret before the lock expires
reveal_timeout=DEFAULT_REVEAL_TIMEOUT,
settle_timeout=DEFAULT_SETTLE_TIMEOUT,
# how long to wait for a transfer until TimeoutTransfer is sent (time in milliseconds)
msg_timeout=100.00,
# throttle policy for token bucket
throttle_capacity=10.,
throttle_fill_rate=10.,
rpc=True,
console=False,
)
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
if config.get('socket'):
self.transport = transport_class(None,
None,
socket=config['socket'])
else:
self.transport = transport_class(config['host'], config['port'])
self.transport.throttle_policy = TokenBucket(
config['throttle_capacity'], config['throttle_fill_rate'])
self.raiden = RaidenService(
chain,
decode_hex(config['privatekey_hex']),
self.transport,
discovery,
config,
)
self.services = {'raiden': self.raiden}
self.start_console = self.config['console']
def __repr__(self):
return '<{} {}>'.format(
self.__class__.__name__,
pex(self.raiden.address),
)
def stop(self, graceful=False):
"""Stop the raiden app.
Args:
graceful (bool): if True, also close and settle all channels before stopping
"""
if graceful:
self.raiden.close_and_settle()
self.raiden.stop()
# The transport must be stopped after the protocol. The protocol can be
# running multiple threads of execution and it expects the protocol to
# be available.
self.transport.stop()
def handle_message_secret(self, raiden: RaidenService, message: Secret):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveUnlock(
message_identifier=message.message_identifier,
secret=message.secret,
balance_proof=balance_proof,
)
raiden.handle_state_change(state_change)
def handle_message_secretrequest(raiden: RaidenService, message: SecretRequest):
secret_request = ReceiveSecretRequest(
message.payment_identifier,
message.amount,
message.secrethash,
message.sender,
)
raiden.handle_state_change(secret_request)
def handle_message_unlock(raiden: RaidenService, message: Unlock) -> None:
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveUnlock(
message_identifier=message.message_identifier,
secret=message.secret,
balance_proof=balance_proof,
)
raiden.handle_and_track_state_change(state_change)
def handle_message_secret(raiden: RaidenService, message: Secret):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveUnlock(
message_identifier=message.message_identifier,
secret=message.secret,
balance_proof=balance_proof,
)
raiden.handle_state_change(state_change)
def handle_message_secretrequest(raiden: RaidenService,
message: SecretRequest):
secret_request = ReceiveSecretRequest(
message.payment_identifier,
message.amount,
message.secrethash,
message.sender,
)
raiden.handle_state_change(secret_request)
def handle_message_acceptcross(raiden: RaidenService, message: AcceptCross):
# for sync
if message.accept == 7:
raiden.wal.change_crosstransaction_status(message.identifier, 8)
log.info('##sync received')
return
raiden.wal.change_crosstransaction_status(message.identifier, 3)
raiden.start_send_crosstansfer(message.identifier)
def handle_message_processed(cls,
raiden: RaidenService,
message: Processed,
is_light_client: bool = False) -> None:
processed = ReceiveProcessed(message.sender,
message.message_identifier)
raiden.handle_and_track_state_change(processed)
if is_light_client:
LightClientMessageHandler.store_lc_processed(message, raiden.wal)
def handle_message_lockexpired(self, raiden: RaidenService,
message: LockExpired):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveLockExpired(
balance_proof=balance_proof,
secrethash=message.secrethash,
message_identifier=message.message_identifier,
)
raiden.handle_state_change(state_change)
def handle_message_delivered(cls,
raiden: RaidenService,
message: Delivered,
is_light_client: bool = False) -> None:
delivered = ReceiveDelivered(message.sender,
message.delivered_message_identifier)
raiden.handle_and_track_state_change(delivered)
if is_light_client:
LightClientMessageHandler.store_lc_delivered(message, raiden.wal)
def handle_message_revealsecret(raiden: RaidenService,
message: RevealSecret,
is_light_client=False) -> None:
if is_light_client:
state_change = ReceiveSecretRevealLight(message.secret,
message.sender, message)
raiden.handle_and_track_state_change(state_change)
else:
state_change = ReceiveSecretReveal(message.secret, message.sender)
raiden.handle_and_track_state_change(state_change)
def handle_channel_new(raiden: RaidenService, event: Event):
data = event.event_data
block_number = data['block_number']
args = data['args']
token_network_identifier = event.originating_contract
transaction_hash = event.event_data['transaction_hash']
channel_identifier = args['channel_identifier']
participant1 = args['participant1']
participant2 = args['participant2']
is_participant = raiden.address in (participant1, participant2)
# Raiden node is participant
if is_participant:
channel_proxy = raiden.chain.payment_channel(
token_network_identifier,
channel_identifier,
)
token_address = channel_proxy.token_address()
channel_state = get_channel_state(
token_address,
raiden.default_registry.address,
token_network_identifier,
raiden.config['reveal_timeout'],
channel_proxy,
block_number,
)
new_channel = ContractReceiveChannelNew(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_state=channel_state,
block_number=block_number,
)
raiden.handle_state_change(new_channel)
partner_address = channel_state.partner_state.address
if ConnectionManager.BOOTSTRAP_ADDR != partner_address:
raiden.start_health_check_for(partner_address)
# Raiden node is not participant of channel
else:
new_route = ContractReceiveRouteNew(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
participant1=participant1,
participant2=participant2,
block_number=block_number,
)
raiden.handle_state_change(new_route)
# A new channel is available, run the connection manager in case more
# connections are needed
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier)
retry_connect = gevent.spawn(connection_manager.retry_connect)
raiden.add_pending_greenlet(retry_connect)
def handle_message_directtransfer(raiden: RaidenService, message: DirectTransfer):
token_network_identifier = message.token_network_address
balance_proof = balanceproof_from_envelope(message)
direct_transfer = ReceiveTransferDirect(
token_network_identifier,
message.message_identifier,
message.payment_identifier,
balance_proof,
)
raiden.handle_state_change(direct_transfer)
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
self.transport = transport_class(config['host'], config['port'])
self.raiden = RaidenService(
chain,
decode_hex(config['privatekey_hex']),
self.transport,
discovery,
config,
)
self.services = {'raiden': self.raiden}
self.start_console = True
def handle_message_lockedtransfer(self, raiden: RaidenService,
message: LockedTransfer):
secret_hash = message.lock.secrethash
if raiden.default_secret_registry.check_registered(secret_hash):
log.warning(
f'Ignoring received locked transfer with secrethash {pex(secret_hash)} '
f'since it is already registered in the secret registry', )
return
if message.target == raiden.address:
raiden.target_mediated_transfer(message)
else:
raiden.mediate_mediated_transfer(message)
def handle_message_directtransfer(self, raiden: RaidenService,
message: DirectTransfer):
token_network_identifier = message.token_network_address
balance_proof = balanceproof_from_envelope(message)
direct_transfer = ReceiveTransferDirect(
token_network_identifier,
message.message_identifier,
message.payment_identifier,
balance_proof,
)
raiden.handle_state_change(direct_transfer)
def handle_channel_new_balance(raiden: RaidenService, event: Event):
data = event.event_data
args = data['args']
block_number = data['block_number']
channel_identifier = args['channel_identifier']
token_network_identifier = event.originating_contract
participant_address = args['participant']
total_deposit = args['total_deposit']
transaction_hash = data['transaction_hash']
previous_channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
# Channels will only be registered if this node is a participant
is_participant = previous_channel_state is not None
if is_participant:
assert previous_channel_state is not None
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
deposit_transaction = TransactionChannelNewBalance(
participant_address,
total_deposit,
block_number,
)
newbalance_statechange = ContractReceiveChannelNewBalance(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
deposit_transaction=deposit_transaction,
block_number=block_number,
)
raiden.handle_state_change(newbalance_statechange)
if balance_was_zero and participant_address != raiden.address:
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier, )
join_channel = gevent.spawn(
connection_manager.join_channel,
participant_address,
total_deposit,
)
raiden.add_pending_greenlet(join_channel)
def __init__(
self,
config: Dict,
chain: BlockChainService,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (config['settle_timeout'] <
default_registry.settlement_timeout_min()
or config['settle_timeout'] >
default_registry.settlement_timeout_max())
if invalid_timeout:
raise InvalidSettleTimeout(
('Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}').format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
), )
try:
self.raiden = RaidenService(
chain,
default_registry,
default_secret_registry,
unhexlify(config['privatekey_hex']),
transport,
config,
discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(
self.config['privatekey_hex'])), )
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}', )
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __init__(self, config, chain, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
self.transport = transport_class(config['host'], config['port'])
self.raiden = RaidenService(
chain,
config['privatekey_hex'].decode('hex'),
self.transport,
discovery,
config,
)
self.services = {'raiden': self.raiden}
self.start_console = True
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max()
)
if invalid_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
try:
self.raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=unhexlify(config['privatekey_hex']),
transport=transport,
config=config,
discovery=discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(self.config['privatekey_hex'])),
)
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}',
)
sys.exit(1)
def __init__(self, config, chain, default_registry, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
if config.get('socket'):
transport = transport_class(
None,
None,
socket=config['socket'],
)
else:
transport = transport_class(
config['host'],
config['port'],
)
transport.throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate']
)
try:
self.raiden = RaidenService(
chain,
default_registry,
unhexlify(config['privatekey_hex']),
transport,
discovery,
config,
)
except filelock.Timeout:
pubkey = privatekey_to_address(unhexlify(self.config['privatekey_hex']))
print('FATAL: Another Raiden instance already running for account 0x%s' %
hexlify(str(pubkey)))
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def handle_message_lockedtransfer(raiden: RaidenService, message: LockedTransfer):
if message.target == raiden.address:
raiden.target_mediated_transfer(message)
else:
raiden.mediate_mediated_transfer(message)
def handle_message_processed(raiden: RaidenService, message: Processed):
processed = ReceiveProcessed(message.message_identifier)
raiden.handle_state_change(processed)
def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret):
state_change = ReceiveSecretReveal(
message.secret,
message.sender,
)
raiden.handle_state_change(state_change)
class App: # pylint: disable=too-few-public-methods
DEFAULT_CONFIG = {
'host': '',
'port': INITIAL_PORT,
'external_ip': '',
'external_port': INITIAL_PORT,
'privatekey_hex': '',
'reveal_timeout': DEFAULT_REVEAL_TIMEOUT,
'settle_timeout': DEFAULT_SETTLE_TIMEOUT,
'database_path': '',
'msg_timeout': 100.0,
'protocol': {
'retry_interval': DEFAULT_PROTOCOL_RETRY_INTERVAL,
'retries_before_backoff': DEFAULT_PROTOCOL_RETRIES_BEFORE_BACKOFF,
'throttle_capacity': DEFAULT_PROTOCOL_THROTTLE_CAPACITY,
'throttle_fill_rate': DEFAULT_PROTOCOL_THROTTLE_FILL_RATE,
'nat_invitation_timeout': DEFAULT_NAT_INVITATION_TIMEOUT,
'nat_keepalive_retries': DEFAULT_NAT_KEEPALIVE_RETRIES,
'nat_keepalive_timeout': DEFAULT_NAT_KEEPALIVE_TIMEOUT,
},
'rpc': True,
'console': False,
'shutdown_timeout': DEFAULT_SHUTDOWN_TIMEOUT,
}
def __init__(self, config, chain, default_registry, discovery, transport_class=UDPTransport):
self.config = config
self.discovery = discovery
if config.get('socket'):
transport = transport_class(
None,
None,
socket=config['socket'],
)
else:
transport = transport_class(
config['host'],
config['port'],
)
transport.throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate']
)
try:
self.raiden = RaidenService(
chain,
default_registry,
unhexlify(config['privatekey_hex']),
transport,
discovery,
config,
)
except filelock.Timeout:
pubkey = privatekey_to_address(unhexlify(self.config['privatekey_hex']))
print('FATAL: Another Raiden instance already running for account 0x%s' %
hexlify(str(pubkey)))
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __repr__(self):
return '<{} {}>'.format(
self.__class__.__name__,
pex(self.raiden.address),
)
def stop(self, leave_channels=False):
"""
Stop the raiden app.
Args:
leave_channels (bool): if True, also close and settle all channels before stopping
"""
if leave_channels:
self.raiden.close_and_settle()
self.raiden.stop()
class App: # pylint: disable=too-few-public-methods
DEFAULT_CONFIG = {
'host': '',
'port': INITIAL_PORT,
'external_ip': '',
'external_port': INITIAL_PORT,
'privatekey_hex': '',
'reveal_timeout': DEFAULT_REVEAL_TIMEOUT,
'settle_timeout': DEFAULT_SETTLE_TIMEOUT,
'database_path': '',
'msg_timeout': 100.0,
'transport': {
'retry_interval': DEFAULT_TRANSPORT_RETRY_INTERVAL,
'retries_before_backoff': DEFAULT_TRANSPORT_RETRIES_BEFORE_BACKOFF,
'throttle_capacity': DEFAULT_TRANSPORT_THROTTLE_CAPACITY,
'throttle_fill_rate': DEFAULT_TRANSPORT_THROTTLE_FILL_RATE,
'nat_invitation_timeout': DEFAULT_NAT_INVITATION_TIMEOUT,
'nat_keepalive_retries': DEFAULT_NAT_KEEPALIVE_RETRIES,
'nat_keepalive_timeout': DEFAULT_NAT_KEEPALIVE_TIMEOUT,
},
'rpc': True,
'console': False,
'shutdown_timeout': DEFAULT_SHUTDOWN_TIMEOUT,
'transport_type': 'udp',
'matrix': {
'server': 'auto',
'available_servers': [
'https://transport01.raiden.network',
'https://transport02.raiden.network',
'https://transport03.raiden.network',
],
'discovery_room': {
'alias_fragment': 'discovery',
'server': 'transport01.raiden.network',
},
},
}
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max()
)
if invalid_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
try:
self.raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=unhexlify(config['privatekey_hex']),
transport=transport,
config=config,
discovery=discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(self.config['privatekey_hex'])),
)
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}',
)
sys.exit(1)
def __repr__(self):
return '<{} {}>'.format(
self.__class__.__name__,
pex(self.raiden.address),
)
def stop(self, leave_channels: bool = False):
"""
Stop the raiden app.
Args:
leave_channels: if True, also close and settle all channels before stopping
"""
if leave_channels:
self.raiden.close_and_settle()
self.raiden.stop()
