def sign(privkey: str, msg: bytes, v=0) -> bytes:
assert isinstance(msg, bytes)
assert isinstance(privkey, str)
pk = PrivateKey.from_hex(remove_0x_prefix(privkey))
assert len(msg) == 32
sig = pk.sign_recoverable(msg, hasher=None)
assert len(sig) == 65
sig = sig[:-1] + bytes([sig[-1] + v])
return sig
def generate_privkey() -> bytes:
return encode_hex(PrivateKey().secret)
def __init__(
self,
chain,
default_registry,
private_key_bin,
transport,
config,
discovery=None,
):
if not isinstance(private_key_bin,
bytes) or len(private_key_bin) != 32:
raise ValueError('invalid private_key')
invalid_timeout = (
config['settle_timeout'] < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
or config['settle_timeout'] > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)
if invalid_timeout:
raise ValueError('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN,
NETTINGCHANNEL_SETTLE_TIMEOUT_MAX))
self.tokens_to_connectionmanagers = dict()
self.identifier_to_results = defaultdict(list)
# This is a map from a secrethash to a list of channels, the same
# secrethash can be used in more than one token (for tokenswaps), a
# channel should be removed from this list only when the lock is
# released/withdrawn but not when the secret is registered.
self.token_to_secrethash_to_channels = defaultdict(
lambda: defaultdict(list))
self.chain = chain
self.default_registry = default_registry
self.config = config
self.privkey = private_key_bin
self.address = privatekey_to_address(private_key_bin)
if config['transport_type'] == 'udp':
endpoint_registration_event = gevent.spawn(
discovery.register,
self.address,
config['external_ip'],
config['external_port'],
)
endpoint_registration_event.link_exception(
endpoint_registry_exception_handler)
self.private_key = PrivateKey(private_key_bin)
self.pubkey = self.private_key.public_key.format(compressed=False)
self.protocol = transport
self.blockchain_events = BlockchainEvents()
self.alarm = AlarmTask(chain)
self.shutdown_timeout = config['shutdown_timeout']
self._block_number = None
self.stop_event = Event()
self.start_event = Event()
self.chain.client.inject_stop_event(self.stop_event)
self.wal = None
self.database_path = config['database_path']
if self.database_path != ':memory:':
database_dir = os.path.dirname(config['database_path'])
os.makedirs(database_dir, exist_ok=True)
self.database_dir = database_dir
# Prevent concurrent acces to the same db
self.lock_file = os.path.join(self.database_dir, '.lock')
self.db_lock = filelock.FileLock(self.lock_file)
else:
self.database_path = ':memory:'
self.database_dir = None
self.lock_file = None
self.serialization_file = None
self.db_lock = None
if config['transport_type'] == 'udp':
# If the endpoint registration fails the node will quit, this must
# finish before starting the protocol
endpoint_registration_event.join()
# Lock used to serialize calls to `poll_blockchain_events`, this is
# important to give a consistent view of the node state.
self.event_poll_lock = gevent.lock.Semaphore()
self.start()
def test_receive_mediatedtransfer_invalid_address(raiden_network, private_keys):
alice_app = raiden_network[0]
messages = setup_messages_cb()
graph = alice_app.raiden.channelgraphs.values()[0]
token_address = graph.token_address
mt_helper = MediatedTransferTestHelper(raiden_network, graph)
initiator_address = alice_app.raiden.address
path = mt_helper.get_paths_of_length(initiator_address, 2)
alice_address, bob_address, charlie_address = path
amount = 10
result = alice_app.raiden.transfer_async(
token_address,
amount,
charlie_address,
)
# check for invitation ping
assert len(messages) == 2 # Ping, Ack
ping_message = decode(messages[0])
assert isinstance(ping_message, Ping)
decoded = decode(messages[1])
assert isinstance(decoded, Ack)
assert decoded.echo == sha3(ping_message.encode() + charlie_address)
assert result.wait(timeout=10)
gevent.sleep(1.)
# check that transfer messages were added
assert len(messages) == 22 # Ping, Ack + tranfer messages
# make sure that the mediated transfer is sent after the invitation ping
assert isinstance(decode(messages[2]), MediatedTransfer)
# and now send one more mediated transfer with the same nonce, simulating
# an out-of-order/resent message that arrives late
locksroot = HASH
lock = Lock(amount, 1, locksroot)
identifier = create_default_identifier(
alice_app.raiden.address,
graph.token_address,
charlie_address,
)
mediated_transfer = MediatedTransfer(
identifier=identifier,
nonce=1,
token=token_address,
transferred_amount=amount,
recipient=bob_address,
locksroot=locksroot,
lock=lock,
target=charlie_address,
initiator=initiator_address,
fee=0
)
alice_key = PrivateKey(private_keys[0])
target_app = None
for app in raiden_network:
if app.raiden.address not in path:
target_app = app
break
sign_and_send(mediated_transfer, alice_key, alice_address, target_app)
def make_privkey_address():
private_key_bin = os.urandom(32)
privkey = PrivateKey(private_key_bin)
pubkey = privkey.public_key.format(compressed=False)
address = publickey_to_address(pubkey)
return privkey, address
def __init__(self):
super().__init__()
self.log = list()
self.settle_timeout = 10
deployer_key = PrivateKey(secret=b'deploy_key')
pyevm_main.GENESIS_GAS_LIMIT = 6 * 10**6
self.tester_chain = ethereum_tester()
self.web3 = get_web3(self.tester_chain, deployer_key)
self.tokens = [
deploy_custom_token(
self.web3,
deployer_key,
),
deploy_custom_token(
self.web3,
deployer_key,
),
]
self.token = self.tokens[0]
self.token_addresses = [token.address for token in self.tokens]
self.private_keys = [
PrivateKey(secret=b'p1'),
PrivateKey(secret=b'p2'),
PrivateKey(secret=b'p3'),
]
# Create and fund accounts with Ether and CustomToken
self.addresses = []
token_amount = 100000
for private_key in self.private_keys:
self.tester_chain.add_account(private_key.to_hex())
address = private_key_to_address(private_key.to_hex())
self.tester_chain.send_transaction({
'from':
self.tester_chain.get_accounts()[0],
'to':
address,
'gas':
21000,
'value':
self.web3.toWei(100, 'ether'),
})
self.token.functions.transfer(
address,
token_amount,
).transact({
'from': private_key_to_address(deployer_key.to_hex()),
})
self.addresses.append(address)
self.secret_registry = deploy_contract(
self.web3,
CONTRACT_SECRET_REGISTRY,
deployer_key,
[], # No Libs
[], # No Args
)
self.token_network_registry = deploy_contract(
self.web3,
CONTRACT_TOKEN_NETWORK_REGISTRY,
deployer_key,
[],
[
self.secret_registry.address,
1,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
],
)
self.token_network_registry.functions.createERC20TokenNetwork(
self.token.address,
MAX_ETH_CHANNEL_PARTICIPANT,
MAX_ETH_TOKEN_NETWORK,
).transact()
token_network_address = self.token_network_registry.functions.token_to_token_networks(
self.token.address, ).call()
self.token_network = get_token_network(
self.web3,
to_checksum_address(token_network_address),
)
channel_identifier = self.open_channel()
self.closing_address = None
self.update_transfer_called = False
self.participant_addresses = {
self.addresses[0],
self.addresses[1],
}
self.channel_addresses = [
channel_identifier,
make_address(),
]
class Kutil:
def __init__(self, network: str, privkey=None, seed=None, wif=None):
'''wif=<WIF> import private key from your wallet in WIF format
privkey=<privkey> import private key in binary format
network=<network> specify network [ppc, tppc, btc]
seed=<seed> specify seed (string) to make the privkey from'''
if privkey is not None:
self.keypair = PrivateKey(unhexlify(privkey))
if seed is not None:
self.keypair = PrivateKey(sha256(seed.encode()).hexdigest())
if wif is not None:
key = self.wif_to_privkey(wif)
self.keypair = PrivateKey(key["privkey"])
network = key['net_prefix']
if privkey == seed == wif is None:
self.keypair = PrivateKey()
if not is_ecdsa:
self.privkey = self.keypair.to_hex().encode()
self.pubkey = hexlify(self.keypair.public_key.format())
else:
self.privkey = self.keypair.private_key
self.pubkey = self.keypair.public_key
self.load_network_parameters(network)
def load_network_parameters(self, network: str) -> None:
'''loads network parameters and sets class variables'''
for field, var in zip(query(network)._fields, query(network)):
setattr(self, field, var)
def wif_to_privkey(self, wif: str) -> dict:
'''import WIF'''
if not 51 <= len(wif) <= 52:
return 'Invalid WIF length'
b58_wif = b58decode(wif)
return {'privkey': b58_wif[1:33], 'net_prefix': hexlify(b58_wif[0:1])}
@property
def address(self) -> str:
'''generate an address from pubkey'''
key = unhexlify(self.pubkey) # compressed pubkey as default
keyhash = unhexlify(
self.pubkeyhash +
hexlify(new('ripemd160',
sha256(key).digest()).digest()))
checksum = sha256(sha256(keyhash).digest()).digest()[0:4]
address = keyhash + checksum
return b58encode(address)
@property
def wif(self) -> str:
'''convert raw private key to WIF'''
extkey = unhexlify(self.wif_prefix + self.privkey +
b'01') # compressed by default
extcheck = extkey + sha256(sha256(extkey).digest()).digest()[0:4]
wif = b58encode(extcheck)
return wif
def test_withdraw_tampered_lock_amount(
tree,
tester_channels,
tester_chain,
tester_token,
settle_timeout,
):
""" withdraw must fail if the lock amonut is tampered. """
pkey0, pkey1, nettingchannel, channel0, _ = tester_channels[0]
current_block = tester_chain.block.number
expiration = current_block + settle_timeout - 1
locks = [
make_lock(
secrethash=secrethash,
expiration=expiration,
)
for secrethash in tree
]
leaves = [sha3(lock.as_bytes) for lock in locks]
layers = compute_layers(leaves)
merkle_tree = MerkleTreeState(layers)
opened_block = nettingchannel.opened(sender=pkey0)
nonce = 1 + (opened_block * (2 ** 32))
direct_transfer = make_direct_transfer(
nonce=nonce,
channel=channel0.identifier,
locksroot=merkleroot(merkle_tree),
token=tester_token.address,
recipient=privatekey_to_address(pkey1),
)
address = privatekey_to_address(pkey0)
sign_key = PrivateKey(pkey0)
direct_transfer.sign(sign_key, address)
direct_transfer_hash = sha3(direct_transfer.packed().data[:-65])
nettingchannel.close(
direct_transfer.nonce,
direct_transfer.transferred_amount,
direct_transfer.locksroot,
direct_transfer_hash,
direct_transfer.signature,
sender=pkey1,
)
for lock in locks:
secret = SECRETHASHES_SECRESTS[lock.secrethash]
lock_encoded = lock.as_bytes
merkle_proof = compute_merkleproof_for(merkle_tree, sha3(lock_encoded))
tampered_lock = make_lock(
amount=lock.amount * 100,
secrethash=lock.secrethash,
expiration=lock.expiration,
)
tampered_lock_encoded = sha3(tampered_lock.as_bytes)
with pytest.raises(TransactionFailed):
nettingchannel.withdraw(
tampered_lock_encoded,
b''.join(merkle_proof),
secret,
sender=pkey1,
)
def test_private_key_sign(benchmark):
private_key = PrivateKey(PRIVATE_KEY_BYTES)
benchmark(private_key.sign, MESSAGE)
def privatekey_to_publickey(private_key_bin: bytes) -> bytes:
""" Returns public key in bitcoins 'bin' encoding. """
if not ishash(private_key_bin):
raise ValueError('private_key_bin format mismatch. maybe hex encoded?')
private_key = PrivateKey(private_key_bin)
return private_key.public_key.format(compressed=False)
def fx_private_key() -> PrivateKey:
return PrivateKey()
def __init__(
self,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
private_key_bin,
transport,
config,
discovery=None,
):
if not isinstance(private_key_bin,
bytes) or len(private_key_bin) != 32:
raise ValueError('invalid private_key')
self.tokennetworkids_to_connectionmanagers = dict()
self.identifier_to_results = defaultdict(list)
self.chain: BlockChainService = chain
self.default_registry = default_registry
self.query_start_block = query_start_block
self.default_secret_registry = default_secret_registry
self.config = config
self.privkey = private_key_bin
self.address = privatekey_to_address(private_key_bin)
self.discovery = discovery
if config['transport_type'] == 'udp':
endpoint_registration_event = gevent.spawn(
discovery.register,
self.address,
config['external_ip'],
config['external_port'],
)
endpoint_registration_event.link_exception(
endpoint_registry_exception_handler)
self.private_key = PrivateKey(private_key_bin)
self.pubkey = self.private_key.public_key.format(compressed=False)
self.transport = transport
self.blockchain_events = BlockchainEvents()
self.alarm = AlarmTask(chain)
self.shutdown_timeout = config['shutdown_timeout']
self.stop_event = Event()
self.start_event = Event()
self.chain.client.inject_stop_event(self.stop_event)
self.wal = None
self.database_path = config['database_path']
if self.database_path != ':memory:':
database_dir = os.path.dirname(config['database_path'])
os.makedirs(database_dir, exist_ok=True)
self.database_dir = database_dir
# Prevent concurrent access to the same db
self.lock_file = os.path.join(self.database_dir, '.lock')
self.db_lock = filelock.FileLock(self.lock_file)
else:
self.database_path = ':memory:'
self.database_dir = None
self.lock_file = None
self.serialization_file = None
self.db_lock = None
if config['transport_type'] == 'udp':
# If the endpoint registration fails the node will quit, this must
# finish before starting the transport
endpoint_registration_event.join()
self.event_poll_lock = gevent.lock.Semaphore()
self.start()
def sign_recoverable(hash_msg_str, pk_str):
from coincurve import PrivateKey
pk = PrivateKey(bytearray.fromhex(pk_str))
return pk.sign_recoverable(hash2hex(hash_msg_str), hasher=None).hex()
def __init__(self, chain, private_key_bin, transport, discovery, config):
if not isinstance(private_key_bin, bytes) or len(private_key_bin) != 32:
raise ValueError('invalid private_key')
private_key = PrivateKey(private_key_bin)
pubkey = private_key.public_key.format(compressed=False)
self.channelgraphs = dict()
self.manager_token = dict()
self.swapkeys_tokenswaps = dict()
self.swapkeys_greenlettasks = dict()
self.identifier_statemanager = defaultdict(list)
self.identifier_result = defaultdict(list)
# This is a map from a hashlock to a list of channels, the same
# hashlock can be used in more than one token (for tokenswaps), a
# channel should be removed from this list only when the lock is
# released/withdrawn but not when the secret is registered.
self.tokens_hashlocks_channels = defaultdict(lambda: defaultdict(list))
self.chain = chain
self.config = config
self.privkey = private_key_bin
self.pubkey = pubkey
self.private_key = private_key
self.address = privatekey_to_address(private_key_bin)
self.protocol = RaidenProtocol(transport, discovery, self)
transport.protocol = self.protocol
message_handler = RaidenMessageHandler(self)
state_machine_event_handler = StateMachineEventHandler(self)
pyethapp_blockchain_events = PyethappBlockchainEvents()
greenlet_task_dispatcher = GreenletTasksDispatcher()
alarm = AlarmTask(chain)
# ignore the blocknumber
alarm.register_callback(self.poll_blockchain_events)
alarm.start()
self._blocknumber = alarm.last_block_number
alarm.register_callback(self.set_block_number)
if config['max_unresponsive_time'] > 0:
self.healthcheck = HealthcheckTask(
self,
config['send_ping_time'],
config['max_unresponsive_time']
)
self.healthcheck.start()
else:
self.healthcheck = None
self.api = RaidenAPI(self)
self.alarm = alarm
self.message_handler = message_handler
self.state_machine_event_handler = state_machine_event_handler
self.pyethapp_blockchain_events = pyethapp_blockchain_events
self.greenlet_task_dispatcher = greenlet_task_dispatcher
self.on_message = message_handler.on_message
self.tokens_connectionmanagers = dict() # token_address: ConnectionManager
def __init__(self, chain, default_registry, private_key_bin, transport,
discovery, config):
if not isinstance(private_key_bin,
bytes) or len(private_key_bin) != 32:
raise ValueError('invalid private_key')
invalid_timeout = (
config['settle_timeout'] < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
or config['settle_timeout'] > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)
if invalid_timeout:
raise ValueError('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN,
NETTINGCHANNEL_SETTLE_TIMEOUT_MAX))
self.token_to_channelgraph = dict()
self.tokens_to_connectionmanagers = dict()
self.manager_to_token = dict()
self.swapkey_to_tokenswap = dict()
self.swapkey_to_greenlettask = dict()
self.identifier_to_statemanagers = defaultdict(list)
self.identifier_to_results = defaultdict(list)
# This is a map from a hashlock to a list of channels, the same
# hashlock can be used in more than one token (for tokenswaps), a
# channel should be removed from this list only when the lock is
# released/withdrawn but not when the secret is registered.
self.token_to_hashlock_to_channels = defaultdict(
lambda: defaultdict(list))
self.chain = chain
self.default_registry = default_registry
self.config = config
self.privkey = private_key_bin
self.address = privatekey_to_address(private_key_bin)
endpoint_registration_event = gevent.spawn(
discovery.register,
self.address,
config['external_ip'],
config['external_port'],
)
endpoint_registration_event.link_exception(
endpoint_registry_exception_handler)
self.private_key = PrivateKey(private_key_bin)
self.pubkey = self.private_key.public_key.format(compressed=False)
self.protocol = RaidenProtocol(
transport,
discovery,
self,
config['protocol']['retry_interval'],
config['protocol']['retries_before_backoff'],
config['protocol']['nat_keepalive_retries'],
config['protocol']['nat_keepalive_timeout'],
config['protocol']['nat_invitation_timeout'],
)
# TODO: remove this cyclic dependency
transport.protocol = self.protocol
self.message_handler = RaidenMessageHandler(self)
self.state_machine_event_handler = StateMachineEventHandler(self)
self.blockchain_events = BlockchainEvents()
self.greenlet_task_dispatcher = GreenletTasksDispatcher()
self.on_message = self.message_handler.on_message
self.alarm = AlarmTask(chain)
self.shutdown_timeout = config['shutdown_timeout']
self._block_number = None
self.stop_event = Event()
self.start_event = Event()
self.chain.client.inject_stop_event(self.stop_event)
self.transaction_log = StateChangeLog(
storage_instance=StateChangeLogSQLiteBackend(
database_path=config['database_path']))
if config['database_path'] != ':memory:':
self.database_dir = os.path.dirname(config['database_path'])
self.lock_file = os.path.join(self.database_dir, '.lock')
self.snapshot_dir = os.path.join(self.database_dir, 'snapshots')
self.serialization_file = os.path.join(self.snapshot_dir,
'data.pickle')
if not os.path.exists(self.snapshot_dir):
os.makedirs(self.snapshot_dir)
# Prevent concurrent acces to the same db
self.db_lock = filelock.FileLock(self.lock_file)
else:
self.database_dir = None
self.lock_file = None
self.snapshot_dir = None
self.serialization_file = None
self.db_lock = None
# If the endpoint registration fails the node will quit, this must
# finish before starting the protocol
endpoint_registration_event.join()
self.start()
def test_private_key_sign_recoverable(benchmark):
private_key = PrivateKey(PRIVATE_KEY_BYTES)
benchmark(private_key.sign_recoverable, MESSAGE)
def test_withdraw_tampered_merkle_proof(tree, tester_channels, tester_chain, settle_timeout):
""" withdraw must fail if the proof is tampered. """
pkey0, pkey1, nettingchannel, channel0, _ = tester_channels[0]
current_block = tester_chain.block.number
expiration = current_block + settle_timeout - 1
locks = [
make_lock(
secrethash=secrethash,
expiration=expiration,
)
for secrethash in tree
]
leaves = [sha3(lock.as_bytes) for lock in locks]
layers = compute_layers(leaves)
merkle_tree = MerkleTreeState(layers)
opened_block = nettingchannel.opened(sender=pkey0)
nonce = 1 + (opened_block * (2 ** 32))
direct_transfer = make_direct_transfer(
nonce=nonce,
channel=channel0.identifier,
locksroot=merkleroot(merkle_tree),
recipient=privatekey_to_address(pkey1),
)
address = privatekey_to_address(pkey0)
sign_key = PrivateKey(pkey0)
direct_transfer.sign(sign_key, address)
direct_transfer_hash = sha3(direct_transfer.packed().data[:-65])
nettingchannel.close(
direct_transfer.nonce,
direct_transfer.transferred_amount,
direct_transfer.locksroot,
direct_transfer_hash,
direct_transfer.signature,
sender=pkey1,
)
for lock in locks:
secret = SECRETHASHES_SECRESTS[lock.secrethash]
lock_encoded = lock.as_bytes
merkle_proof = compute_merkleproof_for(merkle_tree, sha3(lock_encoded))
# withdraw must fail regardless of which part of the proof is tampered
for pos, hash_ in enumerate(merkle_proof):
# changing arbitrary bytes from the proof
tampered_hash = bytearray(hash_)
tampered_hash[6], tampered_hash[7] = tampered_hash[7], tampered_hash[6]
tampered_proof = list(merkle_proof)
tampered_proof[pos] = tampered_hash
joiner = b''
with pytest.raises(TransactionFailed):
nettingchannel.withdraw(
lock_encoded,
joiner.join(tampered_proof),
secret,
sender=pkey1,
)
def test_private_key_ecdh(benchmark):
private_key = PrivateKey(PRIVATE_KEY_BYTES)
benchmark(private_key.ecdh, PUBLIC_KEY_COMPRESSED)
def test_withdraw_tampered_merkle_proof(tree, tester_channels, tester_state,
settle_timeout):
""" withdraw must fail if the proof is tampered. """
pkey0, pkey1, nettingchannel, channel0, _ = tester_channels[0]
current_block = tester_state.block.number
expiration = current_block + settle_timeout - 1
locks = [
make_lock(
hashlock=hashlock,
expiration=expiration,
) for hashlock in tree
]
merkle_tree = Merkletree(sha3(lock.as_bytes) for lock in locks)
opened_block = nettingchannel.opened(sender=pkey0)
nonce = 1 + (opened_block * (2**32))
direct_transfer = make_direct_transfer(
nonce=nonce,
channel=channel0.channel_address,
locksroot=merkle_tree.merkleroot,
recipient=privatekey_to_address(pkey1))
address = privatekey_to_address(pkey0)
sign_key = PrivateKey(pkey0)
direct_transfer.sign(sign_key, address)
direct_transfer_hash = sha3(direct_transfer.packed().data[:-65])
nettingchannel.close(
direct_transfer.nonce,
direct_transfer.transferred_amount,
direct_transfer.locksroot,
direct_transfer_hash,
direct_transfer.signature,
sender=pkey1,
)
for lock in locks:
secret = HASHLOCKS_SECRESTS[lock.hashlock]
lock_encoded = lock.as_bytes
merkle_proof = merkle_tree.make_proof(sha3(lock_encoded))
# withdraw must fail regardless of which part of the proof is tampered
for pos, hash_ in enumerate(merkle_proof):
# changing arbitrary bytes from the proof
tampered_hash = bytearray(hash_)
tampered_hash[5], tampered_hash[6] = tampered_hash[
6], tampered_hash[5]
tampered_proof = list(merkle_proof)
tampered_proof[pos] = str(tampered_hash)
with pytest.raises(TransactionFailed):
nettingchannel.withdraw(
lock_encoded,
''.join(tampered_proof),
secret,
sender=pkey1,
)
def ecdsa_sign(msghash, privkey):
pk = PrivateKey(privkey)
return pk.sign_recoverable(msghash, hasher=None)
def private_key_to_address(private_key: PrivateKeyType) -> Address:
"""Converts a private key to an Ethereum address."""
privkey = PrivateKey(private_key)
return public_key_to_address(privkey.public_key)
def privatekeyHexToAddress(priv):
pk = PrivateKey.from_hex(priv)
publ = pk.public_key.format(compressed=False)[1:]
return publickeyToAddress(publ)
UNIT_PAYMENT_NETWORK_IDENTIFIER = b'paymentnetworkidentifier'
UNIT_TRANSFER_IDENTIFIER = 37
UNIT_TRANSFER_INITIATOR = b'initiatorinitiatorin'
UNIT_TRANSFER_TARGET = b'targettargettargetta'
UNIT_TRANSFER_DESCRIPTION = TransferDescriptionWithSecretState(
UNIT_PAYMENT_NETWORK_IDENTIFIER,
UNIT_TRANSFER_IDENTIFIER,
UNIT_TRANSFER_AMOUNT,
UNIT_TOKEN_NETWORK_ADDRESS,
UNIT_TRANSFER_INITIATOR,
UNIT_TRANSFER_TARGET,
UNIT_SECRET,
)
UNIT_TRANSFER_PKEY_BIN = sha3(b'transfer pkey')
UNIT_TRANSFER_PKEY = PrivateKey(UNIT_TRANSFER_PKEY_BIN)
UNIT_TRANSFER_SENDER = privatekey_to_address(sha3(b'transfer pkey'))
HOP1_KEY = PrivateKey(b'11111111111111111111111111111111')
HOP2_KEY = PrivateKey(b'22222222222222222222222222222222')
HOP3_KEY = PrivateKey(b'33333333333333333333333333333333')
HOP4_KEY = PrivateKey(b'44444444444444444444444444444444')
HOP5_KEY = PrivateKey(b'55555555555555555555555555555555')
HOP6_KEY = PrivateKey(b'66666666666666666666666666666666')
HOP1 = privatekey_to_address(b'11111111111111111111111111111111')
HOP2 = privatekey_to_address(b'22222222222222222222222222222222')
HOP3 = privatekey_to_address(b'33333333333333333333333333333333')
HOP4 = privatekey_to_address(b'44444444444444444444444444444444')
HOP5 = privatekey_to_address(b'55555555555555555555555555555555')
HOP6 = privatekey_to_address(b'66666666666666666666666666666666')
UNIT_CHAIN_ID = 337
def __init__(
self,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
private_key_bin,
transport,
raiden_event_handler,
config,
discovery=None,
):
super().__init__()
if not isinstance(private_key_bin,
bytes) or len(private_key_bin) != 32:
raise ValueError('invalid private_key')
self.tokennetworkids_to_connectionmanagers = dict()
self.identifier_to_results: typing.Dict[typing.PaymentID,
AsyncResult, ] = dict()
self.chain: BlockChainService = chain
self.default_registry = default_registry
self.query_start_block = query_start_block
self.default_secret_registry = default_secret_registry
self.config = config
self.privkey = private_key_bin
self.address = privatekey_to_address(private_key_bin)
self.discovery = discovery
self.private_key = PrivateKey(private_key_bin)
self.pubkey = self.private_key.public_key.format(compressed=False)
self.transport = transport
self.blockchain_events = BlockchainEvents()
self.alarm = AlarmTask(chain)
self.raiden_event_handler = raiden_event_handler
self.stop_event = Event()
self.stop_event.set() # inits as stopped
self.wal = None
self.snapshot_group = 0
# This flag will be used to prevent the service from processing
# state changes events until we know that pending transactions
# have been dispatched.
self.dispatch_events_lock = Semaphore(1)
self.database_path = config['database_path']
if self.database_path != ':memory:':
database_dir = os.path.dirname(config['database_path'])
os.makedirs(database_dir, exist_ok=True)
self.database_dir = database_dir
# Prevent concurrent access to the same db
self.lock_file = os.path.join(self.database_dir, '.lock')
self.db_lock = filelock.FileLock(self.lock_file)
else:
self.database_path = ':memory:'
self.database_dir = None
self.lock_file = None
self.serialization_file = None
self.db_lock = None
self.event_poll_lock = gevent.lock.Semaphore()
def to_pubkey(self) -> bytes:
"""Computes and sends back pubkey, point(kpar) of current key(kpar)"""
kpar = PrivateKey.from_hex(self.seed[:32].hex())
K = kpar.public_key.format(compressed=False)
return K
import pytest
from coincurve import PrivateKey
from flask import Flask, request, jsonify
from pyln.testing.fixtures import * # noqa: F401,F403
import common.receipts as receipts
from common import constants, errors
from common.appointment import Appointment, AppointmentStatus
from common.cryptographer import Cryptographer
plugin_path = os.path.join(os.path.dirname(__file__), "watchtower.py")
tower_netaddr = "localhost"
tower_port = "1234"
tower_sk = PrivateKey()
tower_id = Cryptographer.get_compressed_pk(tower_sk.public_key)
mocked_return = None
# The height is never checked on the tests, so it can be hardcoded
CURRENT_HEIGHT = 1000
class TowerMock:
def __init__(self, tower_sk):
self.sk = tower_sk
self.users = {}
self.app = Flask(__name__)
# Adds all the routes to the functions listed above.
def test_withdraw_at_settlement_block(
deposit,
settle_timeout,
tester_nettingcontracts,
tester_state,
tester_token):
""" It must be possible to unlock a lock up to and including the settlment
block.
"""
pkey0, pkey1, nettingchannel = tester_nettingcontracts[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
initial_balance0 = tester_token.balanceOf(address0, sender=pkey0)
initial_balance1 = tester_token.balanceOf(address1, sender=pkey0)
lock_amount = 31
lock_expiration = tester_state.block.number + settle_timeout
secret = 'settlementsettlementsettlementse'
hashlock = sha3(secret)
lock0 = Lock(
amount=lock_amount,
expiration=lock_expiration,
hashlock=hashlock,
)
lock0_bytes = bytes(lock0.as_bytes)
lock0_hash = sha3(lock0_bytes)
opened_block = nettingchannel.opened(sender=pkey0)
nonce = 1 + (opened_block * (2 ** 32))
mediated0 = MediatedTransfer(
identifier=1,
nonce=nonce,
token=tester_token.address,
transferred_amount=0,
recipient=address1,
locksroot=lock0_hash,
lock=lock0,
target=address1,
initiator=address0,
fee=0,
)
sign_key0 = PrivateKey(pkey0)
mediated0.sign(sign_key0, address0)
mediated0_data = str(mediated0.packed().data)
nettingchannel.close(mediated0_data, sender=pkey1)
block_until_settlement_end = lock_expiration - tester_state.block.number
tester_state.mine(number_of_blocks=block_until_settlement_end)
assert lock_expiration == tester_state.block.number
nettingchannel.withdraw(
lock0_bytes,
'', # the lock itself it the root, the proof is empty
secret,
sender=pkey1,
)
tester_state.mine(number_of_blocks=1)
nettingchannel.settle(sender=pkey0)
balance0 = initial_balance0 + deposit - lock0.amount
balance1 = initial_balance1 + deposit + lock0.amount
assert tester_token.balanceOf(address0, sender=pkey0) == balance0
assert tester_token.balanceOf(address1, sender=pkey0) == balance1
assert tester_token.balanceOf(nettingchannel.address, sender=pkey0) == 0
def make_privatekey(privatekey_bin: bytes = EMPTY) -> PrivateKey:
privatekey_bin = if_empty(privatekey_bin, make_privatekey_bin())
return PrivateKey(privatekey_bin)
words = mnemo.generate(strength=128)
seed = mnemo.to_seed(words, passphrase="")
#print(seed)
from coincurve import PrivateKey,PublicKey
from bip44 import Wallet
from bip44.utils import get_eth_addr
mnemonic = "purity tunnel grid error scout long fruit false embody caught skin gate"
w = Wallet(mnemonic)
sk, pk = w.derive_account("eth", account=0)
sk = PrivateKey(sk)
print(sk.public_key.format() == pk)
pk=PublicKey(pk)
print(pk)
def test_withdraw_at_settlement_block(
tester_registry_address,
deposit,
settle_timeout,
tester_nettingcontracts,
tester_chain,
tester_token,
):
""" It must be possible to unlock a lock up to and including the settlment
block.
"""
pkey0, pkey1, nettingchannel = tester_nettingcontracts[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
initial_balance0 = tester_token.balanceOf(address0, sender=pkey0)
initial_balance1 = tester_token.balanceOf(address1, sender=pkey0)
lock_amount = 31
lock_expiration = tester_chain.block.number + settle_timeout
secret = b'settlementsettlementsettlementse'
secrethash = sha3(secret)
lock0 = Lock(
amount=lock_amount,
expiration=lock_expiration,
secrethash=secrethash,
)
lock0_bytes = bytes(lock0.as_bytes)
lock0_hash = sha3(lock0_bytes)
opened_block = nettingchannel.opened(sender=pkey0)
nonce = 1 + (opened_block * (2 ** 32))
message_identifier = random.randint(0, UINT64_MAX)
mediated0 = LockedTransfer(
message_identifier=message_identifier,
payment_identifier=1,
nonce=nonce,
registry_address=tester_registry_address,
token=tester_token.address,
channel=to_canonical_address(nettingchannel.address),
transferred_amount=0,
locked_amount=lock_amount,
recipient=address1,
locksroot=lock0_hash,
lock=lock0,
target=address1,
initiator=address0,
fee=0,
)
sign_key0 = PrivateKey(pkey0)
mediated0.sign(sign_key0, address0)
mediated0_hash = sha3(mediated0.packed().data[:-65])
nettingchannel.close(
mediated0.nonce,
mediated0.transferred_amount,
mediated0.locksroot,
mediated0_hash,
mediated0.signature,
sender=pkey1,
)
block_until_settlement_end = lock_expiration - tester_chain.block.number
tester_chain.mine(number_of_blocks=block_until_settlement_end)
assert lock_expiration == tester_chain.block.number
nettingchannel.withdraw(
lock0_bytes,
b'', # the lock itself it the root, the proof is empty
secret,
sender=pkey1,
)
tester_chain.mine(number_of_blocks=1)
nettingchannel.settle(sender=pkey0)
balance0 = initial_balance0 + deposit - lock0.amount
balance1 = initial_balance1 + deposit + lock0.amount
assert tester_token.balanceOf(address0, sender=pkey0) == balance0
assert tester_token.balanceOf(address1, sender=pkey0) == balance1
assert tester_token.balanceOf(nettingchannel.address, sender=pkey0) == 0
def privkey_to_addr(privkey: str) -> str:
return to_checksum_address(
pubkey_to_addr(PrivateKey.from_hex(remove_0x_prefix(privkey)).public_key)
)
def privkey_to_addr(privkey: str) -> str:
return to_checksum_address(
pubkey_to_addr(PrivateKey.from_hex(remove_0x_prefix(privkey)).public_key)
)