def execute(args: Namespace, wallet_passwd: str) -> None: from hathor.crypto.util import get_private_key_bytes, get_public_key_bytes_compressed from hathor.wallet import Wallet from hathor.wallet.util import generate_multisig_address, generate_multisig_redeem_script if (args.pubkey_count and args.pubkey_count > 16) or args.signatures_required > 16: print( 'Error: maximum number of public keys or signatures required is 16' ) return if not args.pubkey_count and not args.public_keys: print('Error: you must give at least pubkey_count or public_keys') return if args.dir: wallet = Wallet(directory=args.dir) else: wallet = Wallet() wallet.unlock(wallet_passwd.encode()) if args.public_keys: public_keys_hex = args.public_keys.split(',') public_bytes = [bytes.fromhex(pkh) for pkh in public_keys_hex] else: # If not public keys as parameter, we need to create them public_bytes = [] for i in range(args.pubkey_count): addr = wallet.get_unused_address() key = wallet.keys[addr] pk = key.get_private_key(wallet_passwd.encode()) public_key_bytes = get_public_key_bytes_compressed(pk.public_key()) public_bytes.append(public_key_bytes) print('------------------\n') print('Key {}\n'.format(i + 1)) print('Private key: {}\n'.format( get_private_key_bytes( pk, encryption_algorithm=serialization.BestAvailableEncryption( wallet_passwd.encode())).hex())) print('Public key: {}\n'.format(public_key_bytes.hex())) print('Address: {}\n'.format(addr)) # Then we create the redeem script redeem_script = generate_multisig_redeem_script(args.signatures_required, public_bytes) print('------------------\n') print('Redeem script:', redeem_script.hex()) print('\n') # Then we created the multisig address address = generate_multisig_address(redeem_script) print('------------------\n') print('MultiSig address:', address) print('------------------\n\n')
def create(cls, password: Optional[bytes]) -> 'KeyPair': """ :raises WalletLocked: wallet password was not provided """ if not password: raise WalletLocked new_key = ec.generate_private_key(ec.SECP256K1(), default_backend()) private_key_bytes = get_private_key_bytes(new_key, encryption_algorithm=serialization.BestAvailableEncryption(password)) address = get_address_b58_from_public_key(new_key.public_key()) return cls(private_key_bytes=private_key_bytes, address=address, used=False)
def main(): from hathor.cli.util import create_parser from hathor.crypto.util import get_hash160, get_private_key_bytes, get_public_key_bytes_compressed parser = create_parser() parser.add_argument('filepath', help='Create a new private key in the given file') args = parser.parse_args() new_key = ec.generate_private_key(ec.SECP256K1(), default_backend()) private_key_bytes = get_private_key_bytes(new_key) with open(args.filepath, 'w') as key_file: key_file.write(base64.b64encode(private_key_bytes).decode('utf-8')) print('key created!') public_key_bytes = get_public_key_bytes_compressed(new_key.public_key()) print('base64 pubkey hash:', base64.b64encode(get_hash160(public_key_bytes)).decode('utf-8'))
def test_wallet_create_transaction(self): genesis_private_key_bytes = get_private_key_bytes( self.genesis_private_key, encryption_algorithm=serialization.BestAvailableEncryption( PASSWORD)) genesis_address = get_address_b58_from_public_key( self.genesis_public_key) # create wallet with genesis block key key_pair = KeyPair(private_key_bytes=genesis_private_key_bytes, address=genesis_address, used=True) keys = {} keys[key_pair.address] = key_pair w = Wallet(keys=keys, directory=self.directory) w.unlock(PASSWORD) genesis_blocks = [ tx for tx in get_genesis_transactions(None) if tx.is_block ] genesis_block = genesis_blocks[0] genesis_value = sum([output.value for output in genesis_block.outputs]) # wallet will receive genesis block and store in unspent_tx w.on_new_tx(genesis_block) for index in range(len(genesis_block.outputs)): utxo = w.unspent_txs[settings.HATHOR_TOKEN_UID].get( (genesis_block.hash, index)) self.assertIsNotNone(utxo) self.assertEqual(w.balance[settings.HATHOR_TOKEN_UID], WalletBalance(0, genesis_value)) # create transaction spending this value, but sending to same wallet new_address = w.get_unused_address() out = WalletOutputInfo(decode_address(new_address), 100, timelock=None) tx1 = w.prepare_transaction_compute_inputs(Transaction, outputs=[out]) tx1.storage = self.storage tx1.update_hash() self.storage.save_transaction(tx1) w.on_new_tx(tx1) self.assertEqual(len(w.spent_txs), 1) self.assertEqual(w.balance[settings.HATHOR_TOKEN_UID], WalletBalance(0, genesis_value)) # pass inputs and outputs to prepare_transaction, but not the input keys # spend output last transaction input_info = WalletInputInfo(tx1.hash, 1, None) new_address = w.get_unused_address() key2 = w.keys[new_address] out = WalletOutputInfo(decode_address(key2.address), 100, timelock=None) tx2 = w.prepare_transaction_incomplete_inputs(Transaction, inputs=[input_info], outputs=[out], tx_storage=self.storage) tx2.storage = self.storage tx2.update_hash() self.storage.save_transaction(tx2) w.on_new_tx(tx2) self.assertEqual(len(w.spent_txs), 2) self.assertEqual(w.balance[settings.HATHOR_TOKEN_UID], WalletBalance(0, genesis_value)) # test keypair exception with self.assertRaises(WalletLocked): key_pair.get_private_key(None)
def test_privkey_serialization(self): private_key_bytes = get_private_key_bytes(self.private_key) self.assertEqual( self.private_key.private_numbers(), get_private_key_from_bytes(private_key_bytes).private_numbers())