def setUp(self):
super().setUp()
self.web = StubSite(PushTxResource(self.manager))
self.web_tokens = StubSite(SendTokensResource(self.manager))
self.web_mining = StubSite(MiningResource(self.manager))
self.web_balance = StubSite(BalanceResource(self.manager))
self.web_history = StubSite(HistoryResource(self.manager))
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 setUp(self):
super().setUp()
self.network = 'testnet'
self.manager = self.create_peer(self.network,
unlock_wallet=True,
wallet_index=True)
sendtokens_resource = SendTokensResource(self.manager)
sendtokens_resource.sleep_seconds = 0.1
self.web = StubSite(sendtokens_resource)
self.web_address_history = StubSite(
AddressHistoryResource(self.manager))
def test_address_balance(self):
resource = StubSite(AddressBalanceResource(self.manager))
# Invalid address
response_error = yield resource.get('thin_wallet/address_search', {
b'address': 'vvvv'.encode(),
b'count': 3
})
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
response = yield resource.get('thin_wallet/address_balance',
{b'address': self.address.encode()})
data = response.json_value()
self.assertTrue(data['success'])
# Genesis - token deposit + blocks mined
HTR_value = settings.GENESIS_TOKENS - 1 + (
settings.INITIAL_TOKENS_PER_BLOCK * 5)
self.assertEqual(data['total_transactions'],
6) # 5 blocks mined + token creation tx
self.assertIn(settings.HATHOR_TOKEN_UID.hex(), data['tokens_data'])
self.assertIn(self.token_uid.hex(), data['tokens_data'])
self.assertEqual(
HTR_value,
data['tokens_data'][settings.HATHOR_TOKEN_UID.hex()]['received'])
self.assertEqual(
0, data['tokens_data'][settings.HATHOR_TOKEN_UID.hex()]['spent'])
self.assertEqual(100,
data['tokens_data'][self.token_uid.hex()]['received'])
self.assertEqual(0, data['tokens_data'][self.token_uid.hex()]['spent'])
def test_search(self):
resource = StubSite(AddressSearchResource(self.manager))
# Invalid address
response_error = yield resource.get('thin_wallet/address_search', {
b'address': 'vvvv'.encode(),
b'count': 3
})
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
# Get address search first page success
response = yield resource.get('thin_wallet/address_search', {
b'address': self.address.encode(),
b'count': 3
})
data = response.json_value()
self.assertTrue(data['success'])
self.assertEqual(len(data['transactions']), 3)
self.assertTrue(data['has_more'])
# Getting next page
response2 = yield resource.get(
'thin_wallet/address_search', {
b'address': self.address.encode(),
b'count': 3,
b'page': b'next',
b'hash': data['transactions'][-1]['tx_id'].encode()
})
data2 = response2.json_value()
self.assertTrue(data2['success'])
self.assertEqual(len(data2['transactions']), 3)
self.assertFalse(data2['has_more'])
# Testing that no tx in data is also in data2
tx_ids_data = [tx['tx_id'] for tx in data['transactions']]
for tx in data2['transactions']:
self.assertNotIn(tx['tx_id'], tx_ids_data)
# Getting previous page from third element
response3 = yield resource.get(
'thin_wallet/address_search', {
b'address': self.address.encode(),
b'count': 3,
b'page': b'previous',
b'hash': data['transactions'][-1]['tx_id'].encode()
})
data3 = response3.json_value()
self.assertTrue(data3['success'])
self.assertEqual(len(data3['transactions']), 2)
self.assertFalse(data3['has_more'])
# Testing that no tx in data3 is also in data2
tx_ids_data = [tx['tx_id'] for tx in data3['transactions']]
for tx in data2['transactions']:
self.assertNotIn(tx['tx_id'], tx_ids_data)
def setUp(self):
super().setUp()
self.web = StubSite(CreateTxResource(self.manager))
self.manager.wallet.unlock(b'MYPASS')
self.spent_blocks = add_new_blocks(self.manager, 10)
self.unspent_blocks = add_blocks_unlock_reward(self.manager)
add_blocks_unlock_reward(self.manager)
self.unspent_address = self.manager.wallet.get_unused_address()
self.unspent_tx = add_new_tx(self.manager, self.unspent_address, 100)
self.unspent_tx2 = add_new_tx(self.manager, self.unspent_address, 200)
self.unspent_tx3 = add_new_tx(self.manager, self.unspent_address, 300)
add_blocks_unlock_reward(self.manager)
def setUp(self):
super().setUp()
self.network = 'testnet'
self.manager = self.create_peer(self.network, wallet_index=True)
self.factory = HathorAdminWebsocketFactory(self.manager.metrics)
self.factory.subscribe(self.manager.pubsub)
self.factory._setup_rate_limit()
self.factory.openHandshakeTimeout = 0
self.protocol = self.factory.buildProtocol(None)
self.transport = proto_helpers.StringTransport()
self.protocol.makeConnection(self.transport)
self.web = StubSite(WebsocketStatsResource(self.factory))
def setUp(self):
super().setUp()
self.resource = self.create_resource()
self.web = StubSite(self.resource)
# Unlocking wallet
self.manager.wallet.unlock(b'MYPASS')
# Creating blocks, txs and a conflict tx to test graphviz with it
add_new_blocks(self.manager, 2, advance_clock=2)
add_blocks_unlock_reward(self.manager)
txs = add_new_transactions(self.manager, 2, advance_clock=2)
tx = txs[0]
self.tx2 = Transaction.create_from_struct(tx.get_struct())
self.tx2.parents = [tx.parents[1], tx.parents[0]]
self.tx2.resolve()
self.manager.propagate_tx(self.tx2)
def setUp(self):
super().setUp()
self.network = 'testnet'
self.manager = self.create_peer(self.network, wallet_index=True)
self.factory = HathorAdminWebsocketFactory(self.manager.metrics)
self.factory.subscribe(self.manager.pubsub)
self.factory._setup_rate_limit()
self.factory.openHandshakeTimeout = 0
self.protocol = self.factory.buildProtocol(None)
self.transport = proto_helpers.StringTransport()
self.protocol.makeConnection(self.transport)
self.genesis = list(self.manager.tx_storage.get_all_genesis())
self.genesis.sort(key=lambda x: x.timestamp)
self.assertTrue(self.genesis[0].is_block)
for tx in self.genesis[1:]:
self.assertTrue(tx.is_transaction)
self.web = StubSite(WebsocketStatsResource(self.factory))
def setUp(self):
super().setUp()
self.web = StubSite(TransactionResource(self.manager))
self.manager.wallet.unlock(b'MYPASS')
def setUp(self):
super().setUp()
self.web = StubSite(MiningInfoResource(self.manager))
self.manager.wallet.unlock(b'MYPASS')
def test_match_values(self):
decode_resource = StubSite(NanoContractDecodeResource(self.manager))
execute_resource = StubSite(NanoContractExecuteResource(self.manager))
match_value_resource = StubSite(
NanoContractMatchValueResource(self.manager))
pushtx_resource = StubSite(
PushTxResource(self.manager, allow_non_standard_script=True))
signtx_resource = StubSite(SignTxResource(self.manager))
decodetx_resource = StubSite(DecodeTxResource(self.manager))
add_new_blocks(self.manager, 3)
add_blocks_unlock_reward(self.manager)
self.reactor.advance(3)
# Options
yield match_value_resource.options(
"wallet/nano_contracts/match_values")
total_value = self.manager.get_tokens_issued_per_block(1)
address1 = self.get_address(0)
data_post = {
'oracle_data_id': 'some_id',
'total_value': total_value,
'input_value': total_value,
'min_timestamp': 1,
'fallback_address': self.get_address(1),
'values': [{
'address': address1,
'value': 300
}]
}
# Error missing parameter
response_error = yield match_value_resource.post(
"wallet/nano_contracts/match_value", data_post)
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
self.assertEqual(data_error['message'],
'Missing parameter: oracle_pubkey_hash')
# create nano contract
data_post['oracle_pubkey_hash'] = '6o6ul2c+sqAariBVW+CwNaSJb9w='
response = yield match_value_resource.post(
"wallet/nano_contracts/match_value", data_post)
data = response.json_value()
self.assertTrue(data['success'])
self.assertIsNotNone(data['hex_tx'])
nano_contract_hex = data['hex_tx']
# Error missing parameter
response_error = yield decode_resource.get(
"wallet/nano_contracts/decode", {})
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
self.assertEqual(data_error['message'], 'Missing parameter: hex_tx')
# Error invalid hex
response_error2 = yield decode_resource.get(
"wallet/nano_contracts/decode", {b'hex_tx': b'123'})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Error valid hex but invalid tx struct
response_error3 = yield decode_resource.get(
"wallet/nano_contracts/decode", {b'hex_tx': b'1334'})
data_error3 = response_error3.json_value()
self.assertFalse(data_error3['success'])
# decode
genesis_output = [
tx for tx in self.manager.tx_storage.get_all_genesis()
if tx.is_block
][0].outputs[0]
partial_tx = Transaction.create_from_struct(
bytes.fromhex(nano_contract_hex))
partial_tx.outputs.append(genesis_output)
response_decode = yield decode_resource.get(
"wallet/nano_contracts/decode",
{b'hex_tx': bytes(partial_tx.get_struct().hex(), 'utf-8')})
data = response_decode.json_value()
self.assertTrue(data['success'])
nano_contract = data['nano_contract']
self.assertIsNotNone(nano_contract)
self.assertEqual(nano_contract['type'], 'NanoContractMatchValues')
self.assertEqual(len(data['other_inputs']), 0)
self.assertEqual(len(data['my_inputs']), 1)
self.assertEqual(len(data['outputs']), 1)
self.assertEqual(data['outputs'][0],
genesis_output.to_human_readable())
address2 = self.get_address(2)
data_put = {
'new_values': [{
'address': address2,
'value': 500
}],
'input_value': total_value
}
# Error missing parameter
response_error = yield match_value_resource.put(
"wallet/nano_contracts/match_value", data_put)
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
self.assertEqual(data_error['message'], 'Missing parameter: hex_tx')
# update
data_put['hex_tx'] = partial_tx.get_struct().hex()
response = yield match_value_resource.put(
"wallet/nano_contracts/match_value", data_put)
data = response.json_value()
self.assertTrue(data['success'])
self.assertIsNotNone(data['hex_tx'])
# Error nano contract not found
new_tx = Transaction.create_from_struct(partial_tx.get_struct())
new_tx.outputs = []
data_put['hex_tx'] = new_tx.get_struct().hex()
response = yield match_value_resource.put(
"wallet/nano_contracts/match_value", data_put)
data = response.json_value()
self.assertFalse(data['success'])
# Error missing parameter
response_error = yield signtx_resource.get("wallet/sign_tx", {})
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
self.assertEqual(data_error['message'], 'Missing parameter: hex_tx')
# Error wrong parameter value
response_error2 = yield signtx_resource.get("wallet/sign_tx", {
b'hex_tx': b'123',
b'prepare_to_send': b'true'
})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Error valid hex but wrong tx struct value
response_error3 = yield signtx_resource.get("wallet/sign_tx", {
b'hex_tx': b'1334',
b'prepare_to_send': b'true'
})
data_error3 = response_error3.json_value()
self.assertFalse(data_error3['success'])
# sign tx
response = yield signtx_resource.get(
"wallet/sign_tx", {
b'hex_tx': bytes(nano_contract_hex, 'utf-8'),
b'prepare_to_send': b'true'
})
data = response.json_value()
self.assertTrue(data['success'])
nano_contract_hex = data['hex_tx']
# sign tx without preparing
response2 = yield signtx_resource.get(
"wallet/sign_tx", {b'hex_tx': bytes(nano_contract_hex, 'utf-8')})
data2 = response2.json_value()
self.assertTrue(data2['success'])
self.assertIsNotNone(data2['hex_tx'])
# propagate tx
response = yield pushtx_resource.get(
"push_tx", {b'hex_tx': bytes(nano_contract_hex, 'utf-8')})
data = response.json_value()
self.assertTrue(data['success'])
self.reactor.advance(3)
# get tx hash
response = yield decodetx_resource.get(
"decode_tx", {b'hex_tx': bytes(nano_contract_hex, 'utf-8')})
data = response.json_value()
self.assertTrue(data['success'])
hash_hex = data['tx']['hash']
# Options
yield execute_resource.options("wallet/nano_contracts/execute")
# Error no data
response_error = yield execute_resource.post(
"wallet/nano_contracts/execute")
data_error = response_error.json_value()
self.assertFalse(data_error['success'])
# Error missing parameter
data = {
'spent_tx_index':
0,
'oracle_data':
'B3NvbWVfaWQEW/xjGQIBLA==',
'oracle_signature':
'MEUCIGeqbmLRI6lrgXMy4sQEgK94F5m14oVL5Z7oLLVII7BUAiEApKTMuWlwvws574'
'+jtqKW5/AuH+ICD0u+HyMyHe0aric=',
'oracle_pubkey':
'Awmloohhey8WhajdDURgvbk1z3JHX2vxDSBjz9uG9wEp',
'address':
address1,
'value':
total_value,
}
response_error2 = yield execute_resource.post(
"wallet/nano_contracts/execute", data)
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
self.assertEqual(data_error2['message'],
'Missing parameter: spent_tx_id')
# execute nano contract
data['spent_tx_id'] = hash_hex
response = yield execute_resource.post("wallet/nano_contracts/execute",
data)
data = response.json_value()
self.assertTrue(data['success'])
def setUp(self):
super().setUp()
self.web = StubSite(DecodeTxResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(VersionResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(ValidateAddressResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(BalanceResource(self.manager))
self.web_mining = StubSite(MiningResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(AddPeersResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(TipsHistogramResource(self.manager))
self.manager.wallet.unlock(b'MYPASS')
self.manager.reactor.advance(time.time())
def setUp(self):
super().setUp()
self.web = StubSite(StatusResource(self.manager))
self.manager2 = self.create_peer('testnet')
self.conn1 = FakeConnection(self.manager, self.manager2)
def test_token_history_invalid_params(self):
resource = StubSite(TokenHistoryResource(self.manager))
# invalid count
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'a'
})
data = response.json_value()
self.assertFalse(data['success'])
# missing token uid
response = yield resource.get('thin_wallet/token_history',
{b'count': b'3'})
data = response.json_value()
self.assertFalse(data['success'])
# invalid token uid
response = yield resource.get('thin_wallet/token_history', {
b'id': b'000',
b'count': b'3'
})
data = response.json_value()
self.assertFalse(data['success'])
# missing timestamp
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count':
b'3',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid timestamp
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'3',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
b'timestamp': b'a'
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid hash
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'3',
b'timestamp': b'1578118186',
b'page': b'next',
b'hash': b'000',
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid page
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count':
b'3',
b'timestamp':
b'1578118186',
b'page':
b'nextYY',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
})
data = response.json_value()
self.assertFalse(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']))
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 setUp(self):
super().setUp()
self.web = StubSite(DashboardTransactionResource(self.manager))
def setUp(self):
super().setUp()
self.get_block_template = StubSite(
mining.GetBlockTemplateResource(self.manager))
self.submit_block = StubSite(mining.SubmitBlockResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(UnlockWalletResource(self.manager))
self.web_lock = StubSite(LockWalletResource(self.manager))
self.web_state = StubSite(StateWalletResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(ProfilerResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(TxParentsResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(PushTxResource(self.manager))
self.web_tokens = StubSite(SendTokensResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(MiningStatsResource(self.manager))
def setUp(self):
super().setUp()
self.web = StubSite(BlockAtHeightResource(self.manager))
self.manager.wallet.unlock(b'MYPASS')
