def test_update_fee_schedule_after_balance_change():
channel_state = factories.create(
factories.NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=100),
partner_state=NettingChannelEndStateProperties(balance=0),
)
)
fee_config = prepare_mediation_fee_config(
cli_token_to_flat_fee=(),
cli_token_to_proportional_fee=(),
cli_token_to_proportional_imbalance_fee=((channel_state.token_address, 50_000),), # 5%
cli_cap_mediation_fees=True,
)
update_fee_schedule_after_balance_change(channel_state, fee_config)
assert channel_state.fee_schedule.imbalance_penalty[0] == (0, 5)
def make_target_state(
our_address=factories.ADDR,
amount=3,
block_number=1,
initiator=UNIT_TRANSFER_INITIATOR,
expiration=None,
pseudo_random_generator=None,
):
pseudo_random_generator = pseudo_random_generator or random.Random()
channels = make_channel_set(
[
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(address=our_address),
partner_state=NettingChannelEndStateProperties(
address=UNIT_TRANSFER_SENDER, balance=amount
),
)
]
)
expiration = expiration or channels[0].reveal_timeout + block_number + 1
from_transfer = make_target_transfer(channels[0], amount, expiration, initiator)
state_change = ActionInitTarget(
from_hop=channels.get_hop(0),
transfer=from_transfer,
balance_proof=from_transfer.balance_proof,
sender=from_transfer.balance_proof.sender, # pylint: disable=no-member
)
iteration = target.handle_inittarget(
state_change=state_change,
channel_state=channels[0],
pseudo_random_generator=pseudo_random_generator,
block_number=block_number,
)
return TargetStateSetup(
channel=channels[0],
new_state=iteration.new_state,
our_address=our_address,
initiator=initiator,
expiration=expiration,
amount=amount,
block_number=block_number,
pseudo_random_generator=pseudo_random_generator,
)
def test_fee_add_remove_invariant(flat_fee, prop_fee, imbalance_fee, amount, balance1, balance2):
""" First adding and then removing fees must yield the original value """
total_balance = TokenAmount(100_000_000_000_000_000_000)
prop_fee_per_channel = ppm_fee_per_channel(ProportionalFeeAmount(prop_fee))
imbalance_fee = calculate_imbalance_fees(
channel_capacity=total_balance,
proportional_imbalance_fee=ProportionalFeeAmount(imbalance_fee),
)
fee_schedule = FeeScheduleState(
cap_fees=False,
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
)
channel_in = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=total_balance - balance1),
partner_state=NettingChannelEndStateProperties(balance=balance1),
fee_schedule=fee_schedule,
)
)
channel_out = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance2),
partner_state=NettingChannelEndStateProperties(balance=total_balance - balance2),
fee_schedule=fee_schedule,
)
)
amount_with_fees = get_amount_with_fees(
amount_without_fees=amount,
schedule_in=channel_in.fee_schedule,
schedule_out=channel_out.fee_schedule,
receivable_amount=balance1,
balance_in=total_balance - balance1,
balance_out=balance2,
)
assume(amount_with_fees)
assert amount_with_fees
amount_without_fees = get_amount_without_fees(
amount_with_fees=amount_with_fees, channel_in=channel_in, channel_out=channel_out
)
assume(amount_without_fees)
assert amount - 1 <= amount_without_fees <= amount + 1
def make_channel_pair(
fee_schedule: FeeScheduleState, balance1: int = 0, balance2: int = 0
) -> Tuple[NettingChannelState, NettingChannelState]:
balance1 = TokenAmount(balance1)
balance2 = TokenAmount(balance2)
return (
factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance2),
partner_state=NettingChannelEndStateProperties(balance=balance1),
fee_schedule=fee_schedule,
)
),
factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance1),
partner_state=NettingChannelEndStateProperties(balance=balance2),
fee_schedule=fee_schedule,
)
),
)
def test_get_lock_amount_after_fees(flat_fee, prop_fee, initial_amount, expected_amount):
""" Tests mediation fee deduction. """
prop_fee_per_channel = ppm_fee_per_channel(ProportionalFeeAmount(prop_fee))
lock = make_hash_time_lock_state(amount=initial_amount)
channel_in = factories.create(
NettingChannelStateProperties(
partner_state=NettingChannelEndStateProperties(balance=TokenAmount(2000)),
fee_schedule=FeeScheduleState(flat=flat_fee, proportional=prop_fee_per_channel),
)
)
channel_out = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=TokenAmount(2000)),
fee_schedule=FeeScheduleState(flat=flat_fee, proportional=prop_fee_per_channel),
)
)
locked_after_fees = get_amount_without_fees(
amount_with_fees=lock.amount, channel_in=channel_in, channel_out=channel_out
)
assert locked_after_fees == expected_amount
def test_get_initial_payment_for_final_target_amount(
flat_fee: FeeAmount,
prop_fee: ProportionalFeeAmount,
balance: TokenAmount,
final_amount: PaymentAmount,
initial_amount: PaymentWithFeeAmount,
expected_fees: List[FeeAmount],
):
prop_fee = ppm_fee_per_channel(prop_fee)
channel_set = make_channel_set([
NettingChannelStateProperties(
canonical_identifier=factories.create(
CanonicalIdentifierProperties(
channel_identifier=ChannelID(1))),
our_state=NettingChannelEndStateProperties(balance=TokenAmount(0)),
partner_state=NettingChannelEndStateProperties(balance=balance),
fee_schedule=FeeScheduleState(flat=flat_fee,
proportional=prop_fee),
),
NettingChannelStateProperties(
canonical_identifier=factories.create(
CanonicalIdentifierProperties(
channel_identifier=ChannelID(2))),
our_state=NettingChannelEndStateProperties(balance=balance),
partner_state=NettingChannelEndStateProperties(
balance=TokenAmount(0)),
fee_schedule=FeeScheduleState(flat=flat_fee,
proportional=prop_fee),
),
])
calculation = get_initial_amount_for_amount_after_fees(
amount_after_fees=final_amount,
channels=[(channel_set.channels[0], channel_set.channels[1])],
)
assert calculation is not None
assert calculation.total_amount == initial_amount
assert calculation.mediation_fees == expected_fees
def test_get_lock_amount_after_fees_imbalanced_channel(
cap_fees, flat_fee, prop_fee, imbalance_fee, initial_amount, expected_amount
):
""" Tests mediation fee deduction. """
balance = TokenAmount(100_000)
prop_fee_per_channel = ppm_fee_per_channel(ProportionalFeeAmount(prop_fee))
imbalance_fee = calculate_imbalance_fees(
channel_capacity=balance, proportional_imbalance_fee=ProportionalFeeAmount(imbalance_fee)
)
lock = make_hash_time_lock_state(amount=initial_amount)
channel_in = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=TokenAmount(0)),
partner_state=NettingChannelEndStateProperties(balance=balance),
fee_schedule=FeeScheduleState(
cap_fees=cap_fees,
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
)
)
channel_out = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance),
partner_state=NettingChannelEndStateProperties(balance=TokenAmount(0)),
fee_schedule=FeeScheduleState(
cap_fees=cap_fees,
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
)
)
locked_after_fees = get_amount_without_fees(
amount_with_fees=lock.amount, channel_in=channel_in, channel_out=channel_out
)
assert locked_after_fees == expected_amount
def test_fee_round_trip(flat_fee, prop_fee, imbalance_fee, amount):
""" Tests mediation fee deduction. """
balance = TokenAmount(100_000)
prop_fee_per_channel = ppm_fee_per_channel(ProportionalFeeAmount(prop_fee))
imbalance_fee = calculate_imbalance_fees(
channel_capacity=balance,
proportional_imbalance_fee=ProportionalFeeAmount(imbalance_fee))
payer_channel = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=TokenAmount(0)),
partner_state=NettingChannelEndStateProperties(balance=balance),
fee_schedule=FeeScheduleState(
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
))
payer_channel_backwards = factories.create(
NettingChannelStateProperties(
partner_state=NettingChannelEndStateProperties(
balance=TokenAmount(0)),
our_state=NettingChannelEndStateProperties(balance=balance),
fee_schedule=FeeScheduleState(
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
))
payee_channel = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance),
partner_state=NettingChannelEndStateProperties(
balance=TokenAmount(0)),
fee_schedule=FeeScheduleState(
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
))
fee_calculation = get_initial_payment_for_final_target_amount(
final_amount=PaymentAmount(amount),
channels=[payer_channel_backwards, payee_channel])
assert fee_calculation
amount_after_fees = get_lock_amount_after_fees(
lock=make_hash_time_lock_state(amount=fee_calculation.total_amount),
payer_channel=payer_channel,
payee_channel=payee_channel,
)
assert amount_after_fees
assert abs(amount - amount_after_fees) < 100
def test_regression_mediator_task_no_routes():
""" The mediator must only be cleared after the waiting transfer's lock has
been handled.
If a node receives a transfer to mediate, but there is no route available
(because there is no sufficient capacity or the partner nodes are offline),
and a refund is not possible, the mediator task must not be cleared,
otherwise followup remove expired lock messages wont be processed and the
nodes will get out of sync.
"""
pseudo_random_generator = random.Random()
channels = make_channel_set([
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=0),
partner_state=NettingChannelEndStateProperties(
balance=10,
address=HOP2,
privatekey=HOP2_KEY,
),
),
])
payer_transfer = factories.make_signed_transfer_for(
channels[0],
factories.LockedTransferSignedStateProperties(
sender=HOP2,
pkey=HOP2_KEY,
transfer=factories.LockedTransferProperties(expiration=30),
))
init_state_change = ActionInitMediator(
channels.get_routes(),
channels.get_route(0),
payer_transfer,
)
init_iteration = mediator.state_transition(
mediator_state=None,
state_change=init_state_change,
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=5,
block_hash=factories.make_block_hash(),
)
msg = 'The task must not be cleared, even if there is no route to forward the transfer'
assert init_iteration.new_state is not None, msg
assert init_iteration.new_state.waiting_transfer.transfer == payer_transfer
assert search_for_item(init_iteration.events, SendLockedTransfer,
{}) is None
assert search_for_item(init_iteration.events, SendRefundTransfer,
{}) is None
secrethash = UNIT_SECRETHASH
lock = channels[0].partner_state.secrethashes_to_lockedlocks[secrethash]
# Creates a transfer as it was from the *partner*
send_lock_expired, _ = channel.create_sendexpiredlock(
sender_end_state=channels[0].partner_state,
locked_lock=lock,
pseudo_random_generator=pseudo_random_generator,
chain_id=channels[0].chain_id,
token_network_identifier=channels[0].token_network_identifier,
channel_identifier=channels[0].identifier,
recipient=channels[0].our_state.address,
)
assert send_lock_expired
lock_expired_message = message_from_sendevent(send_lock_expired, HOP1)
lock_expired_message.sign(LocalSigner(channels.partner_privatekeys[0]))
balance_proof = balanceproof_from_envelope(lock_expired_message)
message_identifier = message_identifier_from_prng(pseudo_random_generator)
# Regression: The mediator must still be able to process the block which
# expires the lock
expired_block_number = channel.get_sender_expiration_threshold(lock)
block_hash = factories.make_block_hash()
expire_block_iteration = mediator.state_transition(
mediator_state=init_iteration.new_state,
state_change=Block(
block_number=expired_block_number,
gas_limit=0,
block_hash=block_hash,
),
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=expired_block_number,
block_hash=block_hash,
)
assert expire_block_iteration.new_state is not None
receive_expired_iteration = mediator.state_transition(
mediator_state=expire_block_iteration.new_state,
state_change=ReceiveLockExpired(
balance_proof=balance_proof,
secrethash=secrethash,
message_identifier=message_identifier,
),
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=expired_block_number,
block_hash=block_hash,
)
msg = 'The only used channel had the lock cleared, the task must be cleared'
assert receive_expired_iteration.new_state is None, msg
assert secrethash not in channels[
0].partner_state.secrethashes_to_lockedlocks
)
return TargetStateSetup(
channel=channels[0],
new_state=iteration.new_state,
our_address=our_address,
initiator=initiator,
expiration=expiration,
amount=amount,
block_number=block_number,
pseudo_random_generator=pseudo_random_generator,
)
channel_properties = NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(address=UNIT_TRANSFER_TARGET),
partner_state=NettingChannelEndStateProperties(
address=UNIT_TRANSFER_SENDER, balance=3),
)
channel_properties2 = NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(
address=factories.make_address(), balance=100),
partner_state=NettingChannelEndStateProperties(
address=UNIT_TRANSFER_SENDER, balance=130),
)
def test_events_for_onchain_secretreveal():
""" Secret must be registered on-chain when the unsafe region is reached and
the secret is known.
def test_fee_round_trip(flat_fee, prop_fee, imbalance_fee, amount, balance1, balance2):
"""Tests mediation fee deduction.
First we're doing a PFS-like calculation going backwards from the target
amount to get the amount that the initiator has to send. Then we calculate
the fees from a mediator's point of view and check if `amount_with_fees -
fees = amount`.
"""
# Find examples where there is a reasonable chance of succeeding
amount = int(min(amount, balance1 * 0.95 - 1, balance2 * 0.95 - 1))
assume(amount > 0)
total_balance = TokenAmount(100_000_000_000_000_000_000)
prop_fee_per_channel = ppm_fee_per_channel(ProportionalFeeAmount(prop_fee))
imbalance_fee = calculate_imbalance_fees(
channel_capacity=total_balance,
proportional_imbalance_fee=ProportionalFeeAmount(imbalance_fee),
)
channel_in = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=total_balance - balance1),
partner_state=NettingChannelEndStateProperties(balance=balance1),
fee_schedule=FeeScheduleState(
cap_fees=False,
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
)
)
channel_out = factories.create(
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=balance2),
partner_state=NettingChannelEndStateProperties(balance=total_balance - balance2),
fee_schedule=FeeScheduleState(
cap_fees=False,
flat=FeeAmount(flat_fee),
proportional=prop_fee_per_channel,
imbalance_penalty=imbalance_fee,
),
)
)
# How much do we need to send so that the target receives `amount`? PFS-like calculation.
fee_calculation = get_initial_amount_for_amount_after_fees(
amount_after_fees=PaymentAmount(amount), channels=[(channel_in, channel_out)]
)
assume(fee_calculation) # There is not enough capacity for the payment in all cases
assert fee_calculation
# How much would a mediator send to the target? Ideally exactly `amount`.
amount_without_margin_after_fees = get_amount_without_fees(
amount_with_fees=fee_calculation.total_amount,
channel_in=channel_in,
channel_out=channel_out,
)
assume(amount_without_margin_after_fees) # We might lack capacity for the payment
assert abs(amount - amount_without_margin_after_fees) <= 1 # Equal except for rounding errors
# If we add the fee margin, the mediator must always send at least `amount` to the target!
amount_with_fee_and_margin = calculate_safe_amount_with_fee(
fee_calculation.amount_without_fees, FeeAmount(sum(fee_calculation.mediation_fees))
)
amount_with_margin_after_fees = get_amount_without_fees(
amount_with_fees=amount_with_fee_and_margin, channel_in=channel_in, channel_out=channel_out
)
assume(amount_with_margin_after_fees) # We might lack capacity to add margins
assert amount_with_margin_after_fees >= amount
