def test_get(self):
response = yield self.web.get("wallet/balance")
data = response.json_value()
self.assertEqual(data['balance'], {'available': 0, 'locked': 0})
# 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')})
# Get new balance after block
response2 = yield self.web.get("wallet/balance")
data2 = response2.json_value()
tokens = self.manager.get_tokens_issued_per_block(1)
self.assertEqual(data2['balance'], {'available': tokens, 'locked': 0})
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')})
# Getting wallet history
response = yield self.web.get("wallet/history", {
b'page': 1,
b'count': 10
})
data = response.json_value()
self.assertEqual(len(data['history']), 1)
self.assertEqual(data['total_pages'], 1)
def test_post(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')})
add_blocks_unlock_reward(self.manager)
self.reactor.advance(10)
# Unlocking wallet
self.manager.wallet.unlock(b"MYPASS")
# Sending token to random address without input
# Options
yield self.web.options("wallet/send_tokens")
data_json = {
"outputs": [{
"address": self.get_address(0),
"value": 505
}],
"inputs": []
}
response = yield self.web.post("wallet/send_tokens",
{'data': data_json})
data = response.json_value()
self.assertTrue(data['success'])
self.reactor.advance(10)
# Asserting new balance
response_balance = yield self.web_balance.get("wallet/balance")
data_balance = response_balance.json_value()
tokens_per_block = self.manager.get_tokens_issued_per_block(1)
self.assertEqual(data_balance['balance'], {
'available': tokens_per_block - 505,
'locked': 0
})
# Getting history, so we can get the input
response_history = yield self.web_history.get("wallet/history", {
b'page': 1,
b'count': 10
})
data_history = response_history.json_value()
input_hash = data_history['history'][0]['tx_id']
# Sending token to random address with input wrong amount
data_json = {
"outputs": [{
"address": self.get_address(0),
"value": 500
}],
"inputs": [{
"tx_id": input_hash,
"index": 0
}]
}
response2 = yield self.web.post("wallet/send_tokens",
{'data': data_json})
data2 = response2.json_value()
self.assertFalse(data2['success'])
self.reactor.advance(10)
# Sending duplicate input
data_json_duplicate = {
"outputs": [{
"address": self.get_address(0),
"value": 19000
}],
"inputs": [{
"tx_id": input_hash,
"index": 0
}, {
"tx_id": input_hash,
"index": 0
}]
}
response_duplicate = yield self.web.post("wallet/send_tokens",
{'data': data_json_duplicate})
data_duplicate = response_duplicate.json_value()
self.assertFalse(data_duplicate['success'])
# Sending token to random address with input right amount
data_json2 = {
"outputs": [{
"address":
self.get_address(0),
"value":
self.manager.get_tokens_issued_per_block(1) - 505
}],
"inputs": [{
"tx_id": input_hash,
"index": 0
}]
}
response3 = yield self.web.post("wallet/send_tokens",
{'data': data_json2})
data3 = response3.json_value()
self.assertTrue(data3['success'])
# Sending token to invalid addresses
data_json3 = {
"outputs": [{
"address": self.get_address(1),
"value": 500
}],
"inputs": []
}
response_error1 = yield self.web.post("wallet/send_tokens",
{'data': data_json3})
data_error1 = response_error1.json_value()
self.assertFalse(data_error1['success'])
data_json4 = {
"outputs": [{
"address": "1234",
"value": 500
}],
"inputs": []
}
response_error2 = yield self.web.post("wallet/send_tokens",
{'data': data_json4})
data_error2 = response_error2.json_value()
self.assertFalse(data_error2['success'])
# Error insuficient funds
data_json5 = {
"outputs": [{
"address": self.get_address(0),
"value": 5000000
}],
"inputs": []
}
response_error3 = yield self.web.post("wallet/send_tokens",
{'data': data_json5})
data_error3 = response_error3.json_value()
self.assertFalse(data_error3['success'])
add_new_blocks(self.manager, 1, advance_clock=1)
add_blocks_unlock_reward(self.manager)
# Sending token with timelock
data_timelock = {
"outputs": [{
"address": self.get_address(0),
"value": 505,
"timelock": 1542995660
}],
"inputs": []
}
response_timelock = yield self.web.post("wallet/send_tokens",
{'data': data_timelock})
data_response_timelock = response_timelock.json_value()
self.assertTrue(data_response_timelock['success'])
self.reactor.advance(5)
# Sending token with timestamp
data_timestamp = {
"outputs": [{
"address": self.get_address(0),
"value": 5
}],
"inputs": [],
"timestamp": int(self.reactor.seconds())
}
response_timestamp = yield self.web.post("wallet/send_tokens",
{'data': data_timestamp})
data_response_timestamp = response_timestamp.json_value()
self.assertTrue(data_response_timestamp['success'])
self.reactor.advance(5)
# Sending token with timestamp=0
data_timestamp = {
"outputs": [{
"address": self.get_address(0),
"value": 5
}],
"inputs": [],
"timestamp": 0
}
response_timestamp = yield self.web.post("wallet/send_tokens",
{'data': data_timestamp})
data_response_timestamp = response_timestamp.json_value()
self.assertTrue(data_response_timestamp['success'])
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'])