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())
