def run_test(self): block_number = 2000 # Setup balance for each node client = RpcClient(self.nodes[0]) for i in range(self.num_nodes): pub_key = self.nodes[i].key addr = self.nodes[i].addr self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr), pub_key) tx = client.new_tx( value=int(default_config["TOTAL_COIN"] / self.num_nodes) - 21000, receiver=encode_hex(addr), nonce=i) client.send_tx(tx) for i in range(1, block_number): chosen_peer = random.randint(0, self.num_nodes - 1) self.log.debug("%d try to generate", chosen_peer) block_hash = RpcClient( self.nodes[chosen_peer]).generate_block(1000) self.log.info("%d generate block %s", chosen_peer, block_hash) time.sleep(random.random() / 15) wait_for_block_count(self.nodes[0], block_number) sync_blocks(self.nodes, timeout=30) hasha = self.nodes[0].getbestblockhash() block_a = client.block_by_hash(hasha) self.log.info("Final height = %s", block_a['height']) self.log.info("Pass")
def __init__(self, genesis: str, remote=False): super().__init__() # Track number of messages of each type received and the most recent # message of each type self.message_count = defaultdict(int) self.protocol_message_count = defaultdict(int) self.last_message = {} self.last_protocol_message = {} # Default protocol version self.protocol = b'cfx' self.protocol_version = 3 # Store genesis_hash self.genesis = decode_hex(genesis) self.best_block_hash = self.genesis self.blocks = {self.genesis: self.genesis} self.peer_pubkey = None self.priv_key, self.pub_key = ec_random_keys() x, y = self.pub_key self.key = "0x" + utils.encode_hex(bytes( int_to_32bytearray(x))) + utils.encode_hex( bytes(int_to_32bytearray(y))) self.had_status = False self.on_packet_func = {} self.remote = remote
def get_balance(self, contract, token_address): tx = contract.functions.balanceOf( Web3.toChecksumAddress( encode_hex(token_address))).buildTransaction(self.tx_conf) result = self.client.call(tx["to"], tx["data"]) balance = bytes_to_int(decode_hex(result)) self.log.debug("address=%s, balance=%s", encode_hex(token_address), balance) return balance
def get_balance(self, contract, token_address, nonce): tx = contract.functions.balanceOf(Web3.toChecksumAddress(encode_hex(token_address))).buildTransaction(self.tx_conf) tx["value"] = int_to_hex(tx['value']) tx["hash"] = "0x"+"0"*64 tx["nonce"] = int_to_hex(nonce) tx["v"] = "0x0" tx["r"] = "0x0" tx["s"] = "0x0" result = self.nodes[0].cfx_call(tx) balance = bytes_to_int(decode_hex(result)) self.log.debug("address=%s, balance=%s", encode_hex(token_address), balance) return balance
def run_test(self): block_number = 2000 # Setup balance for each node client = RpcClient(self.nodes[0]) for i in self.all_nodes: pub_key = self.nodes[i].key addr = self.nodes[i].addr self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr), pub_key) tx = client.new_tx(value=int(default_config["TOTAL_COIN"]/self.num_nodes) - 21000, receiver=encode_hex(addr), nonce=i) client.send_tx(tx) for i in range(1, block_number): chosen_peer = random.randint(0, self.num_nodes - 1) self.maybe_restart_node(chosen_peer, self.stop_probability, self.clean_probability) self.log.debug("%d try to generate", chosen_peer) block_hash = RpcClient(self.nodes[chosen_peer]).generate_block(random.randint(10, 100)) self.log.info("%d generate block %s", chosen_peer, block_hash) time.sleep(random.random()/15) self.log.info("sync blocks") for i in self.full_nodes: self.nodes[i].expireblockgc(1000000) sync_blocks(self.nodes, timeout=120, sync_count=False) self.log.info("block count:%d", self.nodes[0].getblockcount()) hasha = self.nodes[0].best_block_hash() block_a = client.block_by_hash(hasha) self.log.info("Final height = %s", block_a['height']) self.log.info("Pass")
def run_test(self): block_number = 10 for i in range(1, block_number): chosen_peer = random.randint(0, self.num_nodes - 1) block_hash = self.nodes[chosen_peer].generate(1, 0) self.log.info("generate block %s", block_hash) wait_for_block_count(self.nodes[0], block_number, timeout=30) sync_blocks(self.nodes, timeout=30) self.log.info("generated blocks received by all") self.stop_node(0, kill=True) self.log.info("node 0 stopped") block_hash = self.nodes[-1].generate(1, 0) self.log.info("generate block %s", block_hash) wait_for_block_count(self.nodes[1], block_number + 1) sync_blocks(self.nodes[1:], timeout=30) self.log.info("blocks sync success among running nodes") self.start_node(0) sync_blocks(self.nodes, timeout=30) self.log.info("Pass 1") for i in range(1, self.num_nodes): self.stop_node(i) self.nodes[0].add_p2p_connection(P2PInterface()) network_thread_start() self.nodes[0].p2p.wait_for_status() gas_price = 1 value = 1 receiver_sk, _ = ec_random_keys() sender_key = default_config["GENESIS_PRI_KEY"] tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=0, gas_price=gas_price) self.nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx])) self.log.debug("New tx %s: %s send value %d to %s", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:]) def check_packed(): client = RpcClient(self.nodes[0]) client.generate_block(1) return checktx(self.nodes[0], tx.hash_hex()) wait_until(lambda: check_packed()) sender_addr = eth_utils.encode_hex(privtoaddr(sender_key)) receiver_addr = eth_utils.encode_hex(privtoaddr(receiver_sk)) sender_balance = default_config["TOTAL_COIN"] - value - gas_price * 21000 # Generate 2 * CACHE_INDEX_STRIDE to start evicting anticone cache for _ in range(2000): self.nodes[0].generate(1, 0) assert_equal(parse_as_int(self.nodes[0].cfx_getBalance(sender_addr)), sender_balance) assert_equal(parse_as_int(self.nodes[0].cfx_getBalance(receiver_addr)), value) time.sleep(1) self.stop_node(0) self.start_node(0) self.log.info("Wait for node 0 to recover from crash") wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance(sender_addr)) == sender_balance) wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance(receiver_addr)) == value) self.log.info("Pass 2")
def run_test(self): client = RpcClient(self.nodes[0]) genesis_address = "0x" + encode_hex( priv_to_addr(default_config['GENESIS_PRI_KEY'])) genesis_balance = default_config["TOTAL_COIN"] client.generate_empty_blocks(ERA_EPOCH_COUNT * 10) print(client.epoch_number("latest_checkpoint")) assert client.epoch_number("latest_checkpoint") > 0 # Just assert we can still get the balance assert_equal(client.get_balance(genesis_address, client.EPOCH_NUM(1)), genesis_balance)
import rlp import sys, os from eth_utils import decode_hex sys.path.insert(1, os.path.join(sys.path[0], '..')) from conflux.utils import ec_random_keys, encode_hex, priv_to_pub NUM_NODES = 2 for _ in range(NUM_NODES): pri_key_raw, _ = ec_random_keys() pri_key = encode_hex(pri_key_raw) pub_key = encode_hex(priv_to_pub(pri_key_raw)) # print(f""" {host}: # index: {i} print(f""" net_pri_key: \"{pri_key}\" net_pub_key: \"{pub_key}\"""") # i += 1
def run_test(self): genesis_key = default_config["GENESIS_PRI_KEY"] balance_map = {genesis_key: default_config["TOTAL_COIN"]} self.log.info("Initial State: (sk:%d, addr:%s, balance:%d)", bytes_to_int(genesis_key), eth_utils.encode_hex(priv_to_addr(genesis_key)), balance_map[genesis_key]) nonce_map = {genesis_key: 0} # '''Check if transaction from uncommitted new address can be accepted''' # tx_n = 5 # receiver_sk = genesis_key gas_price = 1 # for i in range(tx_n): # sender_key = receiver_sk # value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random()) # nonce = nonce_map[sender_key] # receiver_sk, _ = ec_random_keys() # nonce_map[receiver_sk] = 0 # balance_map[receiver_sk] = value # tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce, # gas_price=gas_price) # r = random.randint(0, self.num_nodes - 1) # self.nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx])) # nonce_map[sender_key] = nonce + 1 # balance_map[sender_key] -= value + gas_price * 21000 # self.log.debug("New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:], # value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk]) # self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) # time.sleep(random.random() / 10 * self.delay_factor) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=self.delay_factor) block_gen_thread.start() # for k in balance_map: # self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k))) # wait_until(lambda: self.check_account(k, balance_map), timeout=60*self.delay_factor) # self.log.info("Pass 1") # self.register_test("general_1.json") '''Test Random Transactions''' all_txs = [] tx_n = 1000 account_n = 10 # Initialize new accounts new_keys = set() for _ in range(account_n): value = int(balance_map[genesis_key] * 0.5) receiver_sk, _ = ec_random_keys() new_keys.add(receiver_sk) tx = create_transaction(pri_key=genesis_key, receiver=priv_to_addr(receiver_sk), value=value, nonce=nonce_map[genesis_key], gas_price=gas_price) self.nodes[0].p2p.send_protocol_msg( Transactions(transactions=[tx])) balance_map[receiver_sk] = value nonce_map[genesis_key] += 1 balance_map[genesis_key] -= value + gas_price * 21000 wait_for_account_stable() for key in new_keys: nonce_map[key] = wait_for_initial_nonce_for_privkey( self.nodes[0], key) self.log.info( "start to generate %d transactions with about %d seconds", tx_n, tx_n / 10 / 2 * self.delay_factor) for i in range(tx_n): sender_key = random.choice(list(balance_map)) nonce = nonce_map[sender_key] value = 1 receiver_sk = random.choice(list(balance_map)) balance_map[receiver_sk] += value # not enough transaction fee (gas_price * gas_limit) should not happen for now assert balance_map[sender_key] >= value + gas_price * 21000 tx = create_transaction(pri_key=sender_key, receiver=priv_to_addr(receiver_sk), value=value, nonce=nonce, gas_price=gas_price) r = random.randint(0, self.num_nodes - 1) self.nodes[r].p2p.send_protocol_msg( Transactions(transactions=[tx])) all_txs.append(tx) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * 21000 self.log.debug( "New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d nonce:%d", encode_hex(tx.hash), eth_utils.encode_hex(priv_to_addr(sender_key))[-4:], value, eth_utils.encode_hex(priv_to_addr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk], nonce) self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) time.sleep(random.random() / 10 * self.delay_factor) for k in balance_map: self.log.info("Account %s with balance:%s", bytes_to_int(k), balance_map[k]) for tx in all_txs: self.log.debug("Wait for tx to confirm %s", tx.hash_hex()) for i in range(3): try: retry = True while retry: try: wait_until( lambda: checktx(self.nodes[0], tx.hash_hex()), timeout=60 * self.delay_factor) retry = False except CannotSendRequest: time.sleep(0.01) break except AssertionError as _: self.nodes[0].p2p.send_protocol_msg( Transactions(transactions=[tx])) if i == 2: raise AssertionError( "Tx {} not confirmed after 30 seconds".format( tx.hash_hex())) for k in balance_map: self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(priv_to_addr(k))) wait_until(lambda: self.check_account(k, balance_map), timeout=60 * self.delay_factor) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes, timeout=60 * self.delay_factor) self.log.info("Pass") self.register_test("general_2.json")
def run_test(self): sponsor_whitelist_contract_addr = Web3.toChecksumAddress( "0888000000000000000000000000000000000001") collateral_per_storage_key = COLLATERAL_UNIT_IN_DRIP * 64 upper_bound = 5 * 10**7 file_dir = os.path.dirname(os.path.realpath(__file__)) control_contract_file_path = os.path.join( file_dir, "..", "internal_contract", "metadata", "SponsorWhitelistControl.json") control_contract_dict = json.loads( open(control_contract_file_path, "r").read()) control_contract = get_contract_instance( contract_dict=control_contract_dict) test_contract = get_contract_instance( abi_file=os.path.join( file_dir, "contracts/commission_privilege_test_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/commission_privilege_test_bytecode.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = self.genesis_priv_key genesis_addr = encode_hex(self.genesis_addr) self.log.info("genesis_addr={}".format(genesis_addr)) nonce = 0 gas_price = 1 gas = CONTRACT_DEFAULT_GAS block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(genesis_addr), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } # Setup balance for node 0 node = self.nodes[0] client = RpcClient(node) (addr1, priv_key1) = client.rand_account() self.log.info("addr1={}".format(addr1)) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**6, nonce=self.get_nonce(self.genesis_addr), receiver=addr1) client.send_tx(tx, True) assert_equal(client.get_balance(addr1), 10**6) # setup contract transaction = self.call_contract_function( contract=test_contract, name="constructor", args=[], sender_key=self.genesis_priv_key, storage_limit=20000) contract_addr = self.wait_for_tx([transaction], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(client.get_balance(contract_addr), 0) # sponsor the contract succeed b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="setSponsorForGas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound) assert_equal(client.get_balance(genesis_addr), b0 - 10**18 - charged_of_huge_gas(gas)) # set privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) transaction = self.call_contract_function( contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=64) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) assert_equal( self.wait_for_tx([transaction], True)[0]['gasCoveredBySponsor'], False) # addr1 call contract with privilege without enough cfx for gas fee sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) transaction = self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(addr1), b1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - charged_of_huge_gas(gas)) assert_equal( self.wait_for_tx([transaction], True)[0]['gasCoveredBySponsor'], True) # sponsor collateral for the contract succeed b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="setSponsorForCollateral", args=[Web3.toChecksumAddress(contract_addr)], value=10**18, # 1 CFX = 1KB sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), 10**18) assert_equal(client.get_sponsor_for_collateral(contract_addr), genesis_addr) assert_equal(client.get_balance(genesis_addr), b0 - 10**18 - charged_of_huge_gas(gas)) # addr1 call contract with privilege without enough cfx for storage sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) transaction = self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=1024) assert_equal(client.get_balance(addr1), b1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - charged_of_huge_gas(gas)) assert_equal( self.wait_for_tx([transaction], True)[0]['storageCoveredBySponsor'], True) # addr1 call with larger storage limit, should not packed transaction = self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, storage_limit=1025) for _ in range(10): client.generate_block() tx_info = self.nodes[0].txpool_txWithPoolInfo(transaction.hash_hex()) assert_equal(int(tx_info['local_nonce'], 16), 2) assert_equal(tx_info['local_balance_enough'], False) assert_equal(tx_info['packed'], False) # send 1025 * 10 ** 18 // 1024 CFX to addr1 tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=1025 * 10**18 // 1024, nonce=self.get_nonce(self.genesis_addr), receiver=addr1) client.send_tx(tx, True) assert_equal(client.get_balance(addr1), 10**6 + 1025 * 10**18 // 1024) for _ in range(10): client.generate_block() tx_info = self.nodes[0].txpool_txWithPoolInfo(transaction.hash_hex()) # Now addr1 pays for storage collateral by itself. assert_equal( self.wait_for_tx([transaction], True)[0]['storageCoveredBySponsor'], False) assert_equal(int(tx_info['local_nonce'], 16), 3) assert_equal(tx_info['packed'], True) self.log.info("Pass")
def read_ack(self, remote_node_id: bytes): assert len(remote_node_id) == 64, "invalid node id length {}".format(len(remote_node_id)) self.peer.peer_key = utils.encode_hex(remote_node_id) self.state = "StartSession"
def on_protocol_packet(self, protocol, payload): """Receive message and dispatch message to appropriate callback. We keep a count of how many of each message type has been received and the most recent message of each type.""" with mininode_lock: try: assert(protocol == self.protocol) # Possible to be false? packet_type, payload = self.read_protocol_msg(payload) self.protocol_message_count[packet_type] += 1 msg = None msg_class = get_msg_class(packet_type) logger.debug("%s %s", packet_type, rlp.decode(payload)) if msg_class is not None: msg = rlp.decode(payload, msg_class) if packet_type == STATUS: self._log_message("receive", "STATUS, protocol_version:{}, terminal_hashes:{}" .format(msg.protocol_version, [utils.encode_hex(i) for i in msg.terminal_block_hashes])) self.had_status = True elif packet_type == GET_BLOCK_HEADERS: self._log_message("receive", "GET_BLOCK_HEADERS of {}".format(msg.hashes)) elif packet_type == GET_BLOCK_HEADER_CHAIN: self._log_message("receive", "GET_BLOCK_HEADER_CHAIN of {} {}".format(msg.hash, msg.max_blocks)) elif packet_type == GET_BLOCK_BODIES: hashes = msg.hashes self._log_message("receive", "GET_BLOCK_BODIES of {} blocks".format(len(hashes))) elif packet_type == GET_BLOCK_HEADERS_RESPONSE: self._log_message("receive", "BLOCK_HEADERS of {} headers".format(len(msg.headers))) elif packet_type == GET_BLOCK_BODIES_RESPONSE: self._log_message("receive", "BLOCK_BODIES of {} blocks".format(len(msg))) elif packet_type == NEW_BLOCK: self._log_message("receive", "NEW_BLOCK, hash:{}".format(msg.block.block_header.hash)) elif packet_type == GET_BLOCK_HASHES: self._log_message("receive", "GET_BLOCK_HASHES, hash:{}, max_blocks:{}" .format(msg.hash, msg.max_blocks)) elif packet_type == GET_BLOCK_HASHES_RESPONSE: self._log_message("receive", "BLOCK_HASHES, {} hashes".format(len(msg.hashes))) elif packet_type == GET_TERMINAL_BLOCK_HASHES: self._log_message("receive", "GET_TERMINAL_BLOCK_HASHES") elif packet_type == TRANSACTIONS: self._log_message("receive", "TRANSACTIONS, {} transactions".format(len(msg.transactions))) elif packet_type == GET_TERMINAL_BLOCK_HASHES_RESPONSE: self._log_message("receive", "TERMINAL_BLOCK_HASHES, {} hashes".format(len(msg.hashes))) elif packet_type == NEW_BLOCK_HASHES: self._log_message("receive", "NEW_BLOCK_HASHES, {} hashes".format(len(msg.block_hashes))) elif packet_type == GET_BLOCKS_RESPONSE: self._log_message("receive", "BLOCKS, {} blocks".format(len(msg.blocks))) elif packet_type == GET_CMPCT_BLOCKS_RESPONSE: self._log_message("receive", "GET_CMPCT_BLOCKS_RESPONSE, {} blocks".format(len(msg.blocks))) elif packet_type == GET_BLOCK_TXN_RESPONSE: self._log_message("receive", "GET_BLOCK_TXN_RESPONSE, block:{}".format(len(msg.block_hash))) elif packet_type == GET_BLOCKS: self._log_message("receive", "GET_BLOCKS, {} hashes".format(len(msg.hashes))) self.on_get_blocks(msg) elif packet_type == GET_CMPCT_BLOCKS: self._log_message("receive", "GET_CMPCT_BLOCKS, {} hashes".format(len(msg.hashes))) self.on_get_compact_blocks(msg) elif packet_type == GET_BLOCK_TXN: self._log_message("receive", "GET_BLOCK_TXN, hash={}".format(len(msg.block_hash))) self.on_get_blocktxn(msg) elif packet_type == GET_BLOCK_HASHES_BY_EPOCH: self._log_message("receive", "GET_BLOCK_HASHES_BY_EPOCH, epochs: {}".format(msg.epochs)) self.on_get_block_hashes_by_epoch(msg) else: self._log_message("receive", "Unknown packet {}".format(packet_type)) return if packet_type in self.on_packet_func and msg is not None: self.on_packet_func[packet_type](self, msg) except: raise
def on_block_headers(node, msg): self.log.info("Received %d headers", len(msg.headers)) for header in msg.headers: self.log.info("Block header: %s", encode_hex(header.hash))
def run_test(self): # Prevent easysolc from configuring the root logger to print to stderr self.log.propagate = False solc = Solc() file_dir = os.path.dirname(os.path.realpath(__file__)) staking_contract = solc.get_contract_instance( abi_file=os.path.join( file_dir, "contracts/storage_interest_staking_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/storage_interest_staking_bytecode.dat"), ) commission_privilege_contract = solc.get_contract_instance( abi_file=os.path.join( file_dir, "contracts/commission_privilege_control_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/commission_privilege_control_bytecode.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = self.genesis_priv_key genesis_addr = self.genesis_addr self.log.info("genesis_addr={}".format(encode_hex_0x(genesis_addr))) nonce = 0 gas_price = 1 gas = 50000000 block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(encode_hex_0x(genesis_addr)), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } # Setup balance for node 0 node = self.nodes[0] client = RpcClient(node) (addr, priv_key) = client.rand_account() self.log.info("addr=%s priv_key=%s", addr, priv_key) tx = client.new_tx(value=5 * 10**18, receiver=addr, nonce=self.get_nonce(genesis_addr)) client.send_tx(tx, True) assert_equal(node.cfx_getBalance(addr), hex(5000000000000000000)) assert_equal(node.cfx_getBankBalance(addr), hex(0)) self.tx_conf["to"] = Web3.toChecksumAddress( "443c409373ffd5c0bec1dddb7bec830856757b65") # deposit 2 * 10**18 / 16 tx_data = decode_hex( staking_contract.functions.deposit( 2 * 10**18 // 16).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, receiver=self.tx_conf["to"], nonce=self.get_nonce(genesis_addr), gas=gas, data=tx_data) client.send_tx(tx, True) assert_equal(node.cfx_getBankBalance(encode_hex(genesis_addr)), hex(2 * 10**18 // 16)) # setup contract transaction = self.call_contract_function( contract=commission_privilege_contract, name="constructor", args=[], sender_key=self.genesis_priv_key) contract_addr = self.wait_for_tx([transaction], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(node.cfx_getBalance(contract_addr), hex(0)) # setup balance transaction = self.call_contract_function( contract=commission_privilege_contract, name="set", args=[], sender_key=genesis_key, contract_addr=contract_addr, value=10**18, wait=True, check_status=True) assert_equal(node.cfx_getBalance(contract_addr), hex(10**18)) # call contract with privilege geneis_balance = node.cfx_getBalance(encode_hex(genesis_addr)) transaction = self.call_contract_function( contract=commission_privilege_contract, name="foo", args=[], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas)) assert_equal(node.cfx_getBalance(encode_hex(genesis_addr)), geneis_balance) # call contract without privilege and remove privilege of genesis transaction = self.call_contract_function( contract=commission_privilege_contract, name="remove", args=[], sender_key=priv_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas)) assert_equal(node.cfx_getBalance(addr), hex(5 * 10**18 - gas)) # call contract after removing privilege geneis_balance = int(node.cfx_getBalance(encode_hex(genesis_addr)), 16) transaction = self.call_contract_function( contract=commission_privilege_contract, name="foo", args=[], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(node.cfx_getBalance(contract_addr), hex(10**18 - gas)) self.log.info("Pass")
def run_test(self): # Start mininode connection self.node = self.nodes[0] start_p2p_connection([self.node]) block_gen_thread = BlockGenThread([self.node], self.log, num_txs=100, interval_fixed=0.2) block_gen_thread.start() tx_n = 100000 generate = False if generate: f = open("encoded_tx", "wb") '''Test Random Transactions''' genesis_key = default_config["GENESIS_PRI_KEY"] balance_map = {genesis_key: default_config["TOTAL_COIN"]} nonce_map = {genesis_key: 0} all_txs = [] gas_price = 1 self.log.info("start to generate %d transactions", tx_n) for i in range(tx_n): if i % 1000 == 0: self.log.debug("generated %d tx", i) sender_key = random.choice(list(balance_map)) nonce = nonce_map[sender_key] if random.random( ) < 0.1 and balance_map[sender_key] > 21000 * 4 * tx_n: value = int(balance_map[sender_key] * 0.5) receiver_sk, _ = ec_random_keys() nonce_map[receiver_sk] = 0 balance_map[receiver_sk] = value else: value = 1 receiver_sk = random.choice(list(balance_map)) balance_map[receiver_sk] += value # not enough transaction fee (gas_price * gas_limit) should not happen for now assert balance_map[sender_key] >= value + gas_price * 21000 tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce, gas_price=gas_price) self.log.debug( "%s send %d to %s nonce=%d balance: sender=%s, receiver=%s", encode_hex(privtoaddr(sender_key)), value, encode_hex(privtoaddr(receiver_sk)), nonce, balance_map[sender_key], balance_map[receiver_sk]) all_txs.append(tx) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * 21000 encoded_txs = [] batch_tx = [] i = 0 for tx in all_txs: batch_tx.append(tx) i += 1 if i % 1000 == 0: encoded = rlp.encode(Transactions(transactions=batch_tx)) encoded_txs.append(encoded) batch_tx = [] pickle.dump(encoded_txs, f) pickle.dump(balance_map, f) else: f = open("encoded_tx", "rb") encoded_txs = pickle.load(f) balance_map = pickle.load(f) f.close() start_time = datetime.datetime.now() for encoded in encoded_txs: self.node.p2p.send_protocol_packet( int_to_bytes(TRANSACTIONS) + encoded) for k in balance_map: wait_until(lambda: self.check_account(k, balance_map)) end_time = datetime.datetime.now() time_used = (end_time - start_time).total_seconds() block_gen_thread.stop() block_gen_thread.join() self.log.info("Time used: %f seconds", time_used) self.log.info("Tx per second: %f", tx_n / time_used)
def run_test(self): sponsor_whitelist_contract_addr = Web3.toChecksumAddress( "8ad036480160591706c831f0da19d1a424e39469") bytes_per_key = 64 collateral_per_storage_key = 10**18 // 16 upper_bound = 5 * 10**7 file_dir = os.path.dirname(os.path.realpath(__file__)) control_contract_file_path = os.path.dirname( os.path.realpath(__file__)).split("/") control_contract_file_path.pop(-1) control_contract_file_path.extend( ["internal_contract", "metadata", "SponsorWhitelistControl.json"]) control_contract_file_path = "/".join(control_contract_file_path) control_contract_dict = json.loads( open(os.path.join(control_contract_file_path), "r").read()) control_contract = get_contract_instance( contract_dict=control_contract_dict) test_contract = get_contract_instance( abi_file=os.path.join( file_dir, "contracts/commission_privilege_test_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/commission_privilege_test_bytecode.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = self.genesis_priv_key genesis_addr = encode_hex(self.genesis_addr) self.log.info("genesis_addr={}".format(genesis_addr)) nonce = 0 gas_price = 1 gas = 50000000 block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(genesis_addr), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } # Setup balance for node 0 node = self.nodes[0] client = RpcClient(node) (addr1, priv_key1) = client.rand_account() (addr2, priv_key2) = client.rand_account() (addr3, priv_key3) = client.rand_account() tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr1) client.send_tx(tx, True) assert_equal(client.get_balance(addr1), 10**18) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr2) client.send_tx(tx, True) assert_equal(client.get_balance(addr2), 10**18) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=3 * 10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr3) client.send_tx(tx, True) assert_equal(client.get_balance(addr3), 3 * 10**18) # setup contract transaction = self.call_contract_function( contract=test_contract, name="constructor", args=[], sender_key=self.genesis_priv_key) contract_addr = self.wait_for_tx([transaction], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(client.get_balance(contract_addr), 0) # sponsor the contract failed due to sponsor_balance < 1000 * upper_bound b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=upper_bound * 1000 - 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 0) assert_equal(client.get_sponsor_for_gas(contract_addr), "0x0000000000000000000000000000000000000000") assert_equal(client.get_sponsor_gas_bound(contract_addr), 0) assert_equal(client.get_balance(genesis_addr), b0 - gas) # sponsor the contract succeed b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound) assert_equal(client.get_balance(genesis_addr), b0 - 10**18 - gas + 12500000) # set privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(genesis_addr), b0 - gas + 12500000 - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) # addr1 call contract with privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(addr1), b1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - gas + 12500000) # addr1 call contract with privilege and large tx fee b1 = client.get_balance(addr1) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True, gas=upper_bound + 1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr1), b1 - upper_bound + upper_bound // 4 - 1) # addr2 call contract without privilege b2 = client.get_balance(addr2) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key2, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr2), b2 - gas + 12500000) # set privilege for addr2 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr2)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(genesis_addr), b0 - gas + 12500000 - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) # now, addr2 call contract with privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key2, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - gas + 12500000) assert_equal(client.get_balance(addr2), b2) # remove privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="remove", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 - collateral_per_storage_key) assert_equal(client.get_balance(genesis_addr), b0 - gas + 12500000 + collateral_per_storage_key) # addr1 call contract without privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr1), b1 - gas + 12500000) # new sponsor failed due to small sponsor_balance b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1], value=5 * 10**17, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_balance(addr3), b3 - gas) # new sponsor failed due to small upper bound b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_balance(addr3), b3 - gas) # new sponsor succeed b0 = client.get_balance(genesis_addr) b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1], value=10**18, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound + 1) assert_equal(client.get_sponsor_for_gas(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - 10**18 - gas + 12500000) assert_equal(client.get_balance(genesis_addr), b0 + sb) # sponsor the contract for collateral failed due to zero sponsor balance b3 = client.get_balance(addr3) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=0, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), 0) assert_equal(client.get_sponsor_for_collateral(contract_addr), "0x0000000000000000000000000000000000000000") assert_equal(client.get_balance(addr3), b3 - gas) # sponsor the contract for collateral succeed b3 = client.get_balance(addr3) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=10**18 - 1, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), 10**18 - 1) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - gas + 12500000 - 10**18 + 1) # addr1 create 2 keys without privilege, and storage limit is 1, should failed b1 = client.get_balance(addr1) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), 0) self.call_contract_function(contract=test_contract, name="par_add", args=[0, 2], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), 0) assert_equal(client.get_balance(addr1), b1 - gas) # addr1 create 2 keys without privilege, and storage limit is 2, should succeed b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="par_add", args=[0, 2], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), collateral_per_storage_key * 2) assert_equal(client.get_balance(addr1), b1 - gas + 12500000 - collateral_per_storage_key * 2) # remove 1 key create by addr1 b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="par_del", args=[0, 1], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), collateral_per_storage_key) assert_equal(client.get_balance(addr1), b1 - gas + 12500000 + collateral_per_storage_key) # addr2 create 2 keys with privilege, and storage limit is 1, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[2, 4], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 2) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc - collateral_per_storage_key * 2) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas + 12500000) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # addr2 create 13 keys with privilege, and storage limit is 0, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[4, 17], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=0) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc - collateral_per_storage_key * 13) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas + 12500000) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # now sponsor_balance is unable to pay collateral for storage # the balance of addr2 is able to pay 15 collateral for storage, but not 16 assert_greater_than( collateral_per_storage_key, client.get_sponsor_balance_for_collateral(contract_addr)) assert_greater_than(collateral_per_storage_key * 16, client.get_balance(addr2)) assert_greater_than(client.get_balance(addr2), collateral_per_storage_key * 15) # addr2 create 1 keys with privilege, and storage limit is 0, should failed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[17, 18], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=0) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # addr2 create 1 keys with privilege, and storage limit is 2, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[17, 18], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas + 12500000) assert_equal(client.get_collateral_for_storage(addr2), collateral_per_storage_key) assert_equal(client.get_balance(addr2), b2 - collateral_per_storage_key) # addr2 del 10 keys with privilege sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_del", args=[2, 12], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 5) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc + collateral_per_storage_key * 10) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas + 12500000) assert_equal(client.get_collateral_for_storage(addr2), collateral_per_storage_key) assert_equal(client.get_balance(addr2), b2) # addr3 sponsor more, treat as transfer b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb * 2) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - gas + 12500000 - sb) # genesis sponsor with sponsor balance, should failed b0 = client.get_balance(genesis_addr) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb + 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(genesis_addr), b0 - gas) # genesis sponsor with sponsor balance and collateral_for_storage, should succeed b0 = client.get_balance(genesis_addr) b3 = client.get_balance(addr3) cfs = client.get_collateral_for_storage(contract_addr) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb + cfs + 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_collateral_for_storage(contract_addr), cfs) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb + cfs + 1) assert_equal(client.get_sponsor_for_collateral(contract_addr), genesis_addr) assert_equal(client.get_balance(genesis_addr), b0 - gas + 12500000 - sb - cfs - 1) assert_equal(client.get_balance(addr3), b3 + sb + cfs) self.log.info("Pass")
def run_test(self): start_p2p_connection(self.nodes) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.2) block_gen_thread.start() genesis_key = default_config["GENESIS_PRI_KEY"] tx_n = 100 gas_price = 1 shard_balance = [] for s in range(self.n_shard): ''' Send random transactions to this shard s ''' shard_nodes = self.nodes[s * self.shard_size:(s + 1) * self.shard_size] # We can not use genesis accounts in two shards, because they may generate transactions # that are valid in another shard and breaks our assertion about the final shard state. start_sk, _ = ec_random_keys() value = default_config["TOTAL_COIN"] - 21000 tx = create_transaction(pri_key=genesis_key, receiver=priv_to_addr(start_sk), value=value, nonce=0, gas_price=gas_price) shard_nodes[0].p2p.send_protocol_msg( Transactions(transactions=[tx])) balance_map = {start_sk: value} nonce_map = { start_sk: wait_for_initial_nonce_for_privkey(shard_nodes[0], start_sk) } account_n = 10 # Initialize new accounts new_keys = set() for _ in range(account_n): value = max(int(balance_map[start_sk] * random.random()), 21000 * tx_n) receiver_sk, _ = ec_random_keys() new_keys.add(receiver_sk) tx = create_transaction(pri_key=start_sk, receiver=priv_to_addr(receiver_sk), value=value, nonce=nonce_map[start_sk], gas_price=gas_price) shard_nodes[0].p2p.send_protocol_msg( Transactions(transactions=[tx])) balance_map[receiver_sk] = value nonce_map[start_sk] += 1 balance_map[start_sk] -= value + gas_price * 21000 wait_for_account_stable() for key in new_keys: nonce_map[key] = wait_for_initial_nonce_for_privkey( shard_nodes[0], key) for i in range(tx_n): sender_key = random.choice(list(balance_map)) nonce = nonce_map[sender_key] value = 0 receiver_sk = random.choice(list(balance_map)) balance_map[receiver_sk] += value tx = create_transaction(pri_key=sender_key, receiver=priv_to_addr(receiver_sk), value=value, nonce=nonce, gas_price=gas_price) r = random.randint(0, self.shard_size - 1) shard_nodes[r].p2p.send_protocol_msg( Transactions(transactions=[tx])) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * 21000 self.log.info( "New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(priv_to_addr(sender_key))[-4:], value, eth_utils.encode_hex(priv_to_addr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk]) self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) time.sleep(random.random() / 10) for k in balance_map: self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(priv_to_addr(k))) wait_until( lambda: self.check_account(k, balance_map, shard_nodes[0])) shard_balance.append(balance_map) def epochCheck(node): r = node.cfx_epochNumber() return int(r, 0) > 110 wait_until(lambda: epochCheck(self.nodes[0])) wait_until( lambda: epochCheck(self.nodes[int(self.num_nodes / self.n_shard)])) for s in range(self.n_shard): for idx in range(self.shard_size): connect_nodes(self.nodes, s * self.shard_size - 1 + idx, s * self.shard_size + idx) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes) ''' Check if the balance state of every node matches ''' success_shard = -1 # use the state of node 0 to find the winning shard for s in range(self.n_shard): balance_map = shard_balance[s] unmatch = False for k in balance_map: if not self.check_account(k, balance_map, self.nodes[0]): unmatch = True self.log.info( "Final balance does not match shard %s, check next", s) break if unmatch: continue success_shard = s break assert success_shard != -1, "The final state of node 0 matches no shard state" self.log.info("Shard %s succeeds", success_shard) for i in range(1, self.num_nodes): balance_map = shard_balance[success_shard] for k in balance_map: if not self.check_account(k, balance_map, self.nodes[i]): raise AssertionError( "Final balance of node {} does not match node 0, sender={}" .format(i, k)) self.log.info("Pass")
def run_test(self): sponsor_whitelist_contract_addr = Web3.toChecksumAddress( "0888000000000000000000000000000000000001") bytes_per_key = 64 collateral_per_byte = 10**18 // 1024 collateral_per_storage_key = 10**18 // 16 # block gas limit (GENESIS_GAS_LIMIT); -1 because below gas is set to upper_bound + 1 upper_bound = default_config["GENESIS_GAS_LIMIT"] - 1 file_dir = os.path.dirname(os.path.realpath(__file__)) control_contract_file_path = os.path.dirname( os.path.realpath(__file__)).split("/") control_contract_file_path.pop(-1) control_contract_file_path.extend( ["internal_contract", "metadata", "SponsorWhitelistControl.json"]) control_contract_file_path = "/".join(control_contract_file_path) control_contract_dict = json.loads( open(os.path.join(control_contract_file_path), "r").read()) control_contract = get_contract_instance( contract_dict=control_contract_dict) test_contract = get_contract_instance( abi_file=os.path.join( file_dir, "contracts/commission_privilege_test_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/commission_privilege_test_bytecode.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = self.genesis_priv_key genesis_addr = encode_hex(self.genesis_addr) self.log.info("genesis_addr={}".format(genesis_addr)) nonce = 0 gas_price = 1 gas = CONTRACT_DEFAULT_GAS block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(genesis_addr), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } # Setup balance for node 0 node = self.nodes[0] client = RpcClient(node) (addr1, priv_key1) = client.rand_account() (addr2, priv_key2) = client.rand_account() (addr3, priv_key3) = client.rand_account() (addr4, priv_key4) = client.rand_account() tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr1) client.send_tx(tx, True) assert_equal(client.get_balance(addr1), 10**18) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr2) client.send_tx(tx, True) assert_equal(client.get_balance(addr2), 10**18) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=3 * 10**18, nonce=self.get_nonce(self.genesis_addr), receiver=addr3) client.send_tx(tx, True) assert_equal(client.get_balance(addr3), 3 * 10**18) # setup contract transaction = self.call_contract_function( contract=test_contract, name="constructor", args=[], sender_key=self.genesis_priv_key, storage_limit=2723) contract_addr = self.wait_for_tx([transaction], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(client.get_balance(contract_addr), 0) assert_equal(client.get_collateral_for_storage(genesis_addr), 2723 * collateral_per_byte) # sponsor the contract failed due to sponsor_balance < 1000 * upper_bound b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=upper_bound * 1000 - 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 0) assert_equal(client.get_sponsor_for_gas(contract_addr), "0x0000000000000000000000000000000000000000") assert_equal(client.get_sponsor_gas_bound(contract_addr), 0) assert_equal(client.get_balance(genesis_addr), b0 - gas) # sponsor the contract succeed b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound) assert_equal(client.get_balance(genesis_addr), b0 - 10**18 - charged_of_huge_gas(gas)) check_info = client.check_balance_against_transaction(addr1, contract_addr, gas, gas_price, storage_limit=0) assert_equal(check_info['willPayTxFee'], True) assert_equal(check_info['willPayCollateral'], True) assert_equal(check_info['isBalanceEnough'], True) check_info = client.check_balance_against_transaction(addr4, contract_addr, gas, gas_price, storage_limit=0) assert_equal(check_info['willPayTxFee'], True) assert_equal(check_info['willPayCollateral'], True) assert_equal(check_info['isBalanceEnough'], False) # set privilege for addr4 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr4)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=64) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) check_info = client.check_balance_against_transaction(addr4, contract_addr, gas, gas_price, storage_limit=0) assert_equal(check_info['willPayTxFee'], False) assert_equal(check_info['willPayCollateral'], True) assert_equal(check_info['isBalanceEnough'], True) # remove privilege for addr4 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="remove", args=[Web3.toChecksumAddress(addr4)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 - collateral_per_storage_key) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) + collateral_per_storage_key) # set privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=64) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) # addr1 call contract with privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(addr1), b1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - charged_of_huge_gas(gas)) # addr1 call contract with privilege and large tx fee b1 = client.get_balance(addr1) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True, gas=upper_bound + 1) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr1), b1 - charged_of_huge_gas(upper_bound + 1)) # addr2 call contract without privilege b2 = client.get_balance(addr2) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key2, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr2), b2 - charged_of_huge_gas(gas)) # set privilege for addr2 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr2)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=64) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) # now, addr2 call contract with privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key2, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - charged_of_huge_gas(gas)) assert_equal(client.get_balance(addr2), b2) # remove privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="remove", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 - collateral_per_storage_key) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) + collateral_per_storage_key) # addr1 call contract without privilege sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_balance(addr1), b1 - charged_of_huge_gas(gas)) # new sponsor failed due to small sponsor_balance b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1], value=5 * 10**17, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_balance(addr3), b3 - gas) # new sponsor failed due to small upper bound b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_balance(addr3), b3 - gas) # new sponsor succeed b0 = client.get_balance(genesis_addr) b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_gas(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound + 1], value=10**18, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound + 1) assert_equal(client.get_sponsor_for_gas(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - 10**18 - charged_of_huge_gas(gas)) assert_equal(client.get_balance(genesis_addr), b0 + sb) # sponsor the contract for collateral failed due to zero sponsor balance b3 = client.get_balance(addr3) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=0, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), 0) assert_equal(client.get_sponsor_for_collateral(contract_addr), "0x0000000000000000000000000000000000000000") assert_equal(client.get_balance(addr3), b3 - gas) # sponsor the contract for collateral succeed b3 = client.get_balance(addr3) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=10**18 - 1, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), 10**18 - 1) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - charged_of_huge_gas(gas) - 10**18 + 1) check_info = client.check_balance_against_transaction(addr1, contract_addr, gas, gas_price, storage_limit=0) assert_equal(check_info['willPayTxFee'], True) assert_equal(check_info['willPayCollateral'], True) assert_equal(check_info['isBalanceEnough'], True) # addr1 create 2 keys without privilege, and storage limit is 1, should failed b1 = client.get_balance(addr1) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), 0) self.call_contract_function(contract=test_contract, name="par_add", args=[0, 2], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), 0) assert_equal(client.get_balance(addr1), b1 - gas) # addr1 create 2 keys without privilege, and storage limit is 2, should succeed b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="par_add", args=[0, 2], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), collateral_per_storage_key * 2) assert_equal( client.get_balance(addr1), b1 - charged_of_huge_gas(gas) - collateral_per_storage_key * 2) # remove 1 key create by addr1 b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="par_del", args=[0, 1], sender_key=priv_key1, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), 0) assert_equal(client.get_collateral_for_storage(addr1), collateral_per_storage_key) assert_equal( client.get_balance(addr1), b1 - charged_of_huge_gas(gas) + collateral_per_storage_key) check_info = client.check_balance_against_transaction( addr2, contract_addr, gas, gas_price, storage_limit=bytes_per_key) assert_equal(check_info['willPayTxFee'], False) assert_equal(check_info['willPayCollateral'], False) assert_equal(check_info['isBalanceEnough'], True) check_info = client.check_balance_against_transaction( addr2, contract_addr, gas, gas_price, storage_limit=10**18) assert_equal(check_info['willPayTxFee'], False) assert_equal(check_info['willPayCollateral'], True) assert_equal(check_info['isBalanceEnough'], True) # addr2 create 2 keys with privilege, and storage limit is 1, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[2, 4], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 2) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc - collateral_per_storage_key * 2) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - charged_of_huge_gas(gas)) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # addr2 create 13 keys with privilege, and storage limit is 0, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[4, 17], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=0) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc - collateral_per_storage_key * 13) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - charged_of_huge_gas(gas)) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # now sponsor_balance is unable to pay collateral for storage # the balance of addr2 is able to pay 15 collateral for storage, but not 16 assert_greater_than( collateral_per_storage_key, client.get_sponsor_balance_for_collateral(contract_addr)) assert_greater_than(collateral_per_storage_key * 16, client.get_balance(addr2)) assert_greater_than(client.get_balance(addr2), collateral_per_storage_key * 15) # addr2 create 1 keys with privilege, and storage limit is 0, should failed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[17, 18], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=0) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - gas) assert_equal(client.get_collateral_for_storage(addr2), 0) assert_equal(client.get_balance(addr2), b2) # addr2 create 1 keys with privilege, and storage limit is 2, should succeed sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_add", args=[17, 18], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 2) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 15) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - charged_of_huge_gas(gas)) assert_equal(client.get_collateral_for_storage(addr2), collateral_per_storage_key) assert_equal(client.get_balance(addr2), b2 - collateral_per_storage_key) # addr2 del 10 keys with privilege sbc = client.get_sponsor_balance_for_collateral(contract_addr) sbg = client.get_sponsor_balance_for_gas(contract_addr) b2 = client.get_balance(addr2) self.call_contract_function(contract=test_contract, name="par_del", args=[2, 12], sender_key=priv_key2, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key) assert_equal(client.get_collateral_for_storage(contract_addr), collateral_per_storage_key * 5) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sbc + collateral_per_storage_key * 10) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sbg - charged_of_huge_gas(gas)) assert_equal(client.get_collateral_for_storage(addr2), collateral_per_storage_key) assert_equal(client.get_balance(addr2), b2) # addr3 sponsor more, treat as transfer b3 = client.get_balance(addr3) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb, sender_key=priv_key3, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb * 2) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(addr3), b3 - charged_of_huge_gas(gas) - sb) # genesis sponsor with sponsor balance, should failed b0 = client.get_balance(genesis_addr) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb + 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb) assert_equal(client.get_sponsor_for_collateral(contract_addr), addr3) assert_equal(client.get_balance(genesis_addr), b0 - gas) # genesis sponsor with sponsor balance and collateral_for_storage, should succeed b0 = client.get_balance(genesis_addr) b3 = client.get_balance(addr3) cfs = client.get_collateral_for_storage(contract_addr) sb = client.get_sponsor_balance_for_collateral(contract_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_collateral", args=[Web3.toChecksumAddress(contract_addr)], value=sb + cfs + 1, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_collateral_for_storage(contract_addr), cfs) assert_equal(client.get_sponsor_balance_for_collateral(contract_addr), sb + 1) assert_equal(client.get_sponsor_for_collateral(contract_addr), genesis_addr) assert_equal(client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - sb - cfs - 1) assert_equal(client.get_balance(addr3), b3 + sb + cfs) # storage change test c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par", args=[10, 20, 30, 41], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 11 * collateral_per_storage_key) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par_add_del", args=[110, 120, 110, 120], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 10 * collateral_per_storage_key) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par_add_del", args=[210, 220, 215, 220], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 5 * collateral_per_storage_key) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par_add_del", args=[310, 320, 320, 330], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 10 * collateral_per_storage_key) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par_add_del", args=[410, 420, 409, 430], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 300) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 21 * collateral_per_storage_key) # test recurrence c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="rec", args=[510, 520, 3], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + 4 * collateral_per_storage_key) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="par_del", args=[510, 520], sender_key=self.genesis_priv_key, contract_addr=contract_addr, wait=True, storage_limit=bytes_per_key * 30) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 - 4 * collateral_per_storage_key) self.log.info("Pass")
def run_test(self): num_nodes = len(self.nodes) if self.tx_propagation_enabled: # Setup balance for each node client = RpcClient(self.nodes[0]) for i in range(num_nodes): pub_key = self.nodes[i].key addr = self.nodes[i].addr self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr), pub_key) tx = client.new_tx(value=int(default_config["TOTAL_COIN"] / (num_nodes + 1)) - 21000, receiver=encode_hex(addr), nonce=i) client.send_tx(tx) # setup monitor to report the current block count periodically cur_block_count = self.nodes[0].getblockcount() # The monitor will check the block_count of nodes[0] monitor_thread = threading.Thread(target=self.monitor, args=(cur_block_count, 100), daemon=True) monitor_thread.start() # generate blocks threads = {} rpc_times = [] for i in range(1, self.options.num_blocks + 1): wait_sec = random.expovariate(1000 / self.options.generation_period_ms) start = time.time() # find an idle node to generate block p = random.randint(0, num_nodes - 1) retry = 0 while retry < 10: pre_thread = threads.get(p) if pre_thread is not None and pre_thread.is_alive(): p = random.randint(0, num_nodes - 1) retry += 1 else: break if retry >= 10: self.log.warn( "too many nodes are busy to generate block, stop to analyze logs." ) break if self.tx_propagation_enabled: # Generate a block with the transactions in the node's local tx pool thread = SimpleGenerateThread( self.nodes, p, self.options.txs_per_block, self.options.generate_tx_data_len, self.log, rpc_times) else: # Generate a fixed-size block with fake tx thread = GenerateThread(self.nodes, p, self.options.txs_per_block, self.options.generate_tx_data_len, self.log, rpc_times) thread.start() threads[p] = thread if i % self.options.block_sync_step == 0: self.log.info("[PROGRESS] %d blocks generated async", i) elapsed = time.time() - start if elapsed < wait_sec: self.log.debug("%d generating block %.2f", p, elapsed) time.sleep(wait_sec - elapsed) else: self.log.warn("%d generating block slowly %.2f", p, elapsed) monitor_thread.join() self.sync_blocks() self.log.info("generateoneblock RPC latency: {}".format( Statistics(rpc_times, 3).__dict__)) self.log.info("Best block: {}".format( RpcClient(self.nodes[0]).best_block_hash()))
logs = client.get_logs(filter=Filter(from_block=hex(start), to_block=hex(end), address=["0x0888000000000000000000000000000000000005"], networkid=1)) print("logs=", logs) for log in logs: pos_identifier = log["topics"][1] if log["topics"][0] == REGISTER_TOPIC: bls_pub_key, vrf_pub_key = eth_abi.decode_abi(["bytes", "bytes"], decode_hex(log["data"])) pub_keys_map[pos_identifier] = (encode_hex_0x(bls_pub_key), encode_hex_0x(vrf_pub_key)) print(pub_keys_map[pos_identifier]) elif log["topics"][0] == INCREASE_STAKE_TOPIC: assert pos_identifier in pub_keys_map voting_power_map[pos_identifier] += parse_as_int(log["data"]) with open(os.path.join(cwd, "public_keys"), "w") as f: for pos_identifier in pub_keys_map.keys(): f.write(",".join([pub_keys_map[pos_identifier][0][2:], pub_keys_map[pos_identifier][1][2:], str(voting_power_map[pos_identifier])]) + "\n") cfx_block_hash = client.block_by_block_number(hex(end_block_number))["hash"] initial_seed = encode_hex(keccak(hexstr=cfx_block_hash[2:]+bitcoin_block_hash)) tg_config_gen = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../target/release/pos-genesis-tool") check_output([tg_config_gen, "frompub", "--initial-seed={}".format(initial_seed),"public_keys"], cwd=cwd) waypoint = open(os.path.join(cwd, "waypoint_config"), "r").readlines()[0] conf_file = open(os.path.join(cwd, "pos_config.yaml"), "w") conf_file.write(f""" base: #data_dir: ./pos_db role: validator waypoint: from_config: {waypoint} consensus: round_initial_timeout_ms: 60000 safety_rules: service: type: local
def run_test(self): start_p2p_connection(self.nodes) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.2) block_gen_thread.start() genesis_key = default_config["GENESIS_PRI_KEY"] tx_n = 100 gas_price = 1 shard_size = int(self.num_nodes / self.n_shard) shard_balance = [] for s in range(self.n_shard): ''' Send random transactions to this shard s ''' shard_nodes = self.nodes[s * shard_size: (s + 1) * shard_size] receiver_sk, _ = ec_random_keys() value = default_config["TOTAL_COIN"] - 21000 balance_map = {receiver_sk: value} nonce_map = {receiver_sk: 0} tx = create_transaction(pri_key=genesis_key, receiver=privtoaddr(receiver_sk), value=value, nonce=0, gas_price=gas_price) shard_nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx])) for i in range(tx_n): sender_key = random.choice(list(balance_map)) nonce = nonce_map[sender_key] if random.random() < 0.2 and balance_map[sender_key] > 21000 * 4 * tx_n: value = int(balance_map[sender_key] * 0.5) receiver_sk, _ = ec_random_keys() nonce_map[receiver_sk] = 0 balance_map[receiver_sk] = value else: value = 1 receiver_sk = random.choice(list(balance_map)) balance_map[receiver_sk] += value tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce, gas_price=gas_price) r = random.randint(0, shard_size - 1) shard_nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx])) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * 21000 self.log.info("New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk]) self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) time.sleep(random.random() / 10) for k in balance_map: self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k))) wait_until(lambda: self.check_account(k, balance_map, shard_nodes[0])) shard_balance.append(balance_map) def epochCheck(node): r = node.cfx_epochNumber() return int(r, 0) > 110 wait_until(lambda: epochCheck(self.nodes[0])) wait_until(lambda: epochCheck(self.nodes[int(self.num_nodes / self.n_shard)])) for s in range(self.n_shard): connect_nodes(self.nodes, s * shard_size - 1, s * shard_size) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes) ''' Check if the balance state of every node matches ''' success_shard = -1 # use the state of node 0 to find the winning shard for s in range(self.n_shard): balance_map = shard_balance[s] unmatch = False for k in balance_map: if not self.check_account(k, balance_map, self.nodes[0]): unmatch = True self.log.info("Final balance does not match shard %s, check next", s) break if unmatch: continue success_shard = s break assert success_shard != -1, "The final state of node 0 matches no shard state" self.log.info("Shard %s succeeds", success_shard) for i in range(1, self.num_nodes): balance_map = shard_balance[success_shard] for k in balance_map: if not self.check_account(k, balance_map, self.nodes[i]): raise AssertionError("Final balance of node {} does not match node 0, sender={}".format(i, k)) self.log.info("Pass")
def run_test(self): # Prevent easysolc from configuring the root logger to print to stderr self.log.propagate = False solc = Solc() erc20_contract = solc.get_contract_instance(source=os.path.dirname(os.path.realpath(__file__)) + "/erc20.sol", contract_name="FixedSupplyToken") start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = default_config["GENESIS_PRI_KEY"] genesis_addr = privtoaddr(genesis_key) nonce = 0 gas_price = 1 gas = 50000000 block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = {"from":Web3.toChecksumAddress(encode_hex_0x(genesis_addr)), "nonce":int_to_hex(nonce), "gas":int_to_hex(gas), "gasPrice":int_to_hex(gas_price)} raw_create = erc20_contract.constructor().buildTransaction(self.tx_conf) tx_data = decode_hex(raw_create["data"]) tx_create = create_transaction(pri_key=genesis_key, receiver=b'', nonce=nonce, gas_price=gas_price, data=tx_data, gas=gas, value=0) self.nodes[0].p2p.send_protocol_msg(Transactions(transactions=[tx_create])) self.wait_for_tx([tx_create]) self.log.info("Contract created, start transfering tokens") tx_n = 10 self.tx_conf["to"] = Web3.toChecksumAddress(encode_hex_0x(sha3_256(rlp.encode([genesis_addr, nonce]))[-20:])) nonce += 1 balance_map = {genesis_key: 1000000 * 10**18} sender_key = genesis_key all_txs = [] for i in range(tx_n): value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random()) receiver_sk, _ = ec_random_keys() balance_map[receiver_sk] = value tx_data = decode_hex(erc20_contract.functions.transfer(Web3.toChecksumAddress(encode_hex(privtoaddr(receiver_sk))), value).buildTransaction(self.tx_conf)["data"]) tx = create_transaction(pri_key=sender_key, receiver=decode_hex(self.tx_conf["to"]), value=0, nonce=nonce, gas=gas, gas_price=gas_price, data=tx_data) r = random.randint(0, self.num_nodes - 1) self.nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx])) nonce += 1 balance_map[sender_key] -= value all_txs.append(tx) self.log.info("Wait for transactions to be executed") self.wait_for_tx(all_txs) self.log.info("Check final token balance") for sk in balance_map: addr = privtoaddr(sk) assert_equal(self.get_balance(erc20_contract, addr, nonce), balance_map[sk]) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes) self.log.info("Pass")
def run_test(self): file_dir = os.path.dirname(os.path.realpath(__file__)) erc20_contract = get_contract_instance( abi_file=os.path.join(file_dir, "contracts/erc20_abi.json"), bytecode_file=os.path.join(file_dir, "contracts/erc20_bytecode.dat"), ) gas_price = 1 gas = CONTRACT_DEFAULT_GAS start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = default_config["GENESIS_PRI_KEY"] genesis_addr = encode_hex_0x(priv_to_addr(genesis_key)) nonce = 0 block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(genesis_addr), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } raw_create = erc20_contract.constructor().buildTransaction( self.tx_conf) tx_data = decode_hex(raw_create["data"]) tx_create = create_transaction(pri_key=genesis_key, receiver=b'', nonce=nonce, gas_price=gas_price, data=tx_data, gas=gas, value=0, storage_limit=1920) client = RpcClient(self.nodes[0]) c0 = client.get_collateral_for_storage(genesis_addr) client.send_tx(tx_create, True) receipt = client.get_transaction_receipt(tx_create.hash_hex()) c1 = client.get_collateral_for_storage(genesis_addr) assert_equal(c1 - c0, 1920 * 10**18 / 1024) contract_addr = receipt['contractCreated'] self.log.info("Contract " + str(contract_addr) + " created, start transferring tokens") tx_n = 10 self.tx_conf["to"] = contract_addr nonce += 1 balance_map = {genesis_key: 1000000 * 10**18} sender_key = genesis_key all_txs = [] for i in range(tx_n): value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random()) receiver_sk, _ = ec_random_keys() balance_map[receiver_sk] = value tx_data = decode_hex( erc20_contract.functions.transfer( Web3.toChecksumAddress( encode_hex(priv_to_addr(receiver_sk))), value).buildTransaction(self.tx_conf)["data"]) tx = create_transaction(pri_key=sender_key, receiver=decode_hex(self.tx_conf["to"]), value=0, nonce=nonce, gas=gas, gas_price=gas_price, data=tx_data, storage_limit=64) r = random.randint(0, self.num_nodes - 1) self.nodes[r].p2p.send_protocol_msg( Transactions(transactions=[tx])) nonce += 1 balance_map[sender_key] -= value all_txs.append(tx) self.log.info("Wait for transactions to be executed") self.wait_for_tx(all_txs) self.log.info("Check final token balance") for sk in balance_map: addr = priv_to_addr(sk) assert_equal(self.get_balance(erc20_contract, addr, nonce), balance_map[sk]) c2 = client.get_collateral_for_storage(genesis_addr) assert_equal(c2 - c1, 64 * tx_n * 10**18 / 1024) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes) self.log.info("Pass")
def run_test(self): sponsor_whitelist_contract_addr = Web3.toChecksumAddress( "0888000000000000000000000000000000000001") collateral_per_storage_key = 10**18 // 16 upper_bound = 5 * 10**7 file_dir = os.path.dirname(os.path.realpath(__file__)) control_contract_file_path = os.path.dirname( os.path.realpath(__file__)).split("/") control_contract_file_path.pop(-1) control_contract_file_path.extend( ["internal_contract", "metadata", "SponsorWhitelistControl.json"]) control_contract_file_path = "/".join(control_contract_file_path) control_contract_dict = json.loads( open(os.path.join(control_contract_file_path), "r").read()) control_contract = get_contract_instance( contract_dict=control_contract_dict) test_contract = get_contract_instance( abi_file=os.path.join( file_dir, "contracts/commission_privilege_test_abi.json"), bytecode_file=os.path.join( file_dir, "contracts/commission_privilege_test_bytecode.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = self.genesis_priv_key genesis_addr = encode_hex(self.genesis_addr) self.log.info("genesis_addr={}".format(genesis_addr)) nonce = 0 gas_price = 1 gas = CONTRACT_DEFAULT_GAS block_gen_thread = BlockGenThread(self.nodes, self.log) block_gen_thread.start() self.tx_conf = { "from": Web3.toChecksumAddress(genesis_addr), "nonce": int_to_hex(nonce), "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } # Setup balance for node 0 node = self.nodes[0] client = RpcClient(node) (addr1, priv_key1) = client.rand_account() self.log.info("addr1={}".format(addr1)) tx = client.new_tx(sender=genesis_addr, priv_key=genesis_key, value=10**6, nonce=self.get_nonce(self.genesis_addr), receiver=addr1) client.send_tx(tx, True) assert_equal(client.get_balance(addr1), 10**6) # setup contract transaction = self.call_contract_function( contract=test_contract, name="constructor", args=[], sender_key=self.genesis_priv_key, storage_limit=20000) contract_addr = self.wait_for_tx([transaction], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(client.get_balance(contract_addr), 0) # sponsor the contract succeed b0 = client.get_balance(genesis_addr) self.call_contract_function( contract=control_contract, name="set_sponsor_for_gas", args=[Web3.toChecksumAddress(contract_addr), upper_bound], value=10**18, sender_key=self.genesis_priv_key, contract_addr=sponsor_whitelist_contract_addr, wait=True) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), 10**18) assert_equal(client.get_sponsor_for_gas(contract_addr), genesis_addr) assert_equal(client.get_sponsor_gas_bound(contract_addr), upper_bound) assert_equal(client.get_balance(genesis_addr), b0 - 10**18 - charged_of_huge_gas(gas)) # set privilege for addr1 b0 = client.get_balance(genesis_addr) c0 = client.get_collateral_for_storage(genesis_addr) self.call_contract_function(contract=test_contract, name="add", args=[Web3.toChecksumAddress(addr1)], sender_key=genesis_key, contract_addr=contract_addr, wait=True, check_status=True, storage_limit=64) assert_equal( client.get_balance(genesis_addr), b0 - charged_of_huge_gas(gas) - collateral_per_storage_key) assert_equal(client.get_collateral_for_storage(genesis_addr), c0 + collateral_per_storage_key) # addr1 call contract with privilege without enough cfx for gas fee sb = client.get_sponsor_balance_for_gas(contract_addr) b1 = client.get_balance(addr1) self.call_contract_function(contract=test_contract, name="foo", args=[], sender_key=priv_key1, contract_addr=contract_addr, wait=True, check_status=True) assert_equal(client.get_balance(addr1), 10**6) assert_equal(client.get_sponsor_balance_for_gas(contract_addr), sb - charged_of_huge_gas(gas)) self.log.info("Pass")
def run_test(self): genesis_key = default_config["GENESIS_PRI_KEY"] balance_map = {genesis_key: default_config["TOTAL_COIN"]} self.log.info("Initial State: (sk:%d, addr:%s, balance:%d)", bytes_to_int(genesis_key), eth_utils.encode_hex(privtoaddr(genesis_key)), balance_map[genesis_key]) nonce_map = {genesis_key: 0} '''Check if transaction from uncommitted new address can be accepted''' tx_n = 5 receiver_sk = genesis_key gas_price = 1 for i in range(tx_n): sender_key = receiver_sk value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random()) nonce = nonce_map[sender_key] receiver_sk, _ = ec_random_keys() nonce_map[receiver_sk] = 0 balance_map[receiver_sk] = value tx = create_transaction(pri_key=sender_key, receiver=privtoaddr(receiver_sk), value=value, nonce=nonce, gas_price=gas_price) r = random.randint(0, self.num_nodes - 1) self.nodes[r].p2p.send_protocol_msg( Transactions(transactions=[tx])) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * 21000 self.log.debug( "New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk]) self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) time.sleep(random.random() / 100) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.2) block_gen_thread.start() for k in balance_map: self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k))) wait_until(lambda: self.check_account(k, balance_map)) self.log.info("Pass 1") '''Test Random Transactions''' all_txs = [] tx_n = 1000 self.log.info( "start to generate %d transactions with about %d seconds", tx_n, tx_n / 100 / 2) for i in range(tx_n): sender_key = random.choice(list(balance_map)) nonce = nonce_map[sender_key] data = b'' rand_n = random.random() gas = 21000 if rand_n < 0.1 and balance_map[sender_key] > 21000 * 4 * tx_n: value = int(balance_map[sender_key] * 0.5) receiver_sk, _ = ec_random_keys() receiver = privtoaddr(receiver_sk) nonce_map[receiver_sk] = 0 balance_map[receiver_sk] = value elif rand_n > 0.9 and balance_map[sender_key] > 21000 * 4 * tx_n: value = 0 receiver = b'' data = bytes([ 96, 128, 96, 64, 82, 52, 128, 21, 97, 0, 16, 87, 96, 0, 128, 253, 91, 80, 96, 5, 96, 0, 129, 144, 85, 80, 96, 230, 128, 97, 0, 39, 96, 0, 57, 96, 0, 243, 254, 96, 128, 96, 64, 82, 96, 4, 54, 16, 96, 67, 87, 96, 0, 53, 124, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 144, 4, 128, 99, 96, 254, 71, 177, 20, 96, 72, 87, 128, 99, 109, 76, 230, 60, 20, 96, 127, 87, 91, 96, 0, 128, 253, 91, 52, 128, 21, 96, 83, 87, 96, 0, 128, 253, 91, 80, 96, 125, 96, 4, 128, 54, 3, 96, 32, 129, 16, 21, 96, 104, 87, 96, 0, 128, 253, 91, 129, 1, 144, 128, 128, 53, 144, 96, 32, 1, 144, 146, 145, 144, 80, 80, 80, 96, 167, 86, 91, 0, 91, 52, 128, 21, 96, 138, 87, 96, 0, 128, 253, 91, 80, 96, 145, 96, 177, 86, 91, 96, 64, 81, 128, 130, 129, 82, 96, 32, 1, 145, 80, 80, 96, 64, 81, 128, 145, 3, 144, 243, 91, 128, 96, 0, 129, 144, 85, 80, 80, 86, 91, 96, 0, 128, 84, 144, 80, 144, 86, 254, 161, 101, 98, 122, 122, 114, 48, 88, 32, 181, 24, 13, 149, 253, 195, 129, 48, 40, 237, 71, 246, 44, 124, 223, 112, 139, 118, 192, 219, 9, 64, 67, 245, 51, 180, 42, 67, 13, 49, 62, 21, 0, 41 ]) gas = 10000000 else: value = 1 receiver_sk = random.choice(list(balance_map)) receiver = privtoaddr(receiver_sk) balance_map[receiver_sk] += value # not enough transaction fee (gas_price * gas_limit) should not happen for now assert balance_map[sender_key] >= value + gas_price * 21000 tx = create_transaction(pri_key=sender_key, receiver=receiver, value=value, nonce=nonce, gas_price=gas_price, data=data, gas=gas) r = random.randint(0, self.num_nodes - 1) self.nodes[r].p2p.send_protocol_msg( Transactions(transactions=[tx])) all_txs.append(tx) nonce_map[sender_key] = nonce + 1 balance_map[sender_key] -= value + gas_price * gas self.log.debug( "New tx %s: %s send value %d to %s, sender balance:%d, receiver balance:%d nonce:%d", encode_hex(tx.hash), eth_utils.encode_hex(privtoaddr(sender_key))[-4:], value, eth_utils.encode_hex(privtoaddr(receiver_sk))[-4:], balance_map[sender_key], balance_map[receiver_sk], nonce) self.log.debug("Send Transaction %s to node %d", encode_hex(tx.hash), r) time.sleep(random.random() / 100) for k in balance_map: self.log.info("Account %s with balance:%s", bytes_to_int(k), balance_map[k]) for tx in all_txs: self.log.debug("Wait for tx to confirm %s", tx.hash_hex()) for i in range(3): try: retry = True while retry: try: wait_until( lambda: checktx(self.nodes[0], tx.hash_hex()), timeout=120) retry = False except CannotSendRequest: time.sleep(0.01) break except AssertionError as _: self.nodes[0].p2p.send_protocol_msg( Transactions(transactions=[tx])) if i == 2: raise AssertionError( "Tx {} not confirmed after 30 seconds".format( tx.hash_hex())) for k in balance_map: self.log.info("Check account sk:%s addr:%s", bytes_to_int(k), eth_utils.encode_hex(privtoaddr(k))) wait_until(lambda: self.check_account(k, balance_map)) block_gen_thread.stop() block_gen_thread.join() sync_blocks(self.nodes) self.log.info("Pass")