def call_contract_function(self, contract, name, args, sender_key, contract_addr=None, wait=False, check_status=False): # If contract address is empty, call the constructor. if contract_addr: func = getattr(contract.functions, name) else: func = getattr(contract, name) attributes = { 'nonce': self.get_nonce(privtoaddr(sender_key)), **SmartContractBenchBase.REQUEST_BASE } if contract_addr: attributes['receiver'] = decode_hex(contract_addr) attributes['to'] = contract_addr else: attributes['receiver'] = b'' tx_data = func(*args).buildTransaction(attributes) tx_data['data'] = decode_hex(tx_data['data']) tx_data['pri_key'] = sender_key tx_data['gas_price'] = tx_data['gasPrice'] tx_data.pop('gasPrice', None) tx_data.pop('chainId', None) tx_data.pop('to', None) transaction = create_transaction(**tx_data) self._send_transaction(transaction, wait, check_status) return transaction
def new_address_and_transfer(self, count=1, amount=100000000000000, wait=False, check_status=False): results = [] for _ in range(count): pri_key, pub_key = ec_random_keys() transaction = self.transfer(self.default_account_key, privtoaddr(pri_key), amount, wait, check_status) results.append([pri_key, transaction]) return results
def transfer(self, sender_key, receiver, amount, wait=False, check_status=False): nonce = self.get_nonce(privtoaddr(sender_key)) transaction = create_transaction(nonce, 1, 21000, amount, receiver, pri_key=sender_key) self._send_transaction(transaction, wait, check_status) return transaction
def run_test(self): 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"), ) staking_contract_addr = Web3.toChecksumAddress( "443c409373ffd5c0bec1dddb7bec830856757b65") self.problem = "0x2bc79b7514884ab00da924607d71542cc4fed3beb8518e747726ae30ab6c7944" self.solution = "0xc4d2751c52311d0d7efe44e5c4195e058ad5ef4bb89b3e1761b24dc277b132c2" self.priv_key = default_config["GENESIS_PRI_KEY"] self.sender = encode_hex_0x(privtoaddr(self.priv_key)) self.sender_checksum = Web3.toChecksumAddress(self.sender) self.pub = [] self.pri = [] self.rpc = RpcClient(self.nodes[0]) gas = 50000000 gas_price = 10 # lock token for genesis account self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.tx_conf['to'] = staking_contract_addr tx_data = decode_hex( staking_contract.functions.deposit( 1000000 * 10**18).buildTransaction(self.tx_conf)["data"]) tx = self.rpc.new_tx(value=0, receiver=staking_contract_addr, data=tx_data, gas=gas, gas_price=gas_price) self.rpc.send_tx(tx, True) for i in range(10): priv_key = random.randint(0, 2**256).to_bytes(32, "big") pub_key = encode_hex_0x(privtoaddr(priv_key)) self.pub.append(pub_key) self.pri.append(priv_key) transaction = self.rpc.new_tx(sender=self.sender, receiver=pub_key, value=1000000 * 10**18, priv_key=self.priv_key) self.rpc.send_tx(transaction, True) # deposit 10000 tokens tx_data = decode_hex( staking_contract.functions.deposit( 10000 * 10**18).buildTransaction(self.tx_conf)["data"]) tx = self.rpc.new_tx(value=0, sender=pub_key, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) self.rpc.send_tx(tx) self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.filter = Filter(from_epoch="earliest", to_epoch="latest_mined") self.testEventContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testBallotContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testPayContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testHTLCContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testDaiContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testMappingContract() self.tx_conf = { "from": self.sender, "gas": int_to_hex(gas), "gasPrice": int_to_hex(gas_price), "chainId": 0 } self.testDaiJoinContract() self.log.info("Pass")
def __init__(self): super().__init__() self.nonce_map = {} self.default_account_key = default_config["GENESIS_PRI_KEY"] self.default_account_address = privtoaddr(self.default_account_key)
def run_test(self): priv_key = default_config["GENESIS_PRI_KEY"] sender = eth_utils.encode_hex(privtoaddr(priv_key)) # deploy contract bytecode_file = os.path.join( os.path.dirname(os.path.realpath(__file__)), CONTRACT_PATH) assert (os.path.isfile(bytecode_file)) bytecode = open(bytecode_file).read() _, contractAddr = self.deploy_contract(sender, priv_key, bytecode) self.log.info("contract deployed") contract_epoch = hex(self.rpc[FULLNODE0].epoch_number()) # call method once receipt = self.call_contract(sender, priv_key, contractAddr, encode_hex_0x(keccak(b"foo()"))) call_epoch = hex(self.rpc[FULLNODE0].epoch_number()) # deploy another instance of the contract _, contractAddr2 = self.deploy_contract(sender, priv_key, bytecode) # call method multiple times for ii in range(0, NUM_CALLS - 3): self.call_contract(sender, priv_key, contractAddr, encode_hex_0x(keccak(b"foo()"))) # make sure we have enough blocks to be certain about the validity of previous blocks self.log.info("generating blocks...") for _ in range(50): self.generate_correct_block(FULLNODE0) self.log.info("syncing full nodes...") sync_blocks(self.nodes[FULLNODE0:FULLNODE1]) # connect light node to full nodes connect_nodes(self.nodes, LIGHTNODE, FULLNODE0) connect_nodes(self.nodes, LIGHTNODE, FULLNODE1) # make sure we all nodes are in sync self.log.info("syncing light node...") sync_blocks(self.nodes[:]) # retrieve contract code self.log.info("retrieving contract code...") self.check_code(contractAddr, contract_epoch) # apply filter, we expect a single log with 2 topics self.log.info("testing filter range...") self.check_filter( Filter(from_epoch="earliest", to_epoch=contract_epoch)) self.check_filter(Filter(from_epoch="earliest", to_epoch=call_epoch)) self.check_filter(Filter()) self.check_filter(Filter(from_epoch="0x0", to_epoch="0x0")) # apply filter for specific block, we expect a single log with 3 topics self.check_filter(Filter(block_hashes=[receipt["blockHash"]])) # apply filter for specific topics self.log.info("testing filter topics...") self.check_filter(Filter(topics=[CONSTRUCTED_TOPIC])) self.check_filter(Filter(topics=[CALLED_TOPIC])) self.check_filter(Filter(topics=[None, self.address_to_topic(sender)])) self.check_filter( Filter(topics=[ CALLED_TOPIC, None, [self.number_to_topic(3), self.number_to_topic(4)] ])) # apply filter with limit self.log.info("testing filter limit...") self.check_filter(Filter(limit=("0x%x" % (NUM_CALLS // 2)))) # apply filter for specific contract address self.log.info("testing address filtering...") self.check_filter(Filter(address=[contractAddr])) self.check_filter(Filter(address=[contractAddr2])) self.log.info("Pass")