def __init__(self, sk, i, tokenNetwork, addrs, deposit, channel_identifier, secret_registry_contract, lock):
self.sk = sk
self.i = i
self.token_network = tokenNetwork
self.addrs = addrs
self.deposit = deposit
self.moving_average_capacity = list(deposit)
self.channel_identifier = channel_identifier
self.secret_registry_contract = secret_registry_contract
self.status = "OK"
self.nonce = 0
self.transferred_amount = [0,0]
self.locked_amount = [0,0]
self.locksroot = [pack_data(['uint256'],[0]),pack_data(['uint256'],[0])]
self.leaves = [{},{}]
self.BP = [0,0]
self.chain_id = 337
self.RTT = RTT()
self.pending_payment = [{},{}]
self.reserve_payment = [{}, {}]
self.wait_confirm = [{},{}]
self.lock = lock
self.payment_history = [[],[]]
self.weight = 0.6
self.contract_boundary = [0,0]
def test_pack_data():
assert pack_data(("Test", "string"),
(49, "uint32")) == b"Test\x00\x00\x001"
with pytest.raises(ValueError):
pack_data((13, "uint256"), ("address"))
with pytest.raises(TypeError):
pack_data((256, "uint256"), ("This is not a uint256", "uint256"))
def locked_BP(self, BP):
self.lock.acquire()
try:
self.BP[1 - self.i] = BP
self.locked_amount[1-self.i] += BP.message_data.amount + BP.message_data.selected_incentive
self.locksroot[1-self.i] = BP.message_data.locksroot
finally:
self.lock.release()
cr = BP.message_data.payment_identifier
locked_amount = BP.message_data.amount + BP.message_data.selected_incentive
expiration = BP.message_data.expiration
secrethash = BP.message_data.secrethash
selected_incentive = BP.message_data.selected_incentive
selected_delay = BP.message_data.selected_delay
aux_incentive = BP.message_data.aux_incentive
aux_delay = BP.message_data.aux_delay
startTime = BP.message_data.start_time
target = BP.message_data.target
leaf = pack_data(
['uint256', 'uint256', 'bytes32', 'uint256', 'uint256', 'uint256', 'uint256', 'uint256', 'address'],
[locked_amount, expiration, secrethash, selected_incentive,selected_delay, aux_incentive, aux_delay, startTime, target])
self.leaves[1-self.i][cr] = leaf
# return self.transferred_amount[1-self.i], self.locked_amount[1-self.i], self.locksroot[1-self.i]
return locked_amount, selected_delay, startTime
def pack_balance_proof(
nonce: typing.Nonce,
balance_hash: typing.BalanceHash,
additional_hash: typing.AdditionalHash,
channel_identifier: typing.ChannelID,
token_network_identifier: typing.TokenNetworkID,
chain_id: typing.ChainID,
msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF,
) -> bytes:
return pack_data([
'address',
'uint256',
'uint256',
'uint256',
'bytes32',
'uint256',
'bytes32',
], [
token_network_identifier,
chain_id,
msg_type,
channel_identifier,
balance_hash,
nonce,
additional_hash,
])
def pack_balance_proof(
nonce: typing.Nonce,
balance_hash: typing.BalanceHash,
additional_hash: typing.AdditionalHash,
channel_identifier: typing.ChannelID,
token_network_identifier: typing.TokenNetworkID,
chain_id: typing.ChainID,
msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF,
) -> bytes:
"""Packs balance proof data to be signed
Packs the given arguments in a byte array in the same configuration the
contracts expect the signed data to have.
"""
return pack_data([
'address',
'uint256',
'uint256',
'uint256',
'bytes32',
'uint256',
'bytes32',
], [
token_network_identifier,
chain_id,
msg_type,
channel_identifier,
balance_hash,
nonce,
additional_hash,
])
def _data_to_sign(self) -> bytes:
return pack_data(
(self.cmdid.value, "uint8"),
(b"\x00" * 3, "bytes"), # padding
(self.message_identifier, "uint64"),
(self.secret, "bytes32"),
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.cmdid.value, "uint8"),
(b"\x00" * 3, "bytes"), # padding
(self.nonce, "uint64"),
(self.current_protocol_version, "uint8"),
)
def pack_balance_proof(
nonce: Nonce,
balance_hash: BalanceHash,
additional_hash: AdditionalHash,
canonical_identifier: CanonicalIdentifier,
msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF,
) -> bytes:
"""Packs balance proof data to be signed
Packs the given arguments in a byte array in the same configuration the
contracts expect the signed data to have.
"""
return pack_data([
'address',
'uint256',
'uint256',
'uint256',
'bytes32',
'uint256',
'bytes32',
], [
canonical_identifier.token_network_address,
canonical_identifier.chain_identifier,
msg_type,
canonical_identifier.channel_identifier,
balance_hash,
nonce,
additional_hash,
])
def message_hash(self) -> bytes:
return sha3(
pack_data(
(self.cmdid.value, "uint8"),
(self.message_identifier, "uint64"),
(self.recipient, "address"),
(self.secrethash, "bytes32"),
))
def message_hash(self) -> bytes:
return sha3(
pack_data(
(self.cmdid.value, "uint8"),
(self.message_identifier, "uint64"),
(self.payment_identifier, "uint64"),
(self.secret, "bytes32"),
))
def create_BP(self, w3, cr, initiator, target, secrethash, amount, expiration, s_contract, a_contract, start_time):
# self.lock.acquire()
# try:
# self.locked_amount[self.i] += amount + s_contract[0]
# finally:
# self.lock.release()
# print("locked_amount ", self.locked_amount[self.i])
# uint = 32bytes, address = 20bytes, bytes32 = 32bytes
leaf = pack_data(['uint256', 'uint256', 'bytes32', 'uint256', 'uint256', 'uint256', 'uint256', 'uint256', 'address'],
[amount+s_contract[0], expiration, secrethash, s_contract[0],
s_contract[1], a_contract[0][0], a_contract[1][1], start_time, target])
self.leaves[self.i][cr] = leaf
temp = []
for i in list(self.leaves[self.i].values()) :
temp.append(sha3(i))
layer = compute_layers(temp)
tree = MerkleTreeState(layer)
locksroot = "0x" + merkleroot(tree).hex()
# print("locksroot ", locksroot)
self.locksroot[self.i] = locksroot
self.nonce +=1
message_data = LockedTransfer_structure(self.nonce, self.chain_id, cr, expiration, self.token_network.address, self.channel_identifier,
self.addrs[1-self.i], target, initiator, locksroot, secrethash, self.transferred_amount[self.i],
self.locked_amount[self.i], amount, s_contract[0], s_contract[1], a_contract[0][0], a_contract[1][1], start_time)
packed_message_data = message_data.pack()
additional_hash = '0x' + sha3(packed_message_data).hex()
# print("additional_hash ", additional_hash)
packed_balance = pack_data(['uint256', 'uint256', 'bytes32'], [self.transferred_amount[self.i], self.locked_amount[self.i], locksroot])
balance_hash = '0x' + sha3(packed_balance).hex()
# print("balance_hash ", balance_hash)
packed_balance_proof = pack_data(['uint256', 'bytes32', 'uint256', 'bytes32'],
[self.channel_identifier, balance_hash, self.nonce, additional_hash])
hashBP = '0x' + sha3(packed_balance_proof).hex()
signature = w3.eth.account.signHash(message_hash=hashBP, private_key=self.sk)
# print("signature", signature)
BP = balanceProof(message_data, additional_hash, balance_hash, signature['signature'].hex())
self.BP[self.i] = BP
return BP
def serialize_bin(self, msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF):
return pack_data(
(self.token_network_address, "address"),
(self.chain_id, "uint256"),
(msg_type.value, "uint256"),
(self.channel_identifier, "uint256"),
(decode_hex(self.balance_hash), "bytes32"),
(self.nonce, "uint256"),
(decode_hex(self.additional_hash), "bytes32"),
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.token_network_address, "address"),
(self.chain_id, "uint256"),
(self.message_type, "uint256"),
(self.channel_identifier, "uint256"),
(self.participant, "address"),
(self.total_withdraw, "uint256"),
(self.expiration, "uint256"),
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.cmdid.value, "uint8"),
(b"\x00" * 3, "bytes"), # padding
(self.message_identifier, "uint64"),
(self.payment_identifier, "uint64"),
(self.secrethash, "bytes32"),
(self.amount, "uint256"),
(self.expiration, "uint256"),
)
def pack_reward_proof(canonical_identifier: CanonicalIdentifier,
reward_amount: TokenAmount, nonce: Nonce) -> bytes:
channel_identifier = canonical_identifier.channel_identifier
token_network_address = canonical_identifier.token_network_address
chain_id = canonical_identifier.chain_identifier
return pack_data(
["uint256", "uint256", "address", "uint256", "uint256"],
[
channel_identifier, reward_amount, token_network_address, chain_id,
nonce
],
)
def packed_reward_proof_data(self) -> bytes:
"""Return reward proof data serialized to binary"""
return pack_data(
['uint256', 'uint256', 'address', 'uint256', 'uint256'],
[
self.channel_identifier,
self.reward_amount,
self.token_network_address,
self.chain_id,
self.nonce,
],
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.canonical_identifier.chain_identifier, "uint256"),
(self.canonical_identifier.token_network_address, "address"),
(self.canonical_identifier.channel_identifier, "uint256"),
(self.updating_participant, "address"),
(self.other_participant, "address"),
(self.updating_nonce, "uint64"),
(self.other_nonce, "uint64"),
(self.updating_capacity, "uint256"),
(self.other_capacity, "uint256"),
(self.reveal_timeout, "uint256"),
)
def serialize_bin(self, msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF) -> bytes:
return pack_data(
['address', 'uint256', 'uint256', 'uint256', 'bytes32', 'uint256', 'bytes32'],
[
self.token_network_address,
self.chain_id,
msg_type.value,
self.channel_identifier,
decode_hex(self.balance_hash),
self.nonce,
decode_hex(self.additional_hash),
],
)
def packed_balance_proof_data(
self,
message_type: MessageTypeId = MessageTypeId.BALANCE_PROOF
) -> bytes:
return pack_data(
(self.token_network_address, "address"),
(self.chain_id, "uint256"),
(message_type.value, "uint256"),
(self.channel_identifier, "uint256"),
(decode_hex(self.balance_hash), "bytes32"),
(self.nonce, "uint256"),
(decode_hex(self.additional_hash), "bytes32"),
)
def _packed_data(self) -> bytes:
return pack_data(
(self.cmdid.value, "uint8"),
(self.message_identifier, "uint64"),
(self.payment_identifier, "uint64"),
(self.lock.expiration, "uint256"),
(self.token, "address"),
(self.recipient, "address"),
(self.target, "address"),
(self.initiator, "address"),
(self.lock.secrethash, "bytes32"),
(self.lock.amount, "uint256"),
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.cmdid.value, "uint8"),
(b"\x00" * 3, "bytes"), # padding
(self.nonce, "uint256"),
(self.message_identifier, "uint64"),
(self.token_network_address, "address"),
(self.chain_id, "uint256"),
(self.message_type, "uint256"),
(self.channel_identifier, "uint256"),
(self.participant, "address"),
(self.total_withdraw, "uint256"),
(self.expiration, "uint256"),
)
def _data_to_sign(self) -> bytes:
return pack_data(
(self.canonical_identifier.chain_identifier, "uint256"),
(self.canonical_identifier.token_network_address, "address"),
(self.canonical_identifier.channel_identifier, "uint256"),
(self.updating_participant, "address"),
(self.fee_schedule.cap_fees, "bool"),
(self.fee_schedule.flat, "uint256"),
(self.fee_schedule.proportional, "uint256"),
(rlp.encode(self.fee_schedule.imbalance_penalty or 0), "bytes"),
(
marshmallow.fields.NaiveDateTime()._serialize(self.timestamp, "timestamp", self),
"string",
),
)
def make_params(timestamp: str):
params = {
"sender": to_checksum_address(sender),
"receiver":
to_checksum_address(api_sut.pathfinding_service.address),
"timestamp": timestamp,
}
local_signer = LocalSigner(private_key=decode_hex(privkey))
params["signature"] = encode_hex(
local_signer.sign(
pack_data(
(params["sender"], "address"),
(params["receiver"], "address"),
(params["timestamp"], "string"),
)))
return params
def make_params(timestamp: datetime):
params = {
"sender": sender,
"receiver": api_sut.pathfinding_service.address,
"timestamp": timestamp.isoformat(),
}
local_signer = LocalSigner(private_key=decode_hex(privkey))
params["signature"] = encode_hex(
local_signer.sign(
pack_data(
["address", "address", "string"],
[params["sender"], params["receiver"], params["timestamp"]],
)
)
)
return params
def make_params(timestamp: datetime):
params = {
'sender': sender,
'receiver': api_sut.pathfinding_service.address,
'timestamp': timestamp.isoformat(),
}
local_signer = LocalSigner(private_key=decode_hex(privkey))
params['signature'] = encode_hex(
local_signer.sign(
pack_data(
['address', 'address', 'string'],
[params['sender'], params['receiver'], params['timestamp']],
)
)
)
return params
def pack(self):
return pack_data([
'uint64',
'bytes32',
'uint256',
'bytes32',
'bytes32',
'uint256',
'uint256',
], [
self.nonce,
self.payment_identifier,
self.channel_identifier,
self.secret,
self.locksroot,
self.transferred_amount,
self.locked_amount,
])
def pack(self):
return pack_data([
'uint8',
'uint64',
'uint256',
'bytes32',
'uint256',
'address',
'uint256',
'address',
'address',
'address',
'bytes32',
'bytes32',
'uint256',
'uint256',
'uint256',
'uint256',
'uint256',
'uint256',
'uint256',
'uint256',
], [
self.cmdid,
self.nonce,
self.chain_id,
self.payment_identifier,
self.expiration,
self.token_network_address,
self.channel_identifier,
self.recipient,
self.target,
self.initiator,
self.locksroot,
self.secrethash,
self.transferred_amount,
self.locked_amount,
self.amount,
self.start_time,
self.selected_incentive,
self.selected_delay,
self.aux_incentive,
self.aux_delay,
])
def pack_reward_proof(
channel_identifier: ChannelID,
reward_amount: TokenAmount,
token_network_address: TokenNetworkID,
chain_id: ChainID,
nonce: Nonce,
) -> bytes:
return pack_data([
'uint256',
'uint256',
'address',
'uint256',
'uint256',
], [
channel_identifier,
reward_amount,
token_network_address,
chain_id,
nonce,
])
def packed_balance_proof_data(
self,
message_type: MessageTypeId = MessageTypeId.BALANCE_PROOF,
) -> bytes:
return pack_data([
'address',
'uint256',
'uint256',
'uint256',
'bytes32',
'uint256',
'bytes32',
], [
self.token_network_address,
self.chain_id,
message_type.value,
self.channel_identifier,
decode_hex(self.balance_hash),
self.nonce,
decode_hex(self.additional_hash),
])
def get_partner_leaves(self):
leaves = list(self.leaves[1-self.i].values())
types = ["bytes" for _ in leaves]
return pack_data(types, leaves)
