def run_test(self): file_dir = os.path.dirname(os.path.realpath(__file__)) file_path = os.path.join(file_dir, "..", "internal_contract", "metadata", "Staking.json") staking_contract_dict = json.loads(open(os.path.join(file_path), "r").read()) staking_contract = get_contract_instance(contract_dict=staking_contract_dict) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_key = default_config["GENESIS_PRI_KEY"] genesis_addr = priv_to_addr(genesis_key) 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(encode_hex_0x(genesis_addr)), "nonce":int_to_hex(nonce), "gas":int_to_hex(gas), "gasPrice":int_to_hex(gas_price), "chainId":0} total_num_blocks = 2 * 60 * 60 * 24 * 365 accumulate_interest_rate = [2 ** 80 * total_num_blocks] for _ in range(1000): accumulate_interest_rate.append(accumulate_interest_rate[-1] * ( 40000 + 1000000 * total_num_blocks) // (total_num_blocks * 1000000)) # 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) client.send_tx(tx) self.wait_for_tx([tx]) assert_equal(client.get_balance(addr), 5 * 10 ** 18) assert_equal(client.get_staking_balance(addr), 0) self.tx_conf["to"] = Web3.toChecksumAddress("0888000000000000000000000000000000000002") # deposit 10**18 tx_data = decode_hex(staking_contract.functions.deposit(10 ** 18).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) deposit_time = self.get_block_number(client, tx.hash_hex()) assert_equal(client.get_staking_balance(addr), 10 ** 18) assert_equal(client.get_balance(addr), 4 * 10 ** 18 - charged_of_huge_gas(gas)) # withdraw 5 * 10**17 balance = client.get_balance(addr) capital = 5 * 10 ** 17 tx_data = decode_hex(staking_contract.functions.withdraw(capital).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) withdraw_time = self.get_block_number(client, tx.hash_hex()) interest = capital * accumulate_interest_rate[withdraw_time] // accumulate_interest_rate[deposit_time] - capital assert_equal(client.get_staking_balance(addr), 10 ** 18 - capital) assert_equal(client.get_balance(addr), balance + capital + interest - charged_of_huge_gas(gas)) # lock 4 * 10 ** 17 until block number 100000 balance = client.get_balance(addr) tx_data = decode_hex(staking_contract.functions.vote_lock(4 * 10 ** 17, 100000).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) assert_equal(client.get_balance(addr), balance - charged_of_huge_gas(gas)) assert_equal(client.get_staking_balance(addr), 5 * 10 ** 17) # withdraw 5 * 10**17 and it should fail balance = client.get_balance(addr) capital = 5 * 10 ** 17 tx_data = decode_hex(staking_contract.functions.withdraw(capital).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) assert_equal(client.get_balance(addr), balance - gas) assert_equal(client.get_staking_balance(addr), 5 * 10 ** 17) # withdraw 10**17 + 1 and it should fail balance = client.get_balance(addr) tx_data = decode_hex(staking_contract.functions.withdraw(10 ** 17 + 1).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) assert_equal(client.get_balance(addr), balance - gas) assert_equal(client.get_staking_balance(addr), 5 * 10 ** 17) # withdraw 10**17 and it should succeed balance = client.get_balance(addr) capital = 10 ** 17 tx_data = decode_hex(staking_contract.functions.withdraw(capital).buildTransaction(self.tx_conf)["data"]) tx = client.new_tx(value=0, sender=addr, receiver=self.tx_conf["to"], gas=gas, data=tx_data, priv_key=priv_key) client.send_tx(tx) self.wait_for_tx([tx]) withdraw_time = self.get_block_number(client, tx.hash_hex()) interest = capital * accumulate_interest_rate[withdraw_time] // accumulate_interest_rate[deposit_time] - capital assert_equal(client.get_balance(addr), balance + capital + interest - charged_of_huge_gas(gas)) assert_equal(client.get_staking_balance(addr), 5 * 10 ** 17 - capital) 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): 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_0x(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 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} block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.2) block_gen_thread.start() '''Check if transaction from uncommitted new address can be accepted''' tx_n = 5 new_keys = set() gas_price = 1 for i in range(tx_n): sender_key = genesis_key receiver_sk, _ = ec_random_keys() new_keys.add(receiver_sk) value = int((balance_map[sender_key] - ((tx_n - i) * 21000 * gas_price)) * random.random()) balance_map[receiver_sk] = value nonce = nonce_map[sender_key] receiver_addr = priv_to_addr(receiver_sk) tx = create_transaction(pri_key=sender_key, receiver=receiver_addr, value=value, nonce=nonce, gas_price=gas_price) r = random.randint(0, self.num_nodes - 1) r = 0 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(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) 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)) self.log.info("Pass 1") '''Test Random Transactions''' wait_for_account_stable() for key in new_keys: nonce_map[key] = wait_for_initial_nonce_for_privkey(self.nodes[0], key) 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 storage_limit = 0 if 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 = CONTRACT_DEFAULT_GAS is_payment = False storage_limit = 200000 else: value = 1 receiver_sk = random.choice(list(balance_map)) receiver = priv_to_addr(receiver_sk) balance_map[receiver_sk] += value is_payment = True # 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, storage_limit=storage_limit) r = random.randint(0, self.num_nodes - 1) r = 0 self.nodes[r].p2p.send_protocol_msg(Transactions(transactions=[tx])) all_txs.append(tx) nonce_map[sender_key] = nonce + 1 if is_payment: balance_map[sender_key] -= value + gas_price * gas else: balance_map[sender_key] -= value + gas_price * charged_of_huge_gas(gas) 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(priv_to_addr(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")
def run_test(self): file_dir = os.path.dirname(os.path.realpath(__file__)) pay_contract = get_contract_instance( abi_file=os.path.join(file_dir, "contracts/pay_abi.json"), bytecode_file=os.path.join(file_dir, "contracts/pay_bytecode.dat"), ) control_contract_file_path =os.path.join(file_dir, "../internal_contract/metadata/AdminControl.json") control_contract_dict = json.loads(open(control_contract_file_path, "r").read()) admin_control_contract = get_contract_instance(contract_dict=control_contract_dict) 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 = CONTRACT_DEFAULT_GAS 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(client.get_balance(addr), 5000000000000000000) (addr2, priv_key2) = client.rand_account() self.log.info("addr2=%s priv_key2=%s", addr2, priv_key2) tx = client.new_tx(value=5 * 10 ** 18, receiver=addr2, nonce=self.get_nonce(genesis_addr)) client.send_tx(tx, True) assert_equal(client.get_balance(addr2), 5000000000000000000) # deploy pay contract tx = self.call_contract_function( contract=pay_contract, name="constructor", args=[], sender_key=priv_key, storage_limit=512) contract_addr = self.wait_for_tx([tx], True)[0]['contractCreated'] self.log.info("contract_addr={}".format(contract_addr)) assert_equal(client.get_collateral_for_storage(addr), 512 * 976562500000000) assert_equal(client.get_balance(contract_addr), 0) # deposit 10**18 b0 = int(node.cfx_getBalance(addr), 16) tx = self.call_contract_function( contract=pay_contract, name="recharge", args=[], sender_key=priv_key, contract_addr=contract_addr, value=10 ** 18, wait=True, check_status=True) assert_equal(client.get_balance(contract_addr), 10 ** 18) assert_equal(client.get_balance(addr), b0 - 10 ** 18 - charged_of_huge_gas(gas)) assert_equal(client.get_admin(contract_addr), addr) # transfer admin (fail) tx = self.call_contract_function( contract=admin_control_contract, name="setAdmin", args=[Web3.toChecksumAddress(contract_addr), Web3.toChecksumAddress(addr2)], sender_key=priv_key2, contract_addr=Web3.toChecksumAddress("0x0888000000000000000000000000000000000000"), wait=True, check_status=True) assert_equal(client.get_admin(contract_addr), addr) assert_equal(client.get_balance(addr2), 5 * 10 ** 18 - charged_of_huge_gas(gas)) # transfer admin (success) tx = self.call_contract_function( contract=admin_control_contract, name="setAdmin", args=[Web3.toChecksumAddress(contract_addr), Web3.toChecksumAddress(addr2)], sender_key=priv_key, contract_addr=Web3.toChecksumAddress("0x0888000000000000000000000000000000000000"), wait=True, check_status=True) assert_equal(client.get_admin(contract_addr), addr2) # destroy b0 = client.get_balance(addr) tx = self.call_contract_function( contract=admin_control_contract, name="destroy", args=[Web3.toChecksumAddress(contract_addr)], sender_key=priv_key2, contract_addr=Web3.toChecksumAddress("0x0888000000000000000000000000000000000000"), wait=True, check_status=True) assert_equal(client.get_balance(contract_addr), 0) assert_equal(client.get_balance(addr2), 6 * 10 ** 18 - charged_of_huge_gas(gas) * 2) assert_equal(client.get_collateral_for_storage(addr), 0) assert_equal(client.get_balance(addr), b0 + 512 * 976562500000000) 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 testHTLCContract(self): CONTRACT_PATH = "contracts/htlc_bytecode_new.dat" logs = self.rpc.get_logs(self.filter) l = len(logs) # construct contract object file_dir = os.path.dirname(os.path.realpath(__file__)) contract = get_contract_instance( abi_file=os.path.join(file_dir, "contracts/htlc_abi_new.json"), bytecode_file=os.path.join(file_dir, CONTRACT_PATH), ) # deploy contract data = contract.constructor().buildTransaction(self.tx_conf)["data"] receipt, contractAddr = self.deploy_contract(self.sender, self.priv_key, data, storage_limit=4785) tx_hash = receipt['transactionHash'] contractAddr = Web3.toChecksumAddress(contractAddr) self.tx_conf["to"] = contractAddr logs = self.rpc.get_logs(self.filter) assert_equal(len(logs), l + 1) assert_equal(logs[-1]["topics"][1], self.address_to_topic(self.sender)) assert_equal(logs[-1]["topics"][2], self.number_to_topic(16)) # call getNow() data = contract.functions.getNow().buildTransaction( self.tx_conf)["data"] result = self.rpc.call(contractAddr, data) assert (int(result, 0) - int(time.time()) < 5) b0 = self.rpc.get_balance(self.sender) c0 = self.rpc.get_collateral_for_storage(self.sender) gas = CONTRACT_DEFAULT_GAS # interact with newContract(), sender send conflux to himself time_lock = int(time.time()) + 7200 data = contract.functions.newContract( self.sender_checksum, self.problem, time_lock).buildTransaction(self.tx_conf)["data"] cost = 5000000000000000000 result = self.call_contract(self.sender, self.priv_key, contractAddr, data, cost, storage_limit=320, gas=gas) logs = self.rpc.get_logs(self.filter) c1 = self.rpc.get_collateral_for_storage(self.sender) assert_equal(len(logs), l + 2) assert_equal(self.rpc.get_balance(contractAddr), cost) assert_equal(self.rpc.get_balance(self.sender), b0 - cost - charged_of_huge_gas(gas) - (c1 - c0)) contract_id = logs[-1]["topics"][1] # call getContract cid0 = contract_id data = contract.functions.getContract(contract_id).buildTransaction( self.tx_conf)["data"] result = self.rpc.call(contractAddr, data) result = result[2:] res = ['0x' + result[i * 64:(i + 1) * 64] for i in range(8)] assert_equal(res[0][-20:], self.sender[-20:]) assert_equal(res[1][-20:], self.sender[-20:]) assert_equal(int(res[2], 0), cost) assert_equal(res[3], self.problem) assert_equal(int(res[4], 0), time_lock) assert_equal(int(res[5], 0), 0) assert_equal(int(res[6], 0), 0) assert_equal(int(res[7], 0), 0) # interact with withdraw() data = contract.functions.withdraw( contract_id, self.solution).buildTransaction(self.tx_conf)["data"] result = self.call_contract(self.sender, self.priv_key, contractAddr, data, storage_limit=128) assert_equal(self.rpc.get_balance(contractAddr), 0) c2 = self.rpc.get_collateral_for_storage(self.sender) assert_equal(c2 - c1, 125000000000000000) assert_equal(self.rpc.get_balance(self.sender), b0 - charged_of_huge_gas(gas) * 2 - (c2 - c0)) logs = self.rpc.get_logs(self.filter) assert_equal(len(logs), l + 3) # call getContract data = contract.functions.getContract(contract_id).buildTransaction( self.tx_conf)["data"] result = self.rpc.call(contractAddr, data) result = result[2:] res = ['0x' + result[i * 64:(i + 1) * 64] for i in range(8)] assert_equal(res[0][-20:], self.sender[-20:]) assert_equal(res[1][-20:], self.sender[-20:]) assert_equal(int(res[2], 0), cost) assert_equal(res[3], self.problem) assert_equal(int(res[4], 0), time_lock) assert_equal(int(res[5], 0), 1) assert_equal(int(res[6], 0), 0) assert_equal(res[7], self.solution) receipt = self.rpc.get_transaction_receipt(tx_hash)