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) )