def handle_channel_new_balance(raiden, event, current_block_number):
data = event.event_data
registry_address = data['registry_address']
channel_identifier = event.originating_contract
token_address = data['token_address']
participant_address = data['participant']
new_balance = data['balance']
deposit_block_number = data['block_number']
previous_channel_state = views.get_channelstate_by_tokenaddress(
views.state_from_raiden(raiden),
registry_address,
token_address,
channel_identifier,
)
# Channels will only be registered if this node is a participant
is_participant = previous_channel_state is not None
if is_participant:
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(raiden),
registry_address,
token_address,
)
deposit_transaction = TransactionChannelNewBalance(
participant_address,
new_balance,
deposit_block_number,
)
newbalance_statechange = ContractReceiveChannelNewBalance(
token_network_identifier,
channel_identifier,
deposit_transaction,
)
raiden.handle_state_change(newbalance_statechange,
current_block_number)
if balance_was_zero:
connection_manager = raiden.connection_manager_for_token(
registry_address,
token_address,
)
gevent.spawn(
connection_manager.join_channel,
registry_address,
participant_address,
new_balance,
)
def handle_channel_new_balance(raiden: 'RaidenService', event: Event):
data = event.event_data
args = data['args']
block_number = data['block_number']
block_hash = data['block_hash']
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']
chain_state = views.state_from_raiden(raiden)
previous_channel_state = views.get_channelstate_by_canonical_identifier(
chain_state=chain_state,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
)
# Channels will only be registered if this node is a participant
if 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,
canonical_identifier=previous_channel_state.canonical_identifier,
deposit_transaction=deposit_transaction,
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_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 handle_channel_new_balance(raiden, event: Event):
data = event.event_data
channel_identifier = data['channel_identifier']
token_network_identifier = event.originating_contract
participant_address = data['participant']
total_deposit = data['args']['total_deposit']
deposit_block_number = data['block_number']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
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:
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
deposit_transaction = TransactionChannelNewBalance(
participant_address,
total_deposit,
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=data['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 test_channelstate_repeated_contract_balance():
"""Handling the same blockchain event multiple times must change the
balance only once.
"""
deposit_block_number = 10
block_number = deposit_block_number + DEFAULT_NUMBER_OF_CONFIRMATIONS_BLOCK + 1
our_model1, _ = create_model(70)
partner_model1, _ = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
token_address = factories.make_address()
deposit_amount = 10
balance1_new = our_model1.balance + deposit_amount
deposit_transaction = TransactionChannelNewBalance(
our_model1.participant_address,
balance1_new,
deposit_block_number,
)
state_change = ContractReceiveChannelNewBalance(
payment_network_identifier,
token_address,
channel_state.identifier,
deposit_transaction,
)
our_model2 = our_model1._replace(
balance=balance1_new,
distributable=balance1_new,
contract_balance=balance1_new,
)
partner_model2 = partner_model1
pseudo_random_generator = random.Random()
for _ in range(10):
iteration = channel.state_transition(
deepcopy(channel_state),
state_change,
pseudo_random_generator,
block_number,
)
new_state = iteration.new_state
assert_partner_state(new_state.our_state, new_state.partner_state,
our_model2)
assert_partner_state(new_state.partner_state, new_state.our_state,
partner_model2)
def test_channelstate_update_contract_balance():
"""A blockchain event for a new balance must increase the respective
participants balance.
"""
deposit_block_number = 10
block_number = deposit_block_number + DEFAULT_NUMBER_OF_CONFIRMATIONS_BLOCK + 1
our_model1, _ = create_model(70)
partner_model1, _ = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
token_address = factories.make_address()
payment_network_identifier = factories.make_address()
deposit_amount = 10
balance1_new = our_model1.balance + deposit_amount
deposit_transaction = TransactionChannelNewBalance(
our_model1.participant_address,
balance1_new,
deposit_block_number,
)
state_change = ContractReceiveChannelNewBalance(
payment_network_identifier,
token_address,
channel_state.identifier,
deposit_transaction,
)
iteration = channel.state_transition(
deepcopy(channel_state),
state_change,
block_number,
)
new_state = iteration.new_state
our_model2 = our_model1._replace(
balance=balance1_new,
distributable=balance1_new,
contract_balance=balance1_new,
)
partner_model2 = partner_model1
assert_partner_state(new_state.our_state, new_state.partner_state,
our_model2)
assert_partner_state(new_state.partner_state, new_state.our_state,
partner_model2)
def test_channelstate_decreasing_contract_balance():
"""A blockchain event for a new balance that decrease the balance must be
ignored.
"""
deposit_block_number = 10
block_number = deposit_block_number + DEFAULT_NUMBER_OF_CONFIRMATIONS_BLOCK + 1
our_model1, _ = create_model(70)
partner_model1, _ = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
token_address = factories.make_address()
amount = 10
balance1_new = our_model1.balance - amount
deposit_transaction = TransactionChannelNewBalance(
our_model1.participant_address,
balance1_new,
deposit_block_number,
)
state_change = ContractReceiveChannelNewBalance(
payment_network_identifier,
token_address,
channel_state.identifier,
deposit_transaction,
)
pseudo_random_generator = random.Random()
iteration = channel.state_transition(
deepcopy(channel_state),
state_change,
pseudo_random_generator,
block_number,
)
new_state = iteration.new_state
assert_partner_state(new_state.our_state, new_state.partner_state,
our_model1)
assert_partner_state(new_state.partner_state, new_state.our_state,
partner_model1)
def test_transaction_order_ordering():
a = TransactionOrder(1, TransactionChannelNewBalance(bytes(1), 1, 1))
b = TransactionOrder(2, TransactionChannelNewBalance(bytes(2), 2, 2))
assert a != b
assert a < b
assert b > a
a = TransactionOrder(1, TransactionChannelNewBalance(bytes(1), 1, 1))
b = TransactionOrder(2, TransactionChannelNewBalance(bytes(2), 2, 1))
assert a != b
assert a < b
assert b > a
a = TransactionOrder(3, TransactionChannelNewBalance(bytes(3), 3, 3))
b = TransactionOrder(3, TransactionChannelNewBalance(bytes(3), 3, 3))
assert a == b
assert not a > b
assert not b > a
a = TransactionOrder(1, TransactionChannelNewBalance(bytes(1), 1, 1))
b = TransactionOrder(2, TransactionChannelNewBalance(bytes(1), 1, 1))
assert a != b
assert a < b
assert b > a
def test_transaction_channel_new_balance_ordering():
a = TransactionChannelNewBalance(bytes(1), 1, 1)
b = TransactionChannelNewBalance(bytes(2), 2, 2)
assert a != b
assert a < b
assert b > a
a = TransactionChannelNewBalance(bytes(1), 1, 1)
b = TransactionChannelNewBalance(bytes(2), 2, 1)
assert a != b
assert a < b
assert b > a
a = TransactionChannelNewBalance(bytes(3), 3, 3)
b = TransactionChannelNewBalance(bytes(3), 3, 3)
assert a == b
assert not a > b
assert not b > a
def handle_channel_new_balance(raiden: "RaidenService", event: Event):
data = event.event_data
args = data["args"]
block_number = data["block_number"]
block_hash = data["block_hash"]
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"]
chain_state = views.state_from_raiden(raiden)
previous_channel_state = views.get_channelstate_by_canonical_identifier_and_address(
chain_state=chain_state,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
address=participant_address)
# Channels will only be registered if this node is a participant or LC is a participant
if 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,
canonical_identifier=previous_channel_state.canonical_identifier,
deposit_transaction=deposit_transaction,
block_number=block_number,
block_hash=block_hash,
participant=participant_address)
raiden.handle_and_track_state_change(newbalance_statechange)
def test_deposit_must_wait_for_confirmation():
block_number = 10
confirmed_deposit_block_number = block_number + DEFAULT_NUMBER_OF_CONFIRMATIONS_BLOCK + 1
our_model1, _ = create_model(0)
partner_model1, _ = create_model(0)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
token_address = factories.make_address()
deposit_amount = 10
balance1_new = our_model1.balance + deposit_amount
our_model2 = our_model1._replace(
balance=balance1_new,
distributable=balance1_new,
contract_balance=balance1_new,
)
partner_model2 = partner_model1
assert channel_state.our_state.contract_balance == 0
assert channel_state.partner_state.contract_balance == 0
deposit_transaction = TransactionChannelNewBalance(
channel_state.our_state.address,
deposit_amount,
block_number,
)
new_balance = ContractReceiveChannelNewBalance(
payment_network_identifier,
token_address,
channel_state.identifier,
deposit_transaction,
)
pseudo_random_generator = random.Random()
iteration = channel.state_transition(
deepcopy(channel_state),
new_balance,
pseudo_random_generator,
block_number,
)
unconfirmed_state = iteration.new_state
for block_number in range(block_number, confirmed_deposit_block_number):
unconfirmed_block = Block(block_number)
iteration = channel.state_transition(
deepcopy(unconfirmed_state),
unconfirmed_block,
pseudo_random_generator,
block_number,
)
unconfirmed_state = iteration.new_state
assert_partner_state(
unconfirmed_state.our_state,
unconfirmed_state.partner_state,
our_model1,
)
assert_partner_state(
unconfirmed_state.partner_state,
unconfirmed_state.our_state,
partner_model1,
)
confirmed_block = Block(confirmed_deposit_block_number)
iteration = channel.state_transition(
deepcopy(unconfirmed_state),
confirmed_block,
pseudo_random_generator,
confirmed_deposit_block_number,
)
confirmed_state = iteration.new_state
assert_partner_state(confirmed_state.our_state, confirmed_state.partner_state, our_model2)
assert_partner_state(confirmed_state.partner_state, confirmed_state.our_state, partner_model2)
