def test_verify_balance_proof_v0(channel_manager_contract_address: str):
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11,
channel_manager_contract_address)
sig = sig[:-1] + b'\x00'
assert verify_balance_proof(
RECEIVER_ADDR, 312524, 11, sig,
channel_manager_contract_address) == SENDER_ADDR
def sign_close(self, sender, open_block_number, balance):
"""Sign an agreement for a channel closing."""
if (sender, open_block_number) not in self.channels:
raise NoOpenChannel('Channel does not exist or has been closed'
'(sender=%s, open_block_number=%d)' %
(sender, open_block_number))
c = self.channels[sender, open_block_number]
print('sign_close', c)
if c.is_closed:
raise NoOpenChannel('Channel closing has been requested already.')
assert balance is not None
# if c.last_signature is None:todo fix
# raise NoBalanceProofReceived('Payment has not been registered.')
if balance != c.balance:
raise InvalidBalanceProof(
'Requested closing balance does not match latest one.')
c.is_closed = True
c.mtime = time.time()
receiver_sig = sign_balance_proof(self.private_key, self.receiver,
open_block_number, balance)
self.state.store()
self.log.info(
'signed cooperative closing message (sender %s, block number %s)',
sender, open_block_number)
return receiver_sig
def sign(self):
return sign_balance_proof(
self.client.privkey,
self.receiver,
self.block,
self.balance,
self.client.channel_manager_address
)
def test_verify_balance_proof_v27(channel_manager_contract_address: str):
# Should be default but test anyway.
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11,
channel_manager_contract_address)
sig = sig[:-1] + b'\x1b'
assert verify_balance_proof(
RECEIVER_ADDR, 312524, 11, sig,
channel_manager_contract_address) == SENDER_ADDR
def test_sign_balance_proof_contract(
client_contract_proxy: ChannelContractProxy,
channel_manager_contract_address: str):
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 37, 15,
channel_manager_contract_address)
sender_recovered = client_contract_proxy.contract.call(
).verifyBalanceProof(RECEIVER_ADDR, 37, 15, sig)
assert sender_recovered == SENDER_ADDR
def close_channel_cooperatively(channel,
privkey_receiver,
balance: int = None):
if balance is not None:
channel.balance = balance
closing_sig = sign_balance_proof(
privkey_receiver, channel.receiver, channel.block,
channel.balance if balance is None else balance)
assert channel.close_cooperatively(closing_sig)
def settle():
closing_sig = sign_balance_proof(config.receiver_privkey,
channel_object.receiver,
channel_object.block,
channel_object.balance)
settled = channel_object.close_cooperatively(closing_sig)
if not settled:
return json.dumps(utils.error)
return json.dumps(settled, 200, {'ContentType': 'application/json'})
def test_cooperative_close(client: Client, receiver_privkey, receiver_address):
c = client.get_suitable_channel(receiver_address, 3)
c.create_transfer(3)
assert c.deposit >= 3
assert c.balance == 3
sig = sign_balance_proof(receiver_privkey, c.receiver, c.block, c.balance)
assert c.close_cooperatively(sig)
assert c.state == Channel.State.closed
def delete(self, sender_address):
parser = reqparse.RequestParser()
parser.add_argument('open_block',
type=int,
help='block the channel was opened')
parser.add_argument('signature', help='last balance proof signature')
args = parser.parse_args()
if args.signature is None:
return "Bad signature format", 400
if args.block is None:
return "No opening block specified", 400
channel = self.channel_manager.channels[sender_address, args.block]
if channel.last_signature != args.signature:
return "Invalid or outdated balance signature", 400
ret = sign_balance_proof(self.channel_manager.private_key,
self.channel_manager.receiver, args.block,
channel.balance)
return ret, 200
def test_integrity(client: Client, receiver_address):
c = client.get_suitable_channel(receiver_address, 5)
assert c.balance == 0
assert c.balance_sig == sign_balance_proof(client.privkey, receiver_address, c.block, 0)
assert c.is_valid()
# Balance update without sig update.
c._balance = 2
assert not c.is_valid()
# Proper balance update with sig update.
c.balance = 2
assert c.is_valid()
# Random sig.
c._balance_sig = b'wrong'
assert not c.is_valid()
# Balance exceeds deposit.
c.balance = 100
assert not c.is_valid()
def test_payment(channel_manager, confirmed_open_channel, receiver_address,
receiver_privkey, sender_privkey, sender_address):
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.contract_proxy.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.contract_proxy.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.contract_proxy.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.contract_proxy.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 sign(self):
return sign_balance_proof(self.client.privkey, self.receiver,
self.block, self.balance)
def test_verify_balance_proof():
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 315123, 8)
assert verify_balance_proof(RECEIVER_ADDR, 315123, 8, sig) == SENDER_ADDR
def test_verify_balance_proof_v27():
# Should be default but test anyway.
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11)
sig = sig[:-1] + b'\x1b'
assert verify_balance_proof(RECEIVER_ADDR, 312524, 11, sig) == SENDER_ADDR
def test_verify_balance_proof_v0():
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 312524, 11)
sig = sig[:-1] + b'\x00'
assert verify_balance_proof(RECEIVER_ADDR, 312524, 11, sig) == SENDER_ADDR
def test_verify_balance_proof(channel_manager_contract_address: str):
sig = sign_balance_proof(SENDER_PRIVATE_KEY, RECEIVER_ADDR, 315123, 8,
channel_manager_contract_address)
assert verify_balance_proof(
RECEIVER_ADDR, 315123, 8, sig,
channel_manager_contract_address) == SENDER_ADDR
