def test_verify_balance_proof_v27(channel_manager_address: str):
# Should be default but test anyway.
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11,
channel_manager_address)
sig = sig[:-1] + b'\x1b'
assert verify_balance_proof(RECEIVER_ADDR, 312524, 11, sig,
channel_manager_address) == SENDER_ADDR
def test_verify_balance_proof(channel_manager_address: str):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 315123, 8, channel_manager_address
)
assert verify_balance_proof(
RECEIVER_ADDR, 315123, 8, sig, channel_manager_address
) == SENDER_ADDR
def test_verify_balance_proof(channel_manager_address: str):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 315123, 8, channel_manager_address
)
assert is_same_address(verify_balance_proof(
RECEIVER_ADDR, 315123, 8, sig, channel_manager_address
), SENDER_ADDR)
def test_verify_balance_proof_v0(channel_manager_address: str):
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11,
channel_manager_address)
sig = sig[:-1] + bytes([sig[-1] % 27])
assert is_same_address(
verify_balance_proof(RECEIVER_ADDR, 312524, 11, sig,
channel_manager_address), SENDER_ADDR)
def test_integrity(client: Client, receiver_address):
c = client.get_suitable_channel(receiver_address, 5)
assert c is not None
assert c.balance == 0
assert c.balance_sig == sign_balance_proof(
client.context.private_key,
receiver_address,
c.block,
0,
client.context.channel_manager.address
)
assert c.is_valid()
# Balance update without sig update.
c._balance = 2
assert not c.is_valid()
# Proper balance update with sig update.
c.update_balance(2)
assert c.is_valid()
# Random sig.
c._balance_sig = b'wrong'
assert not c.is_valid()
# Balance exceeds deposit.
c.update_balance(100)
assert not c.is_valid()
c.update_balance(0)
def test_verify_balance_proof_v27(channel_manager_address: str):
# Should be default but test anyway.
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11,
channel_manager_address)
sig = sig[:-1] + bytes([sig[-1] % 27 + 27])
assert is_same_address(
verify_balance_proof(RECEIVER_ADDR, 312524, 11, sig,
channel_manager_address), SENDER_ADDR)
def sign(self):
return sign_balance_proof(
self.core.private_key,
self.receiver,
self.block,
self.balance,
self.core.channel_manager.address
)
def test_verify_balance_proof_v0(channel_manager_address: str):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11, channel_manager_address
)
sig = sig[:-1] + bytes([sig[-1] % 27])
assert is_same_address(verify_balance_proof(
RECEIVER_ADDR, 312524, 11, sig, channel_manager_address
), SENDER_ADDR)
def test_sign_balance_proof_contract(channel_manager_contract: Contract):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 37, 15, channel_manager_contract.address
)
sender_recovered = channel_manager_contract.call().extractBalanceProofSignature(
RECEIVER_ADDR, 37, 15, sig
)
assert is_same_address(sender_recovered, SENDER_ADDR)
def test_verify_balance_proof_v0(channel_manager_address: str):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11, channel_manager_address
)
sig = sig[:-1] + b'\x00'
assert verify_balance_proof(
RECEIVER_ADDR, 312524, 11, sig, channel_manager_address
) == SENDER_ADDR
def test_sign_balance_proof_contract(channel_manager_contract: Contract):
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 37, 15, channel_manager_contract.address
)
sender_recovered = channel_manager_contract.call().verifyBalanceProof(
RECEIVER_ADDR, 37, 15, sig
)
assert sender_recovered == SENDER_ADDR
def test_verify_balance_proof_v27(channel_manager_address: str):
# Should be default but test anyway.
sig = sign_balance_proof(
SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11, channel_manager_address
)
sig = sig[:-1] + bytes([sig[-1] % 27 + 27])
assert is_same_address(verify_balance_proof(
RECEIVER_ADDR, 312524, 11, sig, channel_manager_address
), SENDER_ADDR)
def sign(self):
sig = sign_balance_proof(
self.core.private_key,
self.receiver,
self.block,
self.balance,
self.core.channel_manager.address
)
return sig
def test_payment(
channel_manager: ChannelManager,
confirmed_open_channel,
receiver_address: str,
receiver_privkey: str,
sender_privkey: str,
sender_address: str
):
channel_manager.wait_sync()
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.last_signature is None
assert channel_rec.balance == 0
# valid transfer
sig1 = encode_hex(confirmed_open_channel.create_transfer(2))
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 2, sig1)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer signed with wrong private key
invalid_sig = encode_hex(sign_balance_proof(
receiver_privkey, # should be sender's privkey
channel_rec.receiver,
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer to different receiver
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
sender_address, # should be receiver's address
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer negative amount
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
1, # should be greater than 2
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceAmount):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 1,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# parameters should match balance proof
sig2 = encode_hex(confirmed_open_channel.create_transfer(2))
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(receiver_address, channel_rec.open_block_number,
4, sig2)
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(sender_address, channel_rec.open_block_number + 1,
4, sig2)
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number,
5, sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 4
assert channel_rec.last_signature == sig2
# should transfer up to deposit
sig3 = encode_hex(confirmed_open_channel.create_transfer(6))
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 10, sig3)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
# transfer too much
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
12, # should not be greater than 10
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 12,
invalid_sig)
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
def test_payment(
channel_manager: ChannelManager,
confirmed_open_channel,
receiver_address: str,
receiver_privkey: str,
sender_privkey: str,
sender_address: str
):
channel_manager.wait_sync()
channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.last_signature is None
assert channel_rec.balance == 0
# valid transfer
sig1 = encode_hex(confirmed_open_channel.create_transfer(2))
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 2, sig1)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer signed with wrong private key
invalid_sig = encode_hex(sign_balance_proof(
receiver_privkey, # should be sender's privkey
channel_rec.receiver,
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer to different receiver
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
sender_address, # should be receiver's address
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer negative amount
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
1, # should be greater than 2
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceAmount):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 1,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# parameters should match balance proof
sig2 = encode_hex(confirmed_open_channel.create_transfer(2))
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(receiver_address, channel_rec.open_block_number,
4, sig2)
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(sender_address, channel_rec.open_block_number + 1,
4, sig2)
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number,
5, sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 4, sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 4
assert channel_rec.last_signature == sig2
# should transfer up to deposit
sig3 = encode_hex(confirmed_open_channel.create_transfer(6))
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 10, sig3)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
# transfer too much
invalid_sig = encode_hex(sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
12, # should not be greater than 10
channel_manager.channel_manager_contract.address
))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address, channel_rec.open_block_number, 12,
invalid_sig)
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
def test_payment(channel_manager: ChannelManager, confirmed_open_channel,
receiver_address: str, receiver_privkey: str,
sender_privkey: str, sender_address: str, block_num):
#channel_manager.wait_sync()
#confirmed_open_channel.sender = "0x09226F56C5699E2d87700179507cf25FA2F79F6b"
#confirmed_open_channel.block = 2000508
#channel_id = (confirmed_open_channel.sender, confirmed_open_channel.block)
channel_id = ('0xA7Ac54048B81041dbD527B603175C17473CE2d95', block_num)
print("channels: ", channel_manager.channels)
channel_rec = channel_manager.channels[channel_id]
print("last_sig: ", channel_rec.last_signature)
print("old_sig: ", channel_rec.old_signature)
print("balance: ", channel_rec.balance)
print("old_balance: ", channel_rec.old_balance)
print("sender_address: ", sender_address)
print("receiver_address: ", receiver_address)
print("contract_address: ",
channel_manager.channel_manager_contract.address)
#assert channel_rec.last_signature is None
#assert channel_rec.balance == 0
# valid transfer
#sig1 = encode_hex(confirmed_open_channel.create_transfer(2))
sig1 = encode_hex(
sign_balance_proof(
sender_privkey, # should be sender's privkey
#'0xA7Ac54048B81041dbD527B603175C17473CE2d95',
'0x09226F56C5699E2d87700179507cf25FA2F79F6b',
block_num,
#channel_rec.receiver,
#channel_rec.open_block_number,
coins(2),
channel_manager.channel_manager_contract.address))
sig2 = encode_hex(
sign_balance_proof(
sender_privkey, # should be sender's privkey
'0x09226F56C5699E2d87700179507cf25FA2F79F6b',
block_num,
coins(5),
channel_manager.channel_manager_contract.address))
channel_manager.register_payment(sender_address, block_num, coins(2), sig1)
channel_manager.register_payment(sender_address, block_num, coins(5), sig2)
channel_manager.unregister_payment(sender_address, block_num)
#channel_manager.register_payment(receiver_address, channel_rec.open_block_number, 2, sig1)
channel_rec = channel_manager.channels[channel_id]
print("last_sig2: ", channel_rec.last_signature)
#assert channel_rec.balance == 2
#assert channel_rec.last_signature == sig1
return
# transfer signed with wrong private key
invalid_sig = encode_hex(
sign_balance_proof(
receiver_privkey, # should be sender's privkey
channel_rec.receiver,
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer to different receiver
invalid_sig = encode_hex(
sign_balance_proof(
sender_privkey,
sender_address, # should be receiver's address
channel_rec.open_block_number,
4,
channel_manager.channel_manager_contract.address))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# transfer negative amount
invalid_sig = encode_hex(
sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
1, # should be greater than 2
channel_manager.channel_manager_contract.address))
with pytest.raises(InvalidBalanceAmount):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 1,
invalid_sig)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
# parameters should match balance proof
sig2 = encode_hex(confirmed_open_channel.create_transfer(2))
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(receiver_address,
channel_rec.open_block_number, 4,
sig2)
with pytest.raises(NoOpenChannel):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number + 1, 4,
sig2)
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 5,
sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 2
assert channel_rec.last_signature == sig1
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 4, sig2)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 4
assert channel_rec.last_signature == sig2
# should transfer up to deposit
sig3 = encode_hex(confirmed_open_channel.create_transfer(6))
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 10, sig3)
channel_rec = channel_manager.channels[channel_id]
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
# transfer too much
invalid_sig = encode_hex(
sign_balance_proof(
sender_privkey,
receiver_address,
channel_rec.open_block_number,
12, # should not be greater than 10
channel_manager.channel_manager_contract.address))
with pytest.raises(InvalidBalanceProof):
channel_manager.register_payment(sender_address,
channel_rec.open_block_number, 12,
invalid_sig)
assert channel_rec.balance == 10
assert channel_rec.last_signature == sig3
def test_sign_balance_proof_contract(channel_manager_contract: Contract):
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 37, 15,
channel_manager_contract.address)
sender_recovered = channel_manager_contract.call(
).extractBalanceProofSignature(RECEIVER_ADDR, 37, 15, sig)
assert is_same_address(sender_recovered, SENDER_ADDR)
