def test_call_failure(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): slaves = clusters[0].slave_list # insufficient gas response = send_request("call", { "to": "0x" + acc1.serialize().hex(), "gas": "0x1" }, None) self.assertIsNone(response, "failed tx should return None") self.assertEqual( len(clusters[0].get_shard_state(2 | 0).tx_queue), 0, "should not affect tx queue", )
def test_call_success_default_gas(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): slaves = clusters[0].slave_list # gas is not specified in the request response = send_request("call", [{ "to": "0x" + acc1.serialize().hex() }, "latest"]) self.assertEqual(response, "0x") self.assertEqual( len(clusters[0].get_shard_state(2 | 0).tx_queue), 0, "should not affect tx queue", )
def test_estimate_gas(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc2 = Address.create_random_account(full_shard_id=0) env = get_test_env(genesis_account=acc1, genesis_minor_quarkash=10000000) state = create_default_shard_state(env=env) tx_gen = lambda data: create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc2, value=12345, data=data, ) tx = tx_gen(b"") estimate = state.estimate_gas(tx, acc1) self.assertEqual(estimate, 21000) tx = tx_gen(b"12123478123412348125936583475758") estimate = state.estimate_gas(tx, acc1) self.assertEqual(estimate, 23176)
def test_call_success(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) with ClusterContext(1, acc1) as clusters, jrpc_server_context( clusters[0].master): slaves = clusters[0].slave_list branch = Branch.create(2, 0) response = send_request("call", [{ "to": "0x" + acc1.serialize().hex(), "gas": hex(21000) }]) self.assertEqual(response, "0x") self.assertEqual( len(slaves[0].shards[branch].state.tx_queue), 0, "should not affect tx queue", )
def test_getTransactionReceipt_on_contract_creation(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) with ClusterContext(1, acc1) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list branch = Branch.create(2, 0) to_full_shard_id = acc1.full_shard_id + 2 tx = create_contract_creation_transaction( shard_state=slaves[0].shards[branch].state, key=id1.get_key(), from_address=acc1, to_full_shard_id=to_full_shard_id, ) self.assertTrue(slaves[0].add_tx(tx)) _, block1 = call_async(master.get_next_block_to_mine(address=acc1)) self.assertTrue( call_async(clusters[0].get_shard(0).add_block(block1))) for endpoint in ("getTransactionReceipt", "eth_getTransactionReceipt"): resp = send_request( endpoint, "0x" + tx.get_hash().hex() + branch.serialize().hex()) self.assertEqual(resp["transactionHash"], "0x" + tx.get_hash().hex()) self.assertEqual(resp["status"], "0x1") self.assertEqual(resp["cumulativeGasUsed"], "0x213eb") contract_address = mk_contract_address(acc1.recipient, to_full_shard_id, 0) self.assertEqual( resp["contractAddress"], "0x" + contract_address.hex() + to_full_shard_id.to_bytes(4, "big").hex(), )
def test_getTransactionReceipt_on_contract_creation_failure(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) with ClusterContext(1, acc1) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list # Add a root block to update block gas limit for xshard tx throttling # so that the following tx can be processed is_root, root_block = call_async( master.get_next_block_to_mine(acc1)) self.assertTrue(is_root) call_async(master.add_root_block(root_block)) branch = Branch.create(2, 0) to_full_shard_id = (acc1.full_shard_id + 1 ) # x-shard contract creation should fail tx = create_contract_creation_transaction( shard_state=slaves[0].shards[branch].state, key=id1.get_key(), from_address=acc1, to_full_shard_id=to_full_shard_id, ) self.assertTrue(slaves[0].add_tx(tx)) _, block1 = call_async(master.get_next_block_to_mine(address=acc1)) self.assertTrue( call_async(clusters[0].get_shard(0).add_block(block1))) resp = send_request( "getTransactionReceipt", "0x" + tx.get_hash().hex() + branch.serialize().hex(), ) self.assertEqual(resp["transactionHash"], "0x" + tx.get_hash().hex()) self.assertEqual(resp["status"], "0x0") self.assertEqual(resp["cumulativeGasUsed"], "0x13d6c") self.assertIsNone(resp["contractAddress"])
def test_exceeding_xshard_limit(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc2 = Address.create_random_account(full_shard_id=1) acc3 = Address.create_random_account(full_shard_id=0) env = get_test_env(genesis_account=acc1, genesis_minor_quarkash=10000000) # a huge number to make xshard tx limit become 0 so that no xshard tx can be # included in the block env.quark_chain_config.MAX_NEIGHBORS = 10**18 state = create_default_shard_state(env=env) # xshard tx tx = create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc2, value=12345, gas=50000, ) self.assertTrue(state.add_tx(tx)) b1 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b1.tx_list), 0) # inshard tx tx = create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc3, value=12345, gas=50000, ) self.assertTrue(state.add_tx(tx)) b1 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b1.tx_list), 1)
def test_getTransactionReceipt_on_xshard_contract_creation(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list # Add a root block to update block gas limit for xshard tx throttling # so that the following tx can be processed root_block = call_async( master.get_next_block_to_mine(acc1, branch_value=None)) call_async(master.add_root_block(root_block)) to_full_shard_key = (acc1.full_shard_key + 1 ) # x-shard contract creation should fail tx = create_contract_creation_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_full_shard_key=to_full_shard_key, ) self.assertTrue(slaves[0].add_tx(tx)) block1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block1))) for endpoint in ("getTransactionReceipt", "eth_getTransactionReceipt"): resp = send_request(endpoint, ["0x" + tx.get_hash().hex() + "00000002"]) self.assertEqual(resp["transactionHash"], "0x" + tx.get_hash().hex()) self.assertEqual(resp["status"], "0x1") self.assertEqual(resp["cumulativeGasUsed"], "0x13d6c") self.assertIsNone(resp["contractAddress"])
def test_add_transaction(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc2 = Address.create_from_identity(id1, full_shard_id=1) with ClusterContext(2, acc1) as clusters: master = clusters[0].master slaves = clusters[0].slave_list branch0 = Branch.create(2, 0) tx1 = create_transfer_transaction( shard_state=slaves[0].shards[branch0].state, key=id1.get_key(), from_address=acc1, to_address=acc1, value=12345, ) self.assertTrue(call_async(master.add_transaction(tx1))) self.assertEqual(len(slaves[0].shards[branch0].state.tx_queue), 1) branch1 = Branch.create(2, 1) tx2 = create_transfer_transaction( shard_state=slaves[1].shards[branch1].state, key=id1.get_key(), from_address=acc2, to_address=acc1, value=12345, gas=30000, ) self.assertTrue(call_async(master.add_transaction(tx2))) self.assertEqual(len(slaves[1].shards[branch1].state.tx_queue), 1) # check the tx is received by the other cluster tx_queue = clusters[1].slave_list[0].shards[branch0].state.tx_queue assert_true_with_timeout(lambda: len(tx_queue) == 1) self.assertEqual(tx_queue.pop_transaction(), tx1.code.get_evm_transaction()) tx_queue = clusters[1].slave_list[1].shards[branch1].state.tx_queue assert_true_with_timeout(lambda: len(tx_queue) == 1) self.assertEqual(tx_queue.pop_transaction(), tx2.code.get_evm_transaction())
def test_getTransactionReceipt_on_contract_creation(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list to_full_shard_key = acc1.full_shard_key + 2 tx = create_contract_creation_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_full_shard_key=to_full_shard_key, ) self.assertTrue(slaves[0].add_tx(tx)) block1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block1))) for endpoint in ("getTransactionReceipt", "eth_getTransactionReceipt"): resp = send_request(endpoint, ["0x" + tx.get_hash().hex() + "00000002"]) self.assertEqual(resp["transactionHash"], "0x" + tx.get_hash().hex()) self.assertEqual(resp["status"], "0x1") self.assertEqual(resp["cumulativeGasUsed"], "0x213eb") contract_address = mk_contract_address(acc1.recipient, 0, to_full_shard_key) self.assertEqual( resp["contractAddress"], "0x" + contract_address.hex() + to_full_shard_key.to_bytes(4, "big").hex(), )
def test_fork_resolve(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) env = get_test_env(genesis_account=acc1, genesis_minor_quarkash=10000000) state = create_default_shard_state(env=env, shard_id=0) b0 = state.get_tip().create_block_to_append() b1 = state.get_tip().create_block_to_append() state.finalize_and_add_block(b0) self.assertEqual(state.header_tip, b0.header) # Fork happens, first come first serve state.finalize_and_add_block(b1) self.assertEqual(state.header_tip, b0.header) # Longer fork happens, override existing one b2 = b1.create_block_to_append() state.finalize_and_add_block(b2) self.assertEqual(state.header_tip, b2.header)
def test_get_primary_account_data(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc2 = Address.create_random_account(full_shard_id=1) with ClusterContext(1, acc1) as clusters: master = clusters[0].master slaves = clusters[0].slave_list branch = Branch.create(2, 0) self.assertEqual( call_async( master.get_primary_account_data(acc1)).transaction_count, 0) tx = create_transfer_transaction( shard_state=slaves[0].shards[branch].state, key=id1.get_key(), from_address=acc1, to_address=acc1, value=12345, ) self.assertTrue(slaves[0].add_tx(tx)) is_root, block1 = call_async( master.get_next_block_to_mine(address=acc1)) self.assertTrue( call_async( master.add_raw_minor_block(block1.header.branch, block1.serialize()))) self.assertEqual( call_async( master.get_primary_account_data(acc1)).transaction_count, 1) self.assertEqual( call_async( master.get_primary_account_data(acc2)).transaction_count, 0)
def test_add_minor_block_request_list(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) with ClusterContext(2, acc1) as clusters: shard_state = clusters[0].slave_list[0].shards[Branch(0b10)].state b1 = shard_state.get_tip().create_block_to_append() b1.finalize(evm_state=shard_state.run_block(b1)) addResult = call_async( clusters[0].master.add_raw_minor_block(b1.header.branch, b1.serialize()) ) self.assertTrue(addResult) # Make sure the xshard list is not broadcasted to the other shard self.assertFalse( clusters[0] .slave_list[1] .shards[Branch(0b11)] .state.contain_remote_minor_block_hash(b1.header.get_hash()) ) self.assertTrue( clusters[0].master.root_state.is_minor_block_validated( b1.header.get_hash() ) ) # Make sure another cluster received the new block assert_true_with_timeout( lambda: clusters[1] .slave_list[0] .shards[Branch(0b10)] .state.contain_block_by_hash(b1.header.get_hash()) ) assert_true_with_timeout( lambda: clusters[1].master.root_state.is_minor_block_validated( b1.header.get_hash() ) )
def test_gasPrice(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list # run for multiple times for _ in range(3): tx = create_transfer_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_address=acc1, value=0, gas_price=12, ) self.assertTrue(slaves[0].add_tx(tx)) block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block))) for using_eth_endpoint in (True, False): if using_eth_endpoint: resp = send_request("eth_gasPrice", ["0x0"]) else: resp = send_request( "gasPrice", ["0x0", quantity_encoder(token_id_encode("QKC"))]) self.assertEqual(resp, "0xc")
def test_xshard_tx_insufficient_gas(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc2 = Address.create_from_identity(id1, full_shard_id=1) acc3 = Address.create_random_account(full_shard_id=0) env = get_test_env(genesis_account=acc1, genesis_minor_quarkash=10000000) state = create_default_shard_state(env=env, shard_id=0) state.add_tx( create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc2, value=888888, gas=opcodes.GTXCOST, )) b1 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b1.tx_list), 0) self.assertEqual(len(state.tx_queue), 0)
def main(): args = parse_args() result = [] while True: identity = Identity.create_random_identity() address = Address.create_from_identity(identity) if args.shard > -1: # Follow the same algorithm in testnet web fullShard = int.from_bytes( sha3_256(address.recipient.hex().encode("utf-8"))[:4], "big") shard = fullShard & (args.shard_size - 1) if shard != args.shard: continue address = Address.create_from_identity(identity, fullShard) result.append({ "address": address.to_hex(), "key": identity.get_key().hex() }) args.num_accounts -= 1 if args.num_accounts == 0: break print(json.dumps(result, indent=4))
def test_tx_size(self): id1 = Identity.create_from_key(b"0" * 32) acc1 = Address.create_from_identity(id1, full_shard_key=0) evm_tx = EvmTransaction( nonce=0, gasprice=1, startgas=30000, to=acc1.recipient, value=0, data=b"", from_full_shard_key=0xFFFF, to_full_shard_key=0xFFFF, network_id=1, gas_token_id=12345, transfer_token_id=1234, ) evm_tx.sign(key=id1.get_key()) tx = TypedTransaction(SerializedEvmTransaction.from_evm_tx(evm_tx)) self.assertEqual(len(tx.serialize()), TX_MIN_SIZE) evm_tx = EvmTransaction( nonce=TT256 - 1, gasprice=TT256 - 1, startgas=TT256 - 1, to=acc1.recipient, value=TT256 - 1, data=b"", from_full_shard_key=SHARD_KEY_MAX, to_full_shard_key=SHARD_KEY_MAX, network_id=1, gas_token_id=TOKEN_ID_MAX, transfer_token_id=TOKEN_ID_MAX, ) evm_tx.sign(key=id1.get_key()) tx = TypedTransaction(SerializedEvmTransaction.from_evm_tx(evm_tx)) self.assertEqual(len(tx.serialize()), TX_MAX_SIZE)
def test_disallowed_unknown_token(self): """do not allow tx with unknown token id """ MALICIOUS0 = token_id_encode("MALICIOUS0") MALICIOUS1 = token_id_encode("MALICIOUS1") id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) acc3 = Address.create_random_account(full_shard_key=0) env = get_test_env( genesis_account=acc1, genesis_minor_token_balances={self.GENESIS_TOKEN: 10000000}, ) state = create_default_shard_state(env=env) tx = create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc1, value=0, gas=opcodes.GTXCOST, gas_token_id=self.genesis_token, transfer_token_id=MALICIOUS0, ) self.assertFalse(state.add_tx(tx)) tx1 = create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=acc1, value=0, gas=opcodes.GTXCOST, gas_token_id=MALICIOUS1, transfer_token_id=self.genesis_token, ) self.assertFalse(state.add_tx(tx1))
def test_createTransactions(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) acc2 = Address.create_random_account(full_shard_key=1) loadtest_accounts = [ { "address": "b067ac9ebeeecb10bbcd1088317959d58d1e38f6b0ee10d5", "key": "ca0143c9aa51c3013f08e83f3b6368a4f3ba5b52c4841c6e0c22c300f7ee6827", }, { "address": "9f2b984937ff8e3f20d2a2592f342f47257870909fffa247", "key": "40efdb8528de149c35fb43a572fc821d8fbdf2469dcc7fe1a9e847ef29e3c941", }, ] with ClusterContext(1, acc1, small_coinbase=True, loadtest_accounts=loadtest_accounts ) as clusters, jrpc_server_context( clusters[0].master): slaves = clusters[0].slave_list master = clusters[0].master block = call_async( master.get_next_block_to_mine(address=acc2, branch_value=None)) call_async(master.add_root_block(block)) send_request("createTransactions", { "numTxPerShard": 1, "xShardPercent": 0 })
def test_getCode(self): key = bytes.fromhex( "c987d4506fb6824639f9a9e3b8834584f5165e94680501d1b0044071cd36c3b3") id1 = Identity.create_from_key(key) acc1 = Address.create_from_identity(id1, full_shard_key=0) created_addr = "0x8531eb33bba796115f56ffa1b7df1ea3acdd8cdd00000000" with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list tx = create_contract_with_storage_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_full_shard_key=acc1.full_shard_key, ) self.assertTrue(slaves[0].add_tx(tx)) block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block))) for using_eth_endpoint in (True, False): if using_eth_endpoint: resp = send_request("eth_getCode", [created_addr[:-8], "0x0"]) else: resp = send_request("getCode", [created_addr]) self.assertEqual( resp, "0x6080604052600080fd00a165627a7a72305820a6ef942c101f06333ac35072a8ff40332c71d0e11cd0e6d86de8cae7b42696550029", )
def test_broadcast_cross_shard_transactions_to_neighbor_only(self): """ Test the broadcast is only done to the neighbors """ id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) # create 64 shards so that the neighbor rule can kick in # explicitly set num_slaves to 4 so that it does not spin up 64 slaves with ClusterContext(1, acc1, shard_size=64, num_slaves=4) as clusters: master = clusters[0].master # Add a root block first so that later minor blocks referring to this root # can be broadcasted to other shards is_root, root_block = call_async( master.get_next_block_to_mine( Address.create_empty_account(), prefer_root=True ) ) self.assertTrue(is_root) call_async(master.add_root_block(root_block)) b1 = clusters[0].get_shard_state(64).create_block_to_mine(address=acc1) self.assertTrue( call_async(master.add_raw_minor_block(b1.header.branch, b1.serialize())) ) neighbor_shards = [2 ** i for i in range(6)] for shard_id in range(64): xshard_tx_list = ( clusters[0] .get_shard_state(64 | shard_id) .db.get_minor_block_xshard_tx_list(b1.header.get_hash()) ) # Only neighbor should have it if shard_id in neighbor_shards: self.assertIsNotNone(xshard_tx_list) else: self.assertIsNone(xshard_tx_list)
def test_add_minor_block_request_list(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext(2, acc1) as clusters: shard_state = clusters[0].get_shard_state(0b10) b1 = _tip_gen(shard_state) add_result = call_async(clusters[0].master.add_raw_minor_block( b1.header.branch, b1.serialize())) self.assertTrue(add_result) # Make sure the xshard list is not broadcasted to the other shard self.assertFalse(clusters[0].get_shard_state( 0b11).contain_remote_minor_block_hash(b1.header.get_hash())) self.assertTrue( clusters[0].master.root_state.db.contain_minor_block_by_hash( b1.header.get_hash())) # Make sure another cluster received the new block assert_true_with_timeout(lambda: clusters[0].get_shard_state( 0b10).contain_block_by_hash(b1.header.get_hash())) assert_true_with_timeout( lambda: clusters[1].master.root_state.db. contain_minor_block_by_hash(b1.header.get_hash()))
def test_getTransactionById(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list self.assertEqual( call_async( master.get_primary_account_data(acc1)).transaction_count, 0) tx = create_transfer_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_address=acc1, value=12345, ) self.assertTrue(slaves[0].add_tx(tx)) block1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block1))) resp = send_request( "getTransactionById", [ "0x" + tx.get_hash().hex() + acc1.full_shard_key.to_bytes(4, "big").hex() ], ) self.assertEqual(resp["hash"], "0x" + tx.get_hash().hex())
def test_getLogs(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) expected_log_parts = { "logIndex": "0x0", "transactionIndex": "0x0", "blockNumber": "0x1", "blockHeight": "0x1", "data": "0x", } with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list tx = create_contract_creation_with_event_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_full_shard_key=acc1.full_shard_key, ) self.assertTrue(slaves[0].add_tx(tx)) block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block))) for using_eth_endpoint in (True, False): shard_id = hex(acc1.full_shard_key) if using_eth_endpoint: req = lambda o: send_request("eth_getLogs", [o, shard_id]) else: # `None` needed to bypass some request modification req = lambda o: send_request("getLogs", [o, shard_id]) # no filter object as wild cards resp = req({}) self.assertEqual(1, len(resp)) self.assertDictContainsSubset(expected_log_parts, resp[0]) # filter by contract address contract_addr = mk_contract_address(acc1.recipient, 0, acc1.full_shard_key) filter_obj = { "address": "0x" + contract_addr.hex() + ("" if using_eth_endpoint else hex( acc1.full_shard_key)[2:].zfill(8)) } resp = req(filter_obj) self.assertEqual(1, len(resp)) # filter by topics filter_obj = { "topics": [ "0xa9378d5bd800fae4d5b8d4c6712b2b64e8ecc86fdc831cb51944000fc7c8ecfa" ] } filter_obj_nested = { "topics": [[ "0xa9378d5bd800fae4d5b8d4c6712b2b64e8ecc86fdc831cb51944000fc7c8ecfa" ]] } for f in (filter_obj, filter_obj_nested): resp = req(f) self.assertEqual(1, len(resp)) self.assertDictContainsSubset(expected_log_parts, resp[0]) self.assertEqual( "0xa9378d5bd800fae4d5b8d4c6712b2b64e8ecc86fdc831cb51944000fc7c8ecfa", resp[0]["topics"][0], )
def test_contract_suicide(self): """ Kill Call Data: 0x41c0e1b5 """ QETH = token_id_encode("QETH") id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) id2 = Identity.create_random_identity() acc2 = Address.create_from_identity(id2, full_shard_key=0) acc3 = Address.create_random_account(full_shard_key=0) env = get_test_env( genesis_account=acc1, genesis_minor_token_balances={ self.GENESIS_TOKEN: 200 * 10 ** 18, "QETH": 99999, }, ) state = create_default_shard_state(env=env) # 1. create contract BYTECODE = "6080604052348015600f57600080fd5b5060948061001e6000396000f3fe6080604052600436106039576000357c01000000000000000000000000000000000000000000000000000000009004806341c0e1b514603b575b005b348015604657600080fd5b50604d604f565b005b3373ffffffffffffffffffffffffffffffffffffffff16fffea165627a7a7230582034cc4e996685dcadcc12db798751d2913034a3e963356819f2293c3baea4a18c0029" """ pragma solidity ^0.5.1; contract Sample { function () payable external{} function kill() external {selfdestruct(msg.sender);} } """ CREATION_GAS = 92417 tx = contract_creation_tx( shard_state=state, key=id1.get_key(), from_address=acc1, to_full_shard_key=acc1.full_shard_key, bytecode=BYTECODE, gas_token_id=self.genesis_token, transfer_token_id=self.genesis_token, ) self.assertTrue(state.add_tx(tx)) b1 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b1.tx_list), 1) state.finalize_and_add_block(b1) self.assertEqual(state.header_tip, b1.header) self.assertEqual(len(state.evm_state.receipts), 1) self.assertEqual(state.evm_state.receipts[0].state_root, b"\x01") self.assertEqual(state.evm_state.receipts[0].gas_used, CREATION_GAS) contract_address = mk_contract_address(acc1.recipient, 0, acc1.full_shard_key) self.assertEqual(contract_address, state.evm_state.receipts[0].contract_address) self.assertEqual( acc1.full_shard_key, state.evm_state.receipts[0].contract_full_shard_key ) self.assertEqual( state.get_token_balance(id1.recipient, self.genesis_token), 200 * 10 ** 18 - CREATION_GAS, ) self.assertEqual( state.get_token_balance(acc3.recipient, self.genesis_token), self.get_after_tax_reward(CREATION_GAS + self.shard_coinbase), ) tx_list, _ = state.db.get_transactions_by_address(acc1) self.assertEqual(tx_list[0].value, 0) self.assertEqual(tx_list[0].gas_token_id, self.genesis_token) self.assertEqual(tx_list[0].transfer_token_id, self.genesis_token) # 2. send some default token tx_send = create_transfer_transaction( shard_state=state, key=id1.get_key(), from_address=acc1, to_address=Address(contract_address, acc1.full_shard_key), value=10 * 10 ** 18, gas=opcodes.GTXCOST + 40, gas_price=1, nonce=None, data=b"", gas_token_id=self.genesis_token, transfer_token_id=self.genesis_token, ) self.assertTrue(state.add_tx(tx_send)) b2 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b2.tx_list), 1) state.finalize_and_add_block(b2) self.assertEqual(state.header_tip, b2.header) self.assertEqual(len(state.evm_state.receipts), 1) self.assertEqual(state.evm_state.receipts[0].state_root, b"\x01") self.assertEqual(state.evm_state.receipts[0].gas_used, opcodes.GTXCOST + 40) self.assertEqual( state.get_token_balance(id1.recipient, self.genesis_token), 200 * 10 ** 18 - CREATION_GAS - (opcodes.GTXCOST + 40) - 10 * 10 ** 18, ) self.assertEqual( state.get_token_balance(contract_address, self.genesis_token), 10 * 10 ** 18 ) # 3. suicide SUICIDE_GAS = 13199 tx_kill = create_transfer_transaction( shard_state=state, key=id2.get_key(), from_address=acc2, to_address=Address(contract_address, acc1.full_shard_key), value=0, gas=1000000, gas_price=0, # !!! acc2 has no token yet... nonce=None, data=bytes.fromhex("41c0e1b5"), gas_token_id=self.genesis_token, transfer_token_id=self.genesis_token, ) self.assertTrue(state.add_tx(tx_kill)) b3 = state.create_block_to_mine(address=acc3) self.assertEqual(len(b3.tx_list), 1) state.finalize_and_add_block(b3) self.assertEqual(state.header_tip, b3.header) self.assertEqual(len(state.evm_state.receipts), 1) self.assertEqual(state.evm_state.receipts[0].state_root, b"\x01") self.assertEqual(state.evm_state.receipts[0].gas_used, SUICIDE_GAS) self.assertEqual( state.get_token_balance(id2.recipient, self.genesis_token), 10 * 10 ** 18 ) self.assertEqual( state.get_token_balance(contract_address, self.genesis_token), 0 )
def test_getNextBlockToMine_and_addBlock(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_id=0) acc3 = Address.create_random_account(full_shard_id=1) with ClusterContext(1, acc1) as clusters, jrpc_server_context( clusters[0].master): slaves = clusters[0].slave_list # Expect to mine root that confirms the genesis minor blocks response = send_request("getNextBlockToMine", "0x" + acc1.serialize().hex(), "0x0") self.assertTrue(response["isRootBlock"]) block = RootBlock.deserialize( bytes.fromhex(response["blockData"][2:])) self.assertEqual(block.header.height, 1) self.assertEqual(len(block.minor_block_header_list), 2) self.assertEqual(block.minor_block_header_list[0].height, 0) self.assertEqual(block.minor_block_header_list[1].height, 0) send_request("addBlock", "0x0", response["blockData"]) tx = create_transfer_transaction( shard_state=clusters[0].get_shard_state(0), key=id1.get_key(), from_address=acc1, to_address=acc3, value=14, gas=opcodes.GTXXSHARDCOST + opcodes.GTXCOST, ) self.assertTrue(slaves[0].add_tx(tx)) # Expect to mine shard 0 since it has one tx response = send_request("getNextBlockToMine", "0x" + acc1.serialize().hex(), "0x0") self.assertFalse(response["isRootBlock"]) block1 = MinorBlock.deserialize( bytes.fromhex(response["blockData"][2:])) self.assertEqual(block1.header.branch.value, 0b10) self.assertTrue( send_request("addBlock", "0x2", response["blockData"])) self.assertEqual( clusters[0].get_shard_state(1).get_balance(acc3.recipient, 0), 0) # Expect to mine shard 1 due to proof-of-progress response = send_request("getNextBlockToMine", "0x" + acc1.serialize().hex(), "0x0") self.assertFalse(response["isRootBlock"]) block2 = MinorBlock.deserialize( bytes.fromhex(response["blockData"][2:])) self.assertEqual(block2.header.branch.value, 0b11) self.assertTrue( send_request("addBlock", "0x3", response["blockData"])) # Expect to mine root response = send_request("getNextBlockToMine", "0x" + acc1.serialize().hex(), "0x0") self.assertTrue(response["isRootBlock"]) block = RootBlock.deserialize( bytes.fromhex(response["blockData"][2:])) self.assertEqual(block.header.height, 2) self.assertEqual(len(block.minor_block_header_list), 2) self.assertEqual(block.minor_block_header_list[0], block1.header) self.assertEqual(block.minor_block_header_list[1], block2.header) send_request("addBlock", "0x0", response["blockData"]) self.assertEqual( clusters[0].get_shard_state(1).get_balance(acc3.recipient, 0), 0) # Expect to mine shard 1 for the gas on xshard tx to acc3 response = send_request("getNextBlockToMine", "0x" + acc1.serialize().hex(), "0x0") self.assertFalse(response["isRootBlock"]) block3 = MinorBlock.deserialize( bytes.fromhex(response["blockData"][2:])) self.assertEqual(block3.header.branch.value, 0b11) self.assertTrue( send_request("addBlock", "0x3", response["blockData"])) # Expect withdrawTo is included in acc3's balance resp = send_request("getBalance", "0x" + acc3.serialize().hex()) self.assertEqual(resp["branch"], "0x3") self.assertEqual(resp["balance"], "0xe")
def test_getTransactionReceipt_on_x_shard_transfer(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) acc2 = Address.create_from_identity(id1, full_shard_key=1) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list block = call_async( master.get_next_block_to_mine(address=acc2, branch_value=None)) call_async(master.add_root_block(block)) s1, s2 = ( clusters[0].get_shard_state(2 | 0), clusters[0].get_shard_state(2 | 1), ) tx_gen = lambda s, f, t: create_transfer_transaction( shard_state=s, key=id1.get_key(), from_address=f, to_address=t, gas=21000 if f == t else 30000, value=12345, ) self.assertTrue(slaves[0].add_tx(tx_gen(s1, acc1, acc2))) b1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(b1))) root_block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=None)) call_async(master.add_root_block(root_block)) tx = tx_gen(s2, acc2, acc2) self.assertTrue(slaves[0].add_tx(tx)) b3 = call_async( master.get_next_block_to_mine(address=acc2, branch_value=0b11)) self.assertTrue( call_async(clusters[0].get_shard(2 | 1).add_block(b3))) # in-shard tx 21000 + receiving x-shard tx 9000 self.assertEqual(s2.evm_state.gas_used, 30000) self.assertEqual(s2.evm_state.xshard_receive_gas_used, 9000) for endpoint in ("getTransactionReceipt", "eth_getTransactionReceipt"): resp = send_request( endpoint, [ "0x" + tx.get_hash().hex() + acc2.full_shard_key.to_bytes(4, "big").hex() ], ) self.assertEqual(resp["transactionHash"], "0x" + tx.get_hash().hex()) self.assertEqual(resp["status"], "0x1") self.assertEqual(resp["cumulativeGasUsed"], hex(30000)) self.assertEqual(resp["gasUsed"], hex(21000)) self.assertIsNone(resp["contractAddress"])
def test_getRootblockConfirmationIdAndCount(self): # TODO test root chain forks id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list self.assertEqual( call_async( master.get_primary_account_data(acc1)).transaction_count, 0) block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=None)) call_async(master.add_root_block(block)) tx = create_transfer_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_address=acc1, value=12345, ) self.assertTrue(slaves[0].add_tx(tx)) block1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block1))) tx_id = ("0x" + tx.get_hash().hex() + acc1.full_shard_key.to_bytes(4, "big").hex()) resp = send_request("getTransactionById", [tx_id]) self.assertEqual(resp["hash"], "0x" + tx.get_hash().hex()) self.assertEqual( resp["blockId"], "0x" + block1.header.get_hash().hex() + block1.header.branch.get_full_shard_id().to_bytes( 4, byteorder="big").hex(), ) minor_hash = resp["blockId"] # zero root block confirmation resp_hash = send_request("getRootHashConfirmingMinorBlockById", [minor_hash]) self.assertIsNone( resp_hash, "should return None for unconfirmed minor blocks") resp_count = send_request( "getTransactionConfirmedByNumberRootBlocks", [tx_id]) self.assertEqual(resp_count, "0x0") # 1 root block confirmation block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=None)) call_async(master.add_root_block(block)) resp_hash = send_request("getRootHashConfirmingMinorBlockById", [minor_hash]) self.assertIsNotNone(resp_hash, "confirmed by root block") self.assertEqual(resp_hash, "0x" + block.header.get_hash().hex()) resp_count = send_request( "getTransactionConfirmedByNumberRootBlocks", [tx_id]) self.assertEqual(resp_count, "0x1") # 2 root block confirmation block = call_async( master.get_next_block_to_mine(address=acc1, branch_value=None)) call_async(master.add_root_block(block)) resp_hash = send_request("getRootHashConfirmingMinorBlockById", [minor_hash]) self.assertIsNotNone(resp_hash, "confirmed by root block") self.assertNotEqual(resp_hash, "0x" + block.header.get_hash().hex()) resp_count = send_request( "getTransactionConfirmedByNumberRootBlocks", [tx_id]) self.assertEqual(resp_count, "0x2")
def test_getMinorBlock(self): id1 = Identity.create_random_identity() acc1 = Address.create_from_identity(id1, full_shard_key=0) with ClusterContext( 1, acc1, small_coinbase=True) as clusters, jrpc_server_context( clusters[0].master): master = clusters[0].master slaves = clusters[0].slave_list self.assertEqual( call_async( master.get_primary_account_data(acc1)).transaction_count, 0) tx = create_transfer_transaction( shard_state=clusters[0].get_shard_state(2 | 0), key=id1.get_key(), from_address=acc1, to_address=acc1, value=12345, ) self.assertTrue(slaves[0].add_tx(tx)) block1 = call_async( master.get_next_block_to_mine(address=acc1, branch_value=0b10)) self.assertTrue( call_async(clusters[0].get_shard(2 | 0).add_block(block1))) # By id for need_extra_info in [True, False]: resp = send_request( "getMinorBlockById", [ "0x" + block1.header.get_hash().hex() + "0" * 8, False, need_extra_info, ], ) self.assertEqual(resp["transactions"][0], "0x" + tx.get_hash().hex() + "00000002") resp = send_request( "getMinorBlockById", ["0x" + block1.header.get_hash().hex() + "0" * 8, True], ) self.assertEqual(resp["transactions"][0]["hash"], "0x" + tx.get_hash().hex()) resp = send_request("getMinorBlockById", ["0x" + "ff" * 36, True]) self.assertIsNone(resp) # By height for need_extra_info in [True, False]: resp = send_request("getMinorBlockByHeight", ["0x0", "0x1", False, need_extra_info]) self.assertEqual(resp["transactions"][0], "0x" + tx.get_hash().hex() + "00000002") resp = send_request("getMinorBlockByHeight", ["0x0", "0x1", True]) self.assertEqual(resp["transactions"][0]["hash"], "0x" + tx.get_hash().hex()) resp = send_request("getMinorBlockByHeight", ["0x1", "0x2", False]) self.assertIsNone(resp) resp = send_request("getMinorBlockByHeight", ["0x0", "0x4", False]) self.assertIsNone(resp)
def test_identity(self): id1 = Identity.create_random_identity() id2 = id1.create_from_key(id1.get_key()) self.assertEqual(id1.get_recipient(), id2.get_recipient()) self.assertEqual(id1.get_key(), id2.get_key())