def test_tx_inputs_out_of_range(self):
# we'll try to spend output 3 from genesis transaction, which does not exist
parents = [tx.hash for tx in self.genesis_txs]
genesis_block = self.genesis_blocks[0]
value = genesis_block.outputs[0].value
address = get_address_from_public_key(self.genesis_public_key)
script = P2PKH.create_output_script(address)
output = TxOutput(value, script)
_input = TxInput(genesis_block.hash,
len(genesis_block.outputs) + 1, b'')
tx = Transaction(weight=1,
inputs=[_input],
outputs=[output],
parents=parents,
storage=self.tx_storage)
data_to_sign = tx.get_sighash_all()
public_bytes, signature = self.wallet.get_input_aux_data(
data_to_sign, self.genesis_private_key)
data = P2PKH.create_input_data(public_bytes, signature)
tx.inputs[0].data = data
# test with an inexistent index
tx.resolve()
with self.assertRaises(InexistentInput):
tx.verify()
# now with index equals of len of outputs
_input = [
TxInput(genesis_block.hash, len(genesis_block.outputs), data)
]
tx.inputs = _input
# test with an inexistent index
tx.resolve()
with self.assertRaises(InexistentInput):
tx.verify()
# now with inexistent tx hash
random_bytes = bytes.fromhex(
'0000184e64683b966b4268f387c269915cc61f6af5329823a93e3696cb0fe902')
_input = [TxInput(random_bytes, 3, data)]
tx.inputs = _input
tx.resolve()
with self.assertRaises(InexistentInput):
tx.verify()
def test_get(self):
# Mining new block
response_mining = yield self.web_mining.get('mining')
data_mining = response_mining.json_value()
block_bytes = resolve_block_bytes(
block_bytes=data_mining['block_bytes'])
yield self.web_mining.post(
'mining',
{'block_bytes': base64.b64encode(block_bytes).decode('utf-8')})
# Unlocking wallet
self.manager.wallet.unlock(b'MYPASS')
# Creating a valid transaction to be pushed to the network
blocks = add_new_blocks(self.manager, 3, advance_clock=2)
add_blocks_unlock_reward(self.manager)
tx_id = blocks[0].hash
output = blocks[0].outputs[0]
script_type_out = parse_address_script(output.script)
address = script_type_out.address
private_key = self.manager.wallet.get_private_key(address)
output_address = decode_address(self.get_address(0))
value = self.manager.get_tokens_issued_per_block(1)
o = TxOutput(value, create_output_script(output_address, None))
i = TxInput(tx_id, 0, b'')
tx = Transaction(inputs=[i], outputs=[o])
data_to_sign = tx.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx.inputs = [i]
tx.timestamp = int(self.clock.seconds())
tx.weight = self.manager.minimum_tx_weight(tx)
tx.parents = self.manager.get_new_tx_parents(tx.timestamp)
tx.resolve()
response = yield self.web.get(
'push_tx', {b'hex_tx': bytes(tx.get_struct().hex(), 'utf-8')})
data = response.json_value()
self.assertTrue(data['success'])
# Sending token to random address without input
data_json = {
'outputs': [{
'address': self.get_address(0),
'value': 5
}],
'inputs': []
}
yield self.web_tokens.post('wallet/send_tokens', {'data': data_json})
# modify tx so it will be a double spending, then rejected
tx.weight += 0.1
tx.resolve()
response_success = yield self.web.get(
'push_tx', {b'hex_tx': bytes(tx.get_struct().hex(), 'utf-8')})
data_success = response_success.json_value()
self.assertFalse(data_success['success'])
# Invalid tx (don't have inputs)
genesis_tx = get_genesis_transactions(self.manager.tx_storage)[1]
response_genesis = yield self.web.get(
'push_tx',
{b'hex_tx': bytes(genesis_tx.get_struct().hex(), 'utf-8')})
data_genesis = response_genesis.json_value()
self.assertFalse(data_genesis['success'])
# Invalid hex
response_error1 = yield self.web.get('push_tx', {b'hex_tx': b'XXXX'})
data_error1 = response_error1.json_value()
self.assertFalse(data_error1['success'])
# Invalid tx hex
response_error2 = yield self.web.get('push_tx', {b'hex_tx': b'a12c'})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Token creation tx
tx2 = create_tokens(self.manager,
address,
mint_amount=100,
propagate=False)
response = yield self.web.get(
'push_tx', {b'hex_tx': bytes(tx2.get_struct().hex(), 'utf-8')})
data = response.json_value()
self.assertTrue(data['success'])
def test_post(self):
# Unlocking wallet
self.manager.wallet.unlock(b'MYPASS')
blocks = add_new_blocks(self.manager, 3, advance_clock=1)
add_blocks_unlock_reward(self.manager)
blocks_tokens = [
sum(txout.value for txout in blk.outputs) for blk in blocks
]
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID].available,
sum(blocks_tokens))
# Options
yield self.web.options('thin_wallet/send_tokens')
tx_id = blocks[0].hash
output = blocks[0].outputs[0]
script_type_out = parse_address_script(output.script)
address = script_type_out.address
private_key = self.manager.wallet.get_private_key(address)
output_address = decode_address(self.get_address(0))
value = blocks_tokens[0]
o = TxOutput(value, create_output_script(output_address, None))
o_invalid_amount = TxOutput(value - 1,
create_output_script(output_address, None))
i = TxInput(tx_id, 0, b'')
# wrong weight
tx = Transaction(inputs=[i], outputs=[o])
data_to_sign = tx.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx.inputs = [i]
tx.timestamp = int(self.clock.seconds())
tx.weight = 0
response = yield self.web.post('thin_wallet/send_tokens',
{'tx_hex': tx.get_struct().hex()})
data = response.json_value()
self.assertFalse(data['success'])
# Error wrong amount
tx2 = Transaction(inputs=[i], outputs=[o_invalid_amount])
data_to_sign = tx2.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx2.inputs = [i]
tx2.timestamp = int(self.clock.seconds())
tx2.weight = self.manager.minimum_tx_weight(tx2)
response_wrong_amount = yield self.web.post(
'thin_wallet/send_tokens', {'tx_hex': tx2.get_struct().hex()})
data_wrong_amount = response_wrong_amount.json_value()
self.assertFalse(data_wrong_amount['success'])
# successful tx
tx3 = Transaction(inputs=[i], outputs=[o])
data_to_sign = tx3.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx3.inputs = [i]
tx3.timestamp = int(self.clock.seconds())
tx3.weight = self.manager.minimum_tx_weight(tx3)
# Then send tokens
response = yield self.web.post('thin_wallet/send_tokens',
{'tx_hex': tx3.get_struct().hex()})
data = response.json_value()
self.assertTrue(data['success'])
# Trying to send a double spending will not have success
self.clock.advance(5)
tx3.timestamp = int(self.clock.seconds())
response = yield self.web.post('thin_wallet/send_tokens',
{'tx_hex': tx3.get_struct().hex()})
data_error = response.json_value()
self.assertFalse(data_error['success'])
self.clock.advance(5)
# Check if tokens were really sent
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID].available,
sum(blocks_tokens[:-1]))
response_history = yield self.web_address_history.get(
'thin_wallet/address_history', {
b'addresses[]': address.encode(),
})
response_data = response_history.json_value()['history']
self.assertIn(data['tx']['hash'], [x['tx_id'] for x in response_data])
# Create token tx
tx4 = create_tokens(self.manager,
address,
mint_amount=100,
propagate=False)
tx4.nonce = 0
tx4.timestamp = int(self.clock.seconds())
response = yield self.web.post('thin_wallet/send_tokens',
{'tx_hex': tx4.get_struct().hex()})
data = response.json_value()
self.assertTrue(data['success'])
def _run_push_tx_test(self, is_post: bool) -> Generator:
# Mining new block
response_mining = yield self.web_mining.get('mining')
data_mining = response_mining.json_value()
block_bytes = resolve_block_bytes(block_bytes=data_mining['block_bytes'])
yield self.web_mining.post('mining', {'block_bytes': base64.b64encode(block_bytes).decode('utf-8')})
# Unlocking wallet
self.manager.wallet.unlock(b'MYPASS')
# Creating a valid transaction to be pushed to the network
blocks = add_new_blocks(self.manager, 3, advance_clock=2)
add_blocks_unlock_reward(self.manager)
tx_id = blocks[0].hash
output = blocks[0].outputs[0]
script_type_out = parse_address_script(output.script)
assert script_type_out is not None
address = script_type_out.address
private_key = self.manager.wallet.get_private_key(address)
script_out_addr = self.get_address(0)
assert script_out_addr is not None
output_address = decode_address(script_out_addr)
value = self.manager.get_tokens_issued_per_block(1)
o = TxOutput(value, create_output_script(output_address, None))
i = TxInput(tx_id, 0, b'')
tx = Transaction(inputs=[i], outputs=[o])
data_to_sign = tx.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx.inputs = [i]
tx.timestamp = int(self.clock.seconds())
tx.weight = self.manager.minimum_tx_weight(tx)
tx.parents = self.manager.get_new_tx_parents(tx.timestamp)
tx.resolve()
push_tx_fn = self.web.post if is_post else self.web.get
hex_param = 'hex_tx' if is_post else b'hex_tx'
force_param = 'force' if is_post else b'force'
tx_hex = tx.get_struct().hex()
hex_data = tx_hex if is_post else bytes(tx_hex, 'utf-8')
response = yield push_tx_fn('push_tx', {hex_param: hex_data})
data = response.json_value()
self.assertTrue(data['success'])
# Sending token to random address without input
data_json = {'outputs': [{'address': self.get_address(0), 'value': 5}], 'inputs': []}
yield self.web_tokens.post('wallet/send_tokens', {'data': data_json})
# modify tx so it will be a double spending, then rejected
tx.weight += 0.1
tx.resolve()
tx_hex = tx.get_struct().hex()
hex_data = tx_hex if is_post else bytes(tx_hex, 'utf-8')
response_success = yield push_tx_fn('push_tx', {hex_param: hex_data})
data_success = response_success.json_value()
self.assertFalse(data_success['success'])
# invalid transaction, without forcing
tx.timestamp = 5
tx.inputs = [TxInput(blocks[1].hash, 0, b'')]
script_type_out = parse_address_script(blocks[1].outputs[0].script)
assert script_type_out is not None
private_key = self.manager.wallet.get_private_key(script_type_out.address)
data_to_sign = tx.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(data_to_sign, private_key)
tx.inputs[0].data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx_hex = tx.get_struct().hex()
hex_data = tx_hex if is_post else bytes(tx_hex, 'utf-8')
response = yield push_tx_fn('push_tx', {hex_param: hex_data})
data = response.json_value()
self.assertFalse(data['success'])
# force
tx_hex = tx.get_struct().hex()
hex_data = tx_hex if is_post else bytes(tx_hex, 'utf-8')
response = yield push_tx_fn('push_tx', {hex_param: hex_data, force_param: True if is_post else b'true'})
data = response.json_value()
self.assertFalse(data['success'])
# Invalid tx (don't have inputs)
genesis_tx = next(x for x in self.manager.tx_storage.get_all_genesis() if x.is_transaction)
genesis_hex = genesis_tx.get_struct().hex()
hex_data = genesis_hex if is_post else bytes(genesis_hex, 'utf-8')
response_genesis = yield push_tx_fn('push_tx', {hex_param: hex_data})
data_genesis = response_genesis.json_value()
self.assertFalse(data_genesis['success'])
# Invalid tx hex
invalid_hex_data = 'a12c' if is_post else b'a12c'
response_error2 = yield push_tx_fn('push_tx', {hex_param: invalid_hex_data})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Token creation tx
tx2 = create_tokens(self.manager, address, mint_amount=100, propagate=False)
tx2_hex = tx2.get_struct().hex()
hex_data = tx2_hex if is_post else bytes(tx2_hex, 'utf-8')
response = yield push_tx_fn('push_tx', {hex_param: hex_data})
data = response.json_value()
self.assertTrue(data['success'])
def test_token_history(self):
self.manager.wallet.unlock(b'MYPASS')
resource = StubSite(TokenHistoryResource(self.manager))
add_new_blocks(self.manager, 1, advance_clock=1)
add_blocks_unlock_reward(self.manager)
tx = create_tokens(self.manager,
mint_amount=100,
token_name='Teste',
token_symbol='TST')
token_uid = tx.tokens[0]
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 3
})
data = response.json_value()
# Success returning the token creation tx
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get('thin_wallet/token_history', {
b'id': b'123',
b'count': 3
})
data = response.json_value()
# Fail because token is unknown
self.assertFalse(data['success'])
# Create a tx with this token, so we can have more tx in the history
output = tx.outputs[0]
script_type_out = parse_address_script(output.script)
address = script_type_out.address
private_key = self.manager.wallet.get_private_key(address)
output_address = decode_address(self.get_address(0))
o = TxOutput(100, create_output_script(output_address, None), 1)
i = TxInput(tx.hash, 0, b'')
tx2 = Transaction(inputs=[i], outputs=[o], tokens=[token_uid])
data_to_sign = tx2.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx2.inputs = [i]
tx2.timestamp = int(self.clock.seconds())
tx2.weight = self.manager.minimum_tx_weight(tx2)
tx2.parents = self.manager.get_new_tx_parents()
tx2.resolve()
self.manager.propagate_tx(tx2)
# Now we have 2 txs with this token
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 3
})
data = response.json_value()
# Success returning the token creation tx and newly created tx
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(2, len(data['transactions']))
self.assertEqual(tx2.hash.hex(), data['transactions'][0]['tx_id'])
self.assertEqual(tx.hash.hex(), data['transactions'][1]['tx_id'])
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 1
})
data = response.json_value()
# Testing has_more
self.assertTrue(data['success'])
self.assertTrue(data['has_more'])
self.assertEqual(1, len(data['transactions']))
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'next',
b'hash': tx2.hash.hex().encode(),
b'timestamp': str(tx2.timestamp).encode(),
})
data = response.json_value()
# Testing next
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'previous',
b'hash': tx.hash.hex().encode(),
b'timestamp': str(tx.timestamp).encode(),
})
data = response.json_value()
# Testing previous
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx2.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'previous',
b'hash': tx2.hash.hex().encode(),
b'timestamp': str(tx2.timestamp).encode(),
})
data = response.json_value()
# Testing previous from first
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(0, len(data['transactions']))
