def handle_contract_send_channelupdate(
raiden: RaidenService,
channel_update_event: ContractSendChannelUpdateTransfer,
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
channel = raiden.chain.payment_channel(
token_network_address=channel_update_event.
token_network_identifier,
channel_id=channel_update_event.channel_identifier,
)
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
channel_identifier=balance_proof.channel_identifier,
token_network_identifier=balance_proof.token_network_identifier,
chain_id=balance_proof.chain_id,
partner_signature=balance_proof.signature,
)
our_signature = eth_sign(privkey=raiden.privkey, data=non_closing_data)
try:
channel.update_transfer(
balance_proof.nonce,
balance_proof.balance_hash,
balance_proof.message_hash,
balance_proof.signature,
our_signature,
)
except ChannelOutdatedError as e:
log.error(str(e))
def handle_contract_send_channelupdate(
raiden: "RaidenService", channel_update_event: ContractSendChannelUpdateTransfer
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
canonical_identifier = balance_proof.canonical_identifier
channel = raiden.chain.payment_channel(canonical_identifier=canonical_identifier)
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
canonical_identifier=canonical_identifier,
partner_signature=balance_proof.signature,
)
our_signature = raiden.signer.sign(data=non_closing_data)
channel.update_transfer(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
partner_signature=balance_proof.signature,
signature=our_signature,
block_identifier=channel_update_event.triggered_by_block_hash,
)
def handle_contract_send_channelupdate(
raiden: 'RaidenService',
channel_update_event: ContractSendChannelUpdateTransfer,
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
canonical_identifier = balance_proof.canonical_identifier
channel = raiden.chain.payment_channel(
canonical_identifier=canonical_identifier, )
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
canonical_identifier=canonical_identifier,
partner_signature=balance_proof.signature,
)
our_signature = raiden.signer.sign(data=non_closing_data)
try:
channel.update_transfer(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
partner_signature=balance_proof.signature,
signature=our_signature,
block_identifier=channel_update_event.
triggered_by_block_hash,
)
except ChannelOutdatedError as e:
log.error(
str(e),
node=pex(raiden.address),
)
def test_update_non_closing_balance_proof():
dict_data = {
"type":
"Secret",
"chain_id":
33,
"message_identifier":
4174357123961474742,
"payment_identifier":
5100335212362582814,
"secret":
"0xd1b2cb5b175436f60b6e59be64f4c7b59b3569b8f877c55f66c8f8a6ba8055f4",
"nonce":
2,
"token_network_address":
"0x013b47e5eb40a476dc0e9a212d376899288561a2",
"channel_identifier":
14,
"transferred_amount":
20000000,
"locked_amount":
0,
"locksroot":
"0x0000000000000000000000000000000000000000000000000000000000000000",
"signature":
"0x94d6dba985096b6259151664367443bcd83c5e8cc1913c34bd3542b4ac1b4e7772696e145445625eef4167080fddb3ebe730c71319bee66235864661d9dddc2b1c"
}
# dict_data = {"type": "Secret", "chain_id": 33, "message_identifier": 18237677588114994956, "payment_identifier": 1322351847924173620, "secret": "0xa4678d1f1db376f20854619fc8aa8021f88f318e14ff600aa051e8e4ded5d023", "nonce": 2, "token_network_address": "0x7351ed719de72db92a54c99ef2c4d287f69672a1", "channel_identifier": 3, "transferred_amount": 100000000000000000, "locked_amount": 0, "locksroot": "0x0000000000000000000000000000000000000000000000000000000000000000", "signature": "0x5c805ba51ac4776d879c276d54c1ed97905399e227e7b9ef50aa4f36605ac25e5ab707641c4bd85a0d89549841beaf4f0e06c839ad5460aaf26d4c68b9af822c1b"}
balance_proof_msg = Unlock.from_dict(dict_data)
balance_proof = balanceproof_from_envelope(balance_proof_msg)
non_closing_signature = create_balance_proof_update_signature(
"0x013b47e5eb40a476dc0e9a212d376899288561a2", 14,
balance_proof.balance_hash, 2, balance_proof.message_hash,
decode_hex(
"0x94d6dba985096b6259151664367443bcd83c5e8cc1913c34bd3542b4ac1b4e7772696e145445625eef4167080fddb3ebe730c71319bee66235864661d9dddc2b1c"
))
our_signed_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
canonical_identifier=balance_proof.canonical_identifier,
partner_signature=Signature(
decode_hex(
"0x94d6dba985096b6259151664367443bcd83c5e8cc1913c34bd3542b4ac1b4e7772696e145445625eef4167080fddb3ebe730c71319bee66235864661d9dddc2b1c"
)))
print("Update non consling blanace proof signature " +
non_closing_signature.hex())
our_recovered_address = recover(data=our_signed_data,
signature=Signature(non_closing_signature))
assert our_recovered_address == to_canonical_address(
"0x7ca28d3d760b4aa2b79e8d42cbdc187c7df9af40")
def handle_contract_send_channelupdate(
self,
raiden: RaidenService,
channel_update_event: ContractSendChannelUpdateTransfer,
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
channel = raiden.chain.payment_channel(
token_network_address=channel_update_event.
token_network_identifier,
channel_id=channel_update_event.channel_identifier,
)
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
channel_identifier=balance_proof.channel_identifier,
token_network_identifier=balance_proof.
token_network_identifier,
chain_id=balance_proof.chain_id,
partner_signature=balance_proof.signature,
)
our_signature = raiden.signer.sign(data=non_closing_data)
try:
# LEFTODO: Supply a proper block id
channel.update_transfer(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
partner_signature=balance_proof.signature,
signature=our_signature,
block_identifier='latest',
)
except ChannelOutdatedError as e:
log.error(
str(e),
node=pex(raiden.address),
)
def handle_contract_send_channelupdate(
self,
raiden: RaidenService,
channel_update_event: ContractSendChannelUpdateTransfer,
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
channel = raiden.chain.payment_channel(
token_network_address=channel_update_event.token_network_identifier,
channel_id=channel_update_event.channel_identifier,
)
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
channel_identifier=balance_proof.channel_identifier,
token_network_identifier=balance_proof.token_network_identifier,
chain_id=balance_proof.chain_id,
partner_signature=balance_proof.signature,
)
our_signature = eth_sign(privkey=raiden.privkey, data=non_closing_data)
try:
channel.update_transfer(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
partner_signature=balance_proof.signature,
signature=our_signature,
)
except ChannelOutdatedError as e:
log.error(
str(e),
node=pex(raiden.address),
)
def test_request_monitoring():
partner_signer = LocalSigner(PARTNER_PRIVKEY)
balance_proof = make_balance_proof(signer=partner_signer, amount=1)
partner_signed_balance_proof = SignedBlindedBalanceProof.from_balance_proof_signed_state(
balance_proof, )
request_monitoring = RequestMonitoring(
onchain_balance_proof=partner_signed_balance_proof,
reward_amount=55,
)
assert request_monitoring
with pytest.raises(ValueError):
request_monitoring.to_dict()
request_monitoring.sign(signer)
as_dict = request_monitoring.to_dict()
assert RequestMonitoring.from_dict(as_dict) == request_monitoring
packed = request_monitoring.pack(request_monitoring.packed())
assert RequestMonitoring.unpack(packed) == request_monitoring
# RequestMonitoring can be created directly from BalanceProofSignedState
direct_created = RequestMonitoring.from_balance_proof_signed_state(
balance_proof,
reward_amount=55,
)
with pytest.raises(ValueError):
# equality test uses `validated` packed format
assert direct_created == request_monitoring
direct_created.sign(signer)
# Instances created from same balance proof are equal
assert direct_created == request_monitoring
other_balance_proof = make_balance_proof(signer=partner_signer, amount=2)
other_instance = RequestMonitoring.from_balance_proof_signed_state(
other_balance_proof,
reward_amount=55,
)
other_instance.sign(signer)
# different balance proof ==> non-equality
assert other_instance != request_monitoring
# test signature verification
reward_proof_data = pack_reward_proof(
request_monitoring.balance_proof.channel_identifier,
request_monitoring.reward_amount,
request_monitoring.balance_proof.token_network_address,
request_monitoring.balance_proof.chain_id,
request_monitoring.balance_proof.nonce,
)
assert recover(reward_proof_data,
request_monitoring.reward_proof_signature) == ADDRESS
blinded_data = pack_balance_proof_update(
nonce=request_monitoring.balance_proof.nonce,
balance_hash=request_monitoring.balance_proof.balance_hash,
additional_hash=request_monitoring.balance_proof.additional_hash,
canonical_identifier=CanonicalIdentifier(
chain_identifier=request_monitoring.balance_proof.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
channel_identifier=request_monitoring.balance_proof.
channel_identifier,
),
partner_signature=request_monitoring.balance_proof.signature,
)
assert recover(blinded_data,
request_monitoring.non_closing_signature) == ADDRESS
balance_proof_data = pack_balance_proof(
nonce=request_monitoring.balance_proof.nonce,
balance_hash=request_monitoring.balance_proof.balance_hash,
additional_hash=request_monitoring.balance_proof.additional_hash,
canonical_identifier=CanonicalIdentifier(
chain_identifier=request_monitoring.balance_proof.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
channel_identifier=request_monitoring.balance_proof.
channel_identifier,
),
)
assert recover(
balance_proof_data,
request_monitoring.balance_proof.signature,
) == PARTNER_ADDRESS
assert request_monitoring.verify_request_monitoring(
PARTNER_ADDRESS, ADDRESS)
