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