def execute(args: Namespace, priv_key_password: str) -> None:
from hathor.transaction import Transaction
from hathor.wallet.util import generate_signature
tx = Transaction.create_from_struct(bytes.fromhex(args.partial_tx))
assert isinstance(tx, Transaction)
signature = generate_signature(tx, bytes.fromhex(args.private_key), password=priv_key_password.encode())
print('Signature: ', signature.hex())
def test_spend_multisig(self):
# Adding funds to the wallet
# XXX: note further down the test, 20.00 HTR will be used, block_count must yield at least that amount
block_count = 3 # 3 * 8.00 -> 24.00 HTR is enough
blocks = add_new_blocks(self.manager, block_count, advance_clock=15)
add_blocks_unlock_reward(self.manager)
blocks_tokens = [sum(txout.value for txout in blk.outputs) for blk in blocks]
available_tokens = sum(blocks_tokens)
self.assertEqual(self.manager.wallet.balance[settings.HATHOR_TOKEN_UID], WalletBalance(0, available_tokens))
# First we send tokens to a multisig address
block_reward = blocks_tokens[0]
outputs = [WalletOutputInfo(address=self.multisig_address, value=block_reward, timelock=None)]
tx1 = self.manager.wallet.prepare_transaction_compute_inputs(Transaction, outputs, self.manager.tx_storage)
tx1.weight = 10
tx1.parents = self.manager.get_new_tx_parents()
tx1.timestamp = int(self.clock.seconds())
tx1.resolve()
self.manager.propagate_tx(tx1)
self.clock.advance(10)
wallet_balance = WalletBalance(0, available_tokens - block_reward)
self.assertEqual(self.manager.wallet.balance[settings.HATHOR_TOKEN_UID], wallet_balance)
# Then we create a new tx that spends this tokens from multisig wallet
tx = Transaction.create_from_struct(tx1.get_struct())
tx.weight = 10
tx.parents = self.manager.get_new_tx_parents()
tx.timestamp = int(self.clock.seconds())
multisig_script = create_output_script(self.multisig_address)
multisig_output = TxOutput(200, multisig_script)
wallet_output = TxOutput(300, create_output_script(self.address))
outside_output = TxOutput(block_reward - 200 - 300, create_output_script(self.outside_address))
tx.outputs = [multisig_output, wallet_output, outside_output]
tx_input = TxInput(tx1.hash, 0, b'')
tx.inputs = [tx_input]
signatures = []
for private_key_hex in self.private_keys:
signature = generate_signature(tx, bytes.fromhex(private_key_hex), password=b'1234')
signatures.append(signature)
parser = create_parser()
# Generate spend tx
args = parser.parse_args([
tx.get_struct().hex(), '{},{}'.format(signatures[0].hex(), signatures[1].hex()),
self.redeem_script.hex()
])
f = StringIO()
with capture_logs():
with redirect_stdout(f):
execute(args)
# Transforming prints str in array
output = f.getvalue().strip().splitlines()
tx_raw = output[0].split(':')[1].strip()
tx = Transaction.create_from_struct(bytes.fromhex(tx_raw))
self.assertTrue(self.manager.propagate_tx(tx, False))
def test_spend_multisig(self):
# Adding funds to the wallet
blocks = add_new_blocks(self.manager, 2, advance_clock=15)
add_blocks_unlock_reward(self.manager)
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID],
WalletBalance(0, sum(blk.outputs[0].value for blk in blocks)))
first_block_amount = blocks[0].outputs[0].value
# First we send tokens to a multisig address
outputs = [
WalletOutputInfo(address=self.multisig_address,
value=first_block_amount,
timelock=int(self.clock.seconds()) + 15)
]
tx1 = self.manager.wallet.prepare_transaction_compute_inputs(
Transaction, outputs)
tx1.weight = 10
tx1.parents = self.manager.get_new_tx_parents()
tx1.timestamp = int(self.clock.seconds())
tx1.resolve()
self.manager.propagate_tx(tx1)
self.clock.advance(10)
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID],
WalletBalance(0, first_block_amount))
# Then we create a new tx that spends this tokens from multisig wallet
tx = Transaction.create_from_struct(tx1.get_struct())
tx.weight = 10
tx.parents = self.manager.get_new_tx_parents()
tx.timestamp = int(self.clock.seconds())
multisig_script = create_output_script(self.multisig_address)
multisig_output = TxOutput(200, multisig_script)
wallet_output = TxOutput(300, create_output_script(self.address))
outside_output = TxOutput(first_block_amount - 200 - 300,
create_output_script(self.outside_address))
tx.outputs = [multisig_output, wallet_output, outside_output]
tx_input = TxInput(tx1.hash, 0, b'')
tx.inputs = [tx_input]
signatures = []
for private_key_hex in self.private_keys:
signature = generate_signature(tx,
bytes.fromhex(private_key_hex),
password=b'1234')
signatures.append(signature)
input_data = MultiSig.create_input_data(self.redeem_script, signatures)
tx.inputs[0].data = input_data
tx.resolve()
# Transaction is still locked
self.assertFalse(self.manager.propagate_tx(tx))
self.clock.advance(6)
tx.timestamp = int(self.clock.seconds())
tx.resolve()
# First we try to propagate with a P2PKH input
private_key_obj = get_private_key_from_bytes(bytes.fromhex(
self.private_keys[0]),
password=b'1234')
pubkey_obj = private_key_obj.public_key()
public_key_compressed = get_public_key_bytes_compressed(pubkey_obj)
p2pkh_input_data = P2PKH.create_input_data(public_key_compressed,
signatures[0])
tx2 = Transaction.create_from_struct(tx.get_struct())
tx2.inputs[0].data = p2pkh_input_data
tx2.resolve()
self.assertFalse(self.manager.propagate_tx(tx2))
# Now we propagate the correct
self.assertTrue(self.manager.propagate_tx(tx))
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID],
WalletBalance(0, first_block_amount + 300))
# Testing the MultiSig class methods
cls_script = parse_address_script(multisig_script)
self.assertTrue(isinstance(cls_script, MultiSig))
self.assertEqual(cls_script.address, self.multisig_address_b58)
expected_dict = {
'type': 'MultiSig',
'address': self.multisig_address_b58,
'timelock': None
}
self.assertEqual(cls_script.to_human_readable(), expected_dict)
script_eval(tx, tx_input, tx1)
# Script error
with self.assertRaises(ScriptError):
create_output_script(
base58.b58decode('55d14K5jMqsN2uwUEFqiPG5SoD7Vr1BfnH'))