def setUp(self):
super().setUp()
self.network = 'testnet'
self.manager = self.create_peer(self.network,
unlock_wallet=True,
wallet_index=True)
# Unlocking wallet
self.manager.wallet.unlock(b'MYPASS')
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')
self.token_uid = tx.tokens[0]
# Create a tx with the same address, so we can have more tx in the history
output = tx.outputs[0]
script_type_out = parse_address_script(output.script)
self.address = script_type_out.address
# Using token creation address as search address
# Token creation address has change output for the genesis (1B - 0.01 HTR of token deposit)
self.address_bytes = decode_address(self.address)
add_new_blocks(self.manager,
5,
advance_clock=1,
address=self.address_bytes)
def test_token_transfer_authority(self):
wallet = self.manager.wallet
tx = create_tokens(self.manager, self.address_b58)
token_uid = tx.tokens[0]
parents = self.manager.get_new_tx_parents()
script = P2PKH.create_output_script(self.address)
# input with mint and output with melt
_input1 = TxInput(tx.hash, 1, b'')
token_output = TxOutput(TxOutput.TOKEN_MELT_MASK, script, 0b10000001)
tx2 = Transaction(weight=1, inputs=[_input1], outputs=[token_output], parents=parents, tokens=[token_uid],
storage=self.manager.tx_storage, timestamp=int(self.clock.seconds()))
data_to_sign = tx2.get_sighash_all(clear_input_data=True)
public_bytes, signature = wallet.get_input_aux_data(data_to_sign, wallet.get_private_key(self.address_b58))
tx2.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx2.resolve()
with self.assertRaises(InvalidToken):
tx2.verify()
# input with melt and output with mint
_input1 = TxInput(tx.hash, 2, b'')
token_output = TxOutput(TxOutput.TOKEN_MINT_MASK, script, 0b10000001)
tx3 = Transaction(weight=1, inputs=[_input1], outputs=[token_output], parents=parents, tokens=[token_uid],
storage=self.manager.tx_storage, timestamp=int(self.clock.seconds()))
data_to_sign = tx3.get_sighash_all(clear_input_data=True)
public_bytes, signature = wallet.get_input_aux_data(data_to_sign, wallet.get_private_key(self.address_b58))
tx3.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx3.resolve()
with self.assertRaises(InvalidToken):
tx3.verify()
def test_token_info_serialization(self):
tx = create_tokens(self.manager, self.address_b58, mint_amount=500)
info = tx.serialize_token_info()
# try with version 2
info2 = bytes([0x02]) + info[1:]
with self.assertRaises(ValueError):
TokenCreationTransaction.deserialize_token_info(info2)
def test_voided_token_creation(self):
tx1 = create_tokens(self.manager,
self.address_b58,
mint_amount=500,
use_genesis=False)
token_uid = tx1.tokens[0]
# check tokens index
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
token_uid)
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
# add simple tx that will void the token created above
tx2 = add_new_double_spending(self.manager,
tx=tx1,
weight=(tx1.weight + 3),
use_same_parents=True)
self.assertFalse(bool(tx2.get_metadata().voided_by))
self.assertTrue(bool(tx1.get_metadata().voided_by))
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertEqual(0, len(mint))
self.assertEqual(0, len(melt))
with self.assertRaises(KeyError):
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
token_uid)
print(tokens_index)
def test_unknown_authority(self):
wallet = self.manager.wallet
tx = create_tokens(self.manager, self.address_b58, mint_amount=500)
token_uid = tx.tokens[0]
parents = self.manager.get_new_tx_parents()
script = P2PKH.create_output_script(self.address)
# try an unknown authority
input1 = TxInput(tx.hash, 1, b'')
input2 = TxInput(tx.hash, 2, b'')
output = TxOutput((TxOutput.ALL_AUTHORITIES << 1), script, 0b10000001)
tx2 = Transaction(weight=1,
inputs=[input1, input2],
outputs=[output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx2.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx2.inputs[0].data = data
tx2.inputs[1].data = data
tx2.resolve()
with self.assertRaises(InvalidToken):
tx2.verify()
def test_token_transfer(self):
wallet = self.manager.wallet
tx = create_tokens(self.manager, self.address_b58)
token_uid = tx.tokens[0]
utxo = tx.outputs[0]
parents = self.manager.get_new_tx_parents()
_input1 = TxInput(tx.hash, 0, b'')
script = P2PKH.create_output_script(self.address)
# regular transfer
token_output = TxOutput(utxo.value, script, 1)
tx2 = Transaction(weight=1, inputs=[_input1], outputs=[token_output], parents=parents, tokens=[token_uid],
storage=self.manager.tx_storage, timestamp=int(self.clock.seconds()))
data_to_sign = tx2.get_sighash_all(clear_input_data=True)
public_bytes, signature = wallet.get_input_aux_data(data_to_sign, wallet.get_private_key(self.address_b58))
tx2.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx2.resolve()
tx2.verify()
# missing tokens
token_output = TxOutput(utxo.value - 1, script, 1)
tx3 = Transaction(weight=1, inputs=[_input1], outputs=[token_output], parents=parents, tokens=[token_uid],
storage=self.manager.tx_storage, timestamp=int(self.clock.seconds()))
data_to_sign = tx3.get_sighash_all(clear_input_data=True)
public_bytes, signature = wallet.get_input_aux_data(data_to_sign, wallet.get_private_key(self.address_b58))
tx3.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx3.resolve()
with self.assertRaises(InputOutputMismatch):
tx3.verify()
def test_token(self):
resource = StubSite(TokenResource(self.manager))
# test invalid token id
response = yield resource.get('thin_wallet/token',
{b'id': 'vvvv'.encode()})
data = response.json_value()
self.assertFalse(data['success'])
# test missing token id
response = yield resource.get('thin_wallet/token')
data = response.json_value()
self.assertFalse(data['success'])
# test unknown token id
unknown_uid = '00000000228ed1dd74a2e1b920c1d64bf81dc63875dce4fac486001073b45a27'.encode(
)
response = yield resource.get('thin_wallet/token',
{b'id': unknown_uid})
data = response.json_value()
self.assertFalse(data['success'])
# test success case
add_new_blocks(self.manager, 1, advance_clock=1)
add_blocks_unlock_reward(self.manager)
token_name = 'MyTestToken'
token_symbol = 'MTT'
amount = 150
tx = create_tokens(self.manager,
mint_amount=amount,
token_name=token_name,
token_symbol=token_symbol)
token_uid = tx.tokens[0]
response = yield resource.get('thin_wallet/token',
{b'id': token_uid.hex().encode()})
data = response.json_value()
self.assertTrue(data['success'])
self.assertEqual(len(data['mint']), 1)
self.assertEqual(len(data['melt']), 1)
self.assertEqual(data['mint'][0]['tx_id'], tx.hash_hex)
self.assertEqual(data['melt'][0]['tx_id'], tx.hash_hex)
self.assertEqual(data['mint'][0]['index'], 1)
self.assertEqual(data['melt'][0]['index'], 2)
self.assertEqual(data['total'], amount)
self.assertEqual(data['name'], token_name)
self.assertEqual(data['symbol'], token_symbol)
# test no wallet index
manager2 = self.create_peer(self.network, unlock_wallet=True)
resource2 = StubSite(TokenResource(manager2))
response2 = yield resource2.get('thin_wallet/token')
data2 = response2.json_value()
self.assertEqual(response2.responseCode, 503)
self.assertFalse(data2['success'])
def test_push_nft(self) -> Generator:
self.manager.wallet.unlock(b'MYPASS')
blocks = add_new_blocks(self.manager, 5, advance_clock=15)
add_blocks_unlock_reward(self.manager)
# NFT creation tx
script_type_out = parse_address_script(blocks[0].outputs[0].script)
assert script_type_out is not None
address = script_type_out.address
tx3 = create_tokens(self.manager,
address,
mint_amount=100,
propagate=False,
nft_data='test')
tx3_hex = tx3.get_struct().hex()
response = yield self.push_tx({'hex_tx': tx3_hex})
data = response.json_value()
self.assertTrue(data['success'])
def test_create_token_transaction(self):
add_new_block(self.manager, advance_clock=5)
add_blocks_unlock_reward(self.manager)
tx = create_tokens(self.manager)
tokens_created = tx.outputs[0].value
token_uid = tx.tokens[0]
address_b58 = self.manager.wallet.get_unused_address()
address = decode_address(address_b58)
_, hathor_balance = self.manager.wallet.balance[
settings.HATHOR_TOKEN_UID]
# prepare tx with hathors and another token
# hathor tx
hathor_out = WalletOutputInfo(address, hathor_balance, None)
# token tx
token_out = WalletOutputInfo(address, tokens_created - 20, None,
token_uid.hex())
tx2 = self.manager.wallet.prepare_transaction_compute_inputs(
Transaction, [hathor_out, token_out])
tx2.storage = self.manager.tx_storage
tx2.timestamp = tx.timestamp + 1
tx2.parents = self.manager.get_new_tx_parents()
tx2.resolve()
tx2.verify()
self.assertNotEqual(len(tx2.inputs), 0)
token_dict = defaultdict(int)
for _input in tx2.inputs:
output_tx = self.manager.tx_storage.get_transaction(_input.tx_id)
output = output_tx.outputs[_input.index]
token_uid = output_tx.get_token_uid(output.get_token_index())
token_dict[token_uid] += output.value
# make sure balance is the same and we've checked both balances
did_enter = 0
for token_uid, value in token_dict.items():
if token_uid == settings.HATHOR_TOKEN_UID:
self.assertEqual(value, hathor_balance)
did_enter += 1
elif token_uid == token_uid:
self.assertEqual(value, tokens_created)
did_enter += 1
self.assertEqual(did_enter, 2)
def test_tokens_balance(self):
# create tokens and check balances
# initial tokens
address_b58 = self.manager.wallet.get_unused_address()
address = decode_address(address_b58)
tx = create_tokens(self.manager, address_b58)
token_id = tx.tokens[0]
amount = tx.outputs[0].value
# initial token balance
self.assertEqual(self.manager.wallet.balance[token_id],
WalletBalance(0, amount))
# initial hathor balance
# we don't consider HTR balance 0 because we transfer genesis tokens to this
# wallet during token creation
hathor_balance = self.manager.wallet.balance[settings.HATHOR_TOKEN_UID]
# transfer token to another wallet and check balance again
parents = self.manager.get_new_tx_parents()
_input1 = TxInput(tx.hash, 0, b'')
script = P2PKH.create_output_script(address)
token_output1 = TxOutput(30, b'', 0b00000001)
token_output2 = TxOutput(amount - 30, script, 0b00000001)
tx2 = Transaction(weight=1,
inputs=[_input1],
outputs=[token_output1, token_output2],
parents=parents,
tokens=[token_id],
storage=self.manager.tx_storage,
timestamp=int(self.manager.reactor.seconds()))
data_to_sign = tx2.get_sighash_all(clear_input_data=True)
public_bytes, signature = self.manager.wallet.get_input_aux_data(
data_to_sign, self.manager.wallet.get_private_key(address_b58))
tx2.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx2.resolve()
tx2.verify()
self.manager.propagate_tx(tx2)
self.run_to_completion()
# verify balance
self.assertEqual(self.manager.wallet.balance[token_id],
WalletBalance(0, amount - 30))
# hathor balance remains the same
self.assertEqual(
self.manager.wallet.balance[settings.HATHOR_TOKEN_UID],
hathor_balance)
def test_get(self):
genesis = list(self.manager.tx_storage.get_all_genesis())
genesis.sort(key=lambda x: x.timestamp)
self.assertTrue(genesis[0].is_block)
for tx in genesis[1:]:
self.assertTrue(tx.is_transaction)
genesis_tx = genesis[1]
response_success = yield self.web.get(
"decode_tx",
{b'hex_tx': bytes(genesis_tx.get_struct().hex(), 'utf-8')})
data_success = response_success.json_value()
self.assertTrue(data_success['success'])
data_genesis = genesis_tx.to_json(decode_script=True)
data_genesis['raw'] = genesis_tx.get_struct().hex()
data_genesis['nonce'] = str(data_genesis['nonce'])
self.assertEqual(data_success['tx'], data_genesis)
self.assertTrue('meta' in data_success)
self.assertTrue('spent_outputs' in data_success)
# Invalid hex
response_error1 = yield self.web.get("decode_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("decode_tx", {b'hex_tx': b'a12c'})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Token creation tx
script_type_out = parse_address_script(genesis[0].outputs[0].script)
address = script_type_out.address
add_blocks_unlock_reward(self.manager)
tx2 = create_tokens(self.manager,
address,
mint_amount=100,
propagate=True)
response = yield self.web.get(
'decode_tx', {b'hex_tx': bytes(tx2.get_struct().hex(), 'utf-8')})
data = response.json_value()
self.assertTrue(data['success'])
def test_save_token_creation_tx(self):
tx = create_tokens(self.manager, propagate=False)
tx.get_metadata().validation = ValidationState.FULL
self.validate_save(tx)
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 _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_save_token_creation_tx(self):
tx = create_tokens(self.manager, propagate=False)
self.validate_save(tx)
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 test_token_mint_zero(self):
# try to mint 0 tokens
with self.assertRaises(InvalidToken):
create_tokens(self.manager, self.address_b58, mint_amount=0)
def test_token(self):
self.manager.wallet.unlock(b'MYPASS')
resource = StubSite(TokenResource(self.manager))
# test list of tokens empty
response_list1 = yield resource.get('thin_wallet/token')
data_list1 = response_list1.json_value()
self.assertTrue(data_list1['success'])
self.assertEqual(len(data_list1['tokens']), 0)
# test invalid token id
response = yield resource.get('thin_wallet/token',
{b'id': 'vvvv'.encode()})
data = response.json_value()
self.assertFalse(data['success'])
# test unknown token id
unknown_uid = '00000000228ed1dd74a2e1b920c1d64bf81dc63875dce4fac486001073b45a27'.encode(
)
response = yield resource.get('thin_wallet/token',
{b'id': unknown_uid})
data = response.json_value()
self.assertFalse(data['success'])
# test success case
add_new_blocks(self.manager, 1, advance_clock=1)
add_blocks_unlock_reward(self.manager)
token_name = 'MyTestToken'
token_symbol = 'MTT'
amount = 150
tx = create_tokens(self.manager,
mint_amount=amount,
token_name=token_name,
token_symbol=token_symbol,
use_genesis=False)
token_uid = tx.tokens[0]
response = yield resource.get('thin_wallet/token',
{b'id': token_uid.hex().encode()})
data = response.json_value()
self.assertTrue(data['success'])
self.assertEqual(len(data['mint']), 1)
self.assertEqual(len(data['melt']), 1)
self.assertEqual(data['mint'][0]['tx_id'], tx.hash_hex)
self.assertEqual(data['melt'][0]['tx_id'], tx.hash_hex)
self.assertEqual(data['mint'][0]['index'], 1)
self.assertEqual(data['melt'][0]['index'], 2)
self.assertEqual(data['total'], amount)
self.assertEqual(data['name'], token_name)
self.assertEqual(data['symbol'], token_symbol)
# test list of tokens with one token
response_list2 = yield resource.get('thin_wallet/token')
data_list2 = response_list2.json_value()
self.assertTrue(data_list2['success'])
self.assertEqual(len(data_list2['tokens']), 1)
self.assertEqual(data_list2['tokens'][0]['name'], token_name)
self.assertEqual(data_list2['tokens'][0]['symbol'], token_symbol)
self.assertEqual(data_list2['tokens'][0]['uid'], tx.hash.hex())
token_name2 = 'New Token'
token_symbol2 = 'NTK'
tx2 = create_tokens(self.manager,
mint_amount=amount,
token_name=token_name2,
token_symbol=token_symbol2,
use_genesis=False)
token_name3 = 'Wat Coin'
token_symbol3 = 'WTC'
tx3 = create_tokens(self.manager,
mint_amount=amount,
token_name=token_name3,
token_symbol=token_symbol3,
use_genesis=False)
# test list of tokens with 3 tokens
response_list3 = yield resource.get('thin_wallet/token')
data_list3 = response_list3.json_value()
self.assertTrue(data_list3['success'])
self.assertEqual(len(data_list3['tokens']), 3)
token1 = {
'uid': tx.hash.hex(),
'name': token_name,
'symbol': token_symbol
}
token2 = {
'uid': tx2.hash.hex(),
'name': token_name2,
'symbol': token_symbol2
}
token3 = {
'uid': tx3.hash.hex(),
'name': token_name3,
'symbol': token_symbol3
}
self.assertIn(token1, data_list3['tokens'])
self.assertIn(token2, data_list3['tokens'])
self.assertIn(token3, data_list3['tokens'])
# test no wallet index
manager2 = self.create_peer(self.network, unlock_wallet=True)
resource2 = StubSite(TokenResource(manager2))
response2 = yield resource2.get('thin_wallet/token')
data2 = response2.json_value()
self.assertEqual(response2.responseCode, 503)
self.assertFalse(data2['success'])
def test_token_mint(self):
wallet = self.manager.wallet
tx = create_tokens(self.manager, self.address_b58, mint_amount=500)
token_uid = tx.tokens[0]
parents = self.manager.get_new_tx_parents()
script = P2PKH.create_output_script(self.address)
# mint tokens and transfer mint authority
mint_amount = 10000000
deposit_amount = get_deposit_amount(mint_amount)
_input1 = TxInput(tx.hash, 1, b'')
_input2 = TxInput(tx.hash, 3, b'')
token_output1 = TxOutput(mint_amount, script, 1)
token_output2 = TxOutput(TxOutput.TOKEN_MINT_MASK, script, 0b10000001)
deposit_output = TxOutput(tx.outputs[3].value - deposit_amount, script,
0)
tx2 = Transaction(
weight=1,
inputs=[_input1, _input2],
outputs=[token_output1, token_output2, deposit_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx2.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx2.inputs[0].data = data
tx2.inputs[1].data = data
tx2.resolve()
tx2.verify()
self.manager.propagate_tx(tx2)
self.run_to_completion()
# check tokens index
tokens_index = self.manager.tx_storage.tokens_index.tokens[token_uid]
self.assertIn((tx2.hash, 1), tokens_index.mint)
self.assertIn((tx.hash, 2), tokens_index.melt)
# there should only be one element on the indexes for the token
self.assertEqual(1, len(tokens_index.mint))
self.assertEqual(1, len(tokens_index.melt))
# check total amount of tokens
self.assertEqual(500 + mint_amount, tokens_index.total)
# try to mint 1 token unit without deposit
mint_amount = 1
_input1 = TxInput(tx.hash, 1, b'')
token_output1 = TxOutput(mint_amount, script, 1)
token_output2 = TxOutput(TxOutput.TOKEN_MINT_MASK, script, 0b10000001)
tx3 = Transaction(weight=1,
inputs=[_input1],
outputs=[token_output1, token_output2],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx3.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx3.inputs[0].data = data
tx3.resolve()
with self.assertRaises(InputOutputMismatch):
tx3.verify()
# try to mint and deposit less tokens than necessary
mint_amount = 10000000
deposit_amount = get_deposit_amount(mint_amount) - 1
_input1 = TxInput(tx.hash, 1, b'')
_input2 = TxInput(tx.hash, 3, b'')
token_output1 = TxOutput(mint_amount, script, 1)
token_output2 = TxOutput(TxOutput.TOKEN_MINT_MASK, script, 0b10000001)
deposit_output = TxOutput(tx.outputs[3].value - deposit_amount, script,
0)
tx4 = Transaction(
weight=1,
inputs=[_input1, _input2],
outputs=[token_output1, token_output2, deposit_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx4.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx4.inputs[0].data = data
tx4.inputs[1].data = data
tx4.resolve()
with self.assertRaises(InputOutputMismatch):
tx4.verify()
# try to mint using melt authority UTXO
_input1 = TxInput(tx.hash, 2, b'')
token_output = TxOutput(10000000, script, 1)
tx5 = Transaction(weight=1,
inputs=[_input1],
outputs=[token_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx5.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
tx5.inputs[0].data = P2PKH.create_input_data(public_bytes, signature)
tx5.resolve()
with self.assertRaises(InputOutputMismatch):
tx5.verify()
def test_token_melt(self):
wallet = self.manager.wallet
tx = create_tokens(self.manager, self.address_b58)
token_uid = tx.tokens[0]
parents = self.manager.get_new_tx_parents()
script = P2PKH.create_output_script(self.address)
# melt tokens and transfer melt authority
melt_amount = 100
new_amount = tx.outputs[0].value - melt_amount
withdraw_amount = get_withdraw_amount(melt_amount)
_input1 = TxInput(tx.hash, 0, b'')
_input2 = TxInput(tx.hash, 2, b'')
token_output1 = TxOutput(new_amount, script, 1)
token_output2 = TxOutput(TxOutput.TOKEN_MELT_MASK, script, 0b10000001)
withdraw_output = TxOutput(withdraw_amount, script, 0)
tx2 = Transaction(
weight=1,
inputs=[_input1, _input2],
outputs=[token_output1, token_output2, withdraw_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx2.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx2.inputs[0].data = data
tx2.inputs[1].data = data
tx2.resolve()
tx2.verify()
self.manager.propagate_tx(tx2)
self.run_to_completion()
# check tokens index
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
token_uid)
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertIn(TokenUtxoInfo(tx.hash, 1), mint)
self.assertIn(TokenUtxoInfo(tx2.hash, 1), melt)
# there should only be one element on the indexes for the token
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
# check total amount of tokens
self.assertEqual(new_amount, tokens_index.get_total())
# melt tokens and withdraw more than what's allowed
melt_amount = 100
withdraw_amount = get_withdraw_amount(melt_amount)
_input1 = TxInput(tx.hash, 0, b'')
_input2 = TxInput(tx.hash, 2, b'')
token_output1 = TxOutput(tx.outputs[0].value - melt_amount, script, 1)
token_output2 = TxOutput(TxOutput.TOKEN_MELT_MASK, script, 0b10000001)
withdraw_output = TxOutput(withdraw_amount + 1, script, 0)
tx3 = Transaction(
weight=1,
inputs=[_input1, _input2],
outputs=[token_output1, token_output2, withdraw_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx3.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx3.inputs[0].data = data
tx3.inputs[1].data = data
tx3.resolve()
with self.assertRaises(InputOutputMismatch):
tx3.verify()
# try to melt using mint authority UTXO
_input1 = TxInput(tx.hash, 0, b'')
_input2 = TxInput(tx.hash, 1, b'')
token_output = TxOutput(tx.outputs[0].value - 1, script, 1)
tx4 = Transaction(weight=1,
inputs=[_input1, _input2],
outputs=[token_output],
parents=parents,
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
data_to_sign = tx4.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx4.inputs[0].data = data
tx4.inputs[1].data = data
tx4.resolve()
with self.assertRaises(InputOutputMismatch):
tx4.verify()
def test_token_index_with_conflict(self, mint_amount=0):
# create a new token and have a mint operation done. The tx that mints the
# tokens has the following outputs:
# 0. minted tokens
# 1. mint authority;
# 2. melt authority
# 3. HTR deposit change
tx = create_tokens(self.manager, self.address_b58, mint_amount=100)
token_uid = tx.tokens[0]
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
tx.tokens[0])
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertIn(TokenUtxoInfo(tx.hash, 1), mint)
self.assertIn(TokenUtxoInfo(tx.hash, 2), melt)
# there should only be one element on the indexes for the token
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
# check total amount of tokens
self.assertEqual(100, tokens_index.get_total())
# new tx minting tokens
mint_amount = 300
deposit_amount = get_deposit_amount(mint_amount)
script = P2PKH.create_output_script(self.address)
# inputs
mint_input = TxInput(tx.hash, 1, b'')
melt_input = TxInput(tx.hash, 2, b'')
deposit_input = TxInput(tx.hash, 3, b'')
# outputs
mint_output = TxOutput(mint_amount, script, 1)
authority_output1 = TxOutput(TxOutput.TOKEN_MINT_MASK, script,
0b10000001)
authority_output2 = TxOutput(TxOutput.TOKEN_MELT_MASK, script,
0b10000001)
deposit_output = TxOutput(tx.outputs[3].value - deposit_amount, script,
0)
tx2 = Transaction(weight=1,
inputs=[mint_input, melt_input, deposit_input],
outputs=[
authority_output1, authority_output2,
mint_output, deposit_output
],
parents=self.manager.get_new_tx_parents(),
tokens=[token_uid],
storage=self.manager.tx_storage,
timestamp=int(self.clock.seconds()))
# sign inputs
wallet = self.manager.wallet
data_to_sign = tx2.get_sighash_all()
public_bytes, signature = wallet.get_input_aux_data(
data_to_sign, wallet.get_private_key(self.address_b58))
data = P2PKH.create_input_data(public_bytes, signature)
tx2.inputs[0].data = data
tx2.inputs[1].data = data
tx2.inputs[2].data = data
tx2.resolve()
tx2.verify()
self.manager.propagate_tx(tx2)
self.run_to_completion()
# there should only be one element on the indexes for the token
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
tx.tokens[0])
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
self.assertIn(TokenUtxoInfo(tx2.hash, 0), mint)
self.assertIn(TokenUtxoInfo(tx2.hash, 1), melt)
# check total amount of tokens has been updated
self.assertEqual(400, tokens_index.get_total())
# create conflicting tx by changing parents
tx3 = Transaction.create_from_struct(tx2.get_struct())
tx3.parents = [tx.parents[1], tx.parents[0]]
tx3.weight = 3
tx3.resolve()
self.assertNotEqual(tx3.hash, tx2.hash)
self.assertTrue(tx3.weight > tx2.weight)
self.manager.propagate_tx(tx3)
self.run_to_completion()
# new tx should be on tokens index. Old tx should not be present
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
tx.tokens[0])
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertIn(TokenUtxoInfo(tx3.hash, 0), mint)
self.assertIn(TokenUtxoInfo(tx3.hash, 1), melt)
# there should only be one element on the indexes for the token
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
# should have same amount of tokens
self.assertEqual(400, tokens_index.get_total())
def test_token_info(self):
def update_tx(tx):
""" sighash_all data changes with token name or symbol, so we have to compute signature again
"""
data_to_sign = tx.get_sighash_all()
public_bytes, signature = self.manager.wallet.get_input_aux_data(
data_to_sign, self.genesis_private_key)
tx.inputs[0].data = P2PKH.create_input_data(
public_bytes, signature)
tx.resolve()
# test token name and symbol
tx = create_tokens(self.manager, self.address_b58)
# max token name length
tx.token_name = 'a' * settings.MAX_LENGTH_TOKEN_NAME
update_tx(tx)
tx.verify()
# max token symbol length
tx.token_symbol = 'a' * settings.MAX_LENGTH_TOKEN_SYMBOL
update_tx(tx)
tx.verify()
# long token name
tx.token_name = 'a' * (settings.MAX_LENGTH_TOKEN_NAME + 1)
update_tx(tx)
with self.assertRaises(TransactionDataError):
tx.verify()
# long token symbol
tx.token_name = 'ValidName'
tx.token_symbol = 'a' * (settings.MAX_LENGTH_TOKEN_SYMBOL + 1)
update_tx(tx)
with self.assertRaises(TransactionDataError):
tx.verify()
# Hathor token name
tx.token_name = settings.HATHOR_TOKEN_NAME
tx.token_symbol = 'TST'
update_tx(tx)
with self.assertRaises(TransactionDataError):
tx.verify()
# Hathor token symbol
tx.token_name = 'Test'
tx.token_symbol = settings.HATHOR_TOKEN_SYMBOL
update_tx(tx)
with self.assertRaises(TransactionDataError):
tx.verify()
# Token name unicode
tx.token_name = 'Test ∞'
tx.token_symbol = 'TST'
token_info = tx.serialize_token_info()
TokenCreationTransaction.deserialize_token_info(token_info)
update_tx(tx)
tx.verify()
# Token symbol unicode
tx.token_name = 'Test Token'
tx.token_symbol = 'TST∞'
token_info = tx.serialize_token_info()
TokenCreationTransaction.deserialize_token_info(token_info)
update_tx(tx)
tx.verify()
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']))
def test_push_tx(self) -> Generator:
self.manager.wallet.unlock(b'MYPASS')
blocks = add_new_blocks(self.manager, 5, advance_clock=15)
add_blocks_unlock_reward(self.manager)
tx = self.get_tx()
tx_hex = tx.get_struct().hex()
response = yield self.push_tx({'hex_tx': tx_hex})
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()
response_success = yield self.push_tx({'hex_tx': tx_hex})
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()
response = yield self.push_tx({'hex_tx': tx_hex})
data = response.json_value()
self.assertFalse(data['success'])
# force
tx_hex = tx.get_struct().hex()
response = yield self.push_tx({'hex_tx': tx_hex, 'force': 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()
response_genesis = yield self.push_tx({'tx_hex': genesis_hex})
data_genesis = response_genesis.json_value()
self.assertFalse(data_genesis['success'])
# Token creation tx
script_type_out = parse_address_script(blocks[0].outputs[0].script)
assert script_type_out is not None
address = script_type_out.address
tx2 = create_tokens(self.manager,
address,
mint_amount=100,
propagate=False)
tx2_hex = tx2.get_struct().hex()
response = yield self.push_tx({'hex_tx': tx2_hex})
data = response.json_value()
self.assertTrue(data['success'])
def test_token_struct(self):
tx = create_tokens(self.manager, self.address_b58, mint_amount=500)
tx2 = TokenCreationTransaction.create_from_struct(tx.get_struct())
self.assertEqual(tx.hash, tx2.hash)