def main():
""" Deploy smart contract on all shards """
parser = argparse.ArgumentParser()
parser.add_argument(
"--data",
default=
"608060405234801561001057600080fd5b5061014c806100206000396000f300608060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063a2f09dfa14610114575b60008034141561005057610111565b60644233604051808381526020018273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166c01000000000000000000000000028152601401925050506040518091039020600190048115156100b857fe5b069050603281111515610110573373ffffffffffffffffffffffffffffffffffffffff166108fc346002029081150290604051600060405180830381858888f1935050505015801561010e573d6000803e3d6000fd5b505b5b50005b61011c61011e565b005b5600a165627a7a72305820dfb8255e8f0df762fae8168c8539831acd2852d55c2dc1827fd4348c7ff989d20029",
type=str,
)
parser.add_argument("--jrpc_endpoint", default="localhost:38391", type=str)
parser.add_argument("--log_jrpc", default=False, type=bool)
args = parser.parse_args()
if not args.log_jrpc:
logging.getLogger("jsonrpcclient.client.request").setLevel(
logging.WARNING)
logging.getLogger("jsonrpcclient.client.response").setLevel(
logging.WARNING)
data = bytes.fromhex(args.data)
genesisId = Identity.create_from_key(DEFAULT_ENV.config.GENESIS_KEY)
endpoint = Endpoint("http://" + args.jrpc_endpoint)
asyncio.get_event_loop().run_until_complete(
deploy(endpoint, genesisId, data))
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))
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_create_random_account(self):
account = Account.new()
assert len(account.privkey) == 64
assert len(account.qkc_address.recipient.hex()) == 40
assert len(account.address) == 48
identity = Identity.create_from_key(account.identity.key)
assert account.address == Address.create_from_identity(identity).to_hex()
def test_getStorageAt(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:
req = lambda k: send_request(
"eth_getStorageAt", created_addr[:-8], k, "0x0"
)
else:
req = lambda k: send_request("getStorageAt", created_addr, k)
# first storage
response = req("0x0")
# equals 1234
self.assertEqual(
response,
"0x00000000000000000000000000000000000000000000000000000000000004d2",
)
# mapping storage
k = sha3_256(
bytes.fromhex(acc1.recipient.hex().zfill(64) + "1".zfill(64))
)
response = req("0x" + k.hex())
self.assertEqual(
response,
"0x000000000000000000000000000000000000000000000000000000000000162e",
)
# doesn't exist
response = req("0x3")
self.assertEqual(
response,
"0x0000000000000000000000000000000000000000000000000000000000000000",
)
def new(key=None):
"""
Create a new account.
:param key: the private key to import, or None to generate a random one
"""
if key is None:
identity = Identity.create_random_identity()
else:
if not isinstance(key, str):
raise Exception("Imported key must be a hexadecimal string")
identity = Identity.create_from_key(bytes.fromhex(key))
address = Address.create_from_identity(identity)
return Account(identity, address)
def main():
""" Fund the game addresses """
parser = argparse.ArgumentParser()
parser.add_argument("--data", default="a2f09dfa", type=str) # addFund
parser.add_argument("--jrpc_endpoint", default="localhost:38391", type=str)
parser.add_argument("--log_jrpc", default=False, type=bool)
args = parser.parse_args()
if not args.log_jrpc:
logging.getLogger("jsonrpcclient.client.request").setLevel(
logging.WARNING)
logging.getLogger("jsonrpcclient.client.response").setLevel(
logging.WARNING)
data = bytes.fromhex(args.data)
genesisId = Identity.create_from_key(DEFAULT_ENV.config.GENESIS_KEY)
endpoint = Endpoint("http://" + args.jrpc_endpoint)
asyncio.get_event_loop().run_until_complete(fund(endpoint, genesisId,
data))
def main():
""" Fund the game addresses """
parser = argparse.ArgumentParser()
parser.add_argument("--jrpc_endpoint", default="localhost:38391", type=str)
parser.add_argument("--log_jrpc", default=False, type=bool)
parser.add_argument("--tqkc_file", required=True, type=str)
args = parser.parse_args()
if not args.log_jrpc:
logging.getLogger("jsonrpcclient.client.request").setLevel(
logging.WARNING)
logging.getLogger("jsonrpcclient.client.response").setLevel(
logging.WARNING)
genesisId = Identity.create_from_key(DEFAULT_ENV.config.GENESIS_KEY)
endpoint = Endpoint("http://" + args.jrpc_endpoint)
addrByAmount = read_addr(args.tqkc_file)
asyncio.get_event_loop().run_until_complete(
fund(endpoint, genesisId, addrByAmount))
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)
