def _set_samples(self, domain: str) -> (list, list, list, list): buf_blocks = list() buf_transactions_on_blocks = list( ) # block's transaction list which means confirmed transaction list buf_transactions = list() # return value of 'get_transaction' buf_transaction_results = list( ) # return value of 'get_transaction_result' icon_service = IconService(HTTPProvider(domain, VERSION_FOR_TEST)) target_block_heights = self._set_target_heights() for height in target_block_heights: block = icon_service.get_block(height, full_response=True) block = block['result'] buf_blocks.append(block) for transaction in block[ 'confirmed_transaction_list' if block['version'] == BLOCK_0_1A_VERSION else 'transactions']: buf_transactions_on_blocks.append(transaction) if ('tx_hash' or 'txHash') in transaction: tx_hash = transaction['tx_hash' if 'tx_hash' in transaction else 'txHash'] tx_hash = add_0x_prefix(tx_hash) tx = icon_service.get_transaction(tx_hash, full_response=True) tx = tx['result'] buf_transactions.append(tx) tx_result = icon_service.get_transaction_result( tx_hash, full_response=True) tx_result = tx_result['result'] buf_transaction_results.append(tx_result) return buf_blocks, buf_transactions_on_blocks, buf_transactions, buf_transaction_results
def get_txresults(self, network: IconService, tx_hashes: list) -> list: tx_results: list = [] for h in tx_hashes: tx_result = network.get_transaction_result(h) tx_results.append(tx_result) return tx_results
def test_integrate_converter(self): """ Test integrating for the converter which checks that all of the data about the block, transaction, and transaction result have the right format. [Purpose] Check all of the data about the block, transaction, and transaction result. [Scenario] 1. Get the last block data and validate the block data. 2. Get all of the transaction data on that block and validate the transaction data. 3. Get all of the transaction result data on that transaction and validate the transaction result data. 4. Repeatedly, get the other blocks from the last to the first and validate all of three kinds of the data. """ logger = getLogger("TEST CONVERTER") # No need to use logging, remove the line. set_logger(logger, 'DEBUG') logger.debug("TEST CONVERTER START") icon_service = IconService(HTTPProvider(TEST_HTTP_ENDPOINT_URI_V3)) # Scenario 1: Get the last block data and validate the block data. last_block_height = icon_service.get_block("latest")["height"] for height in range( 0, last_block_height if last_block_height < 30 else 30): # Scenario 2: Get all of the transaction data on that block and validate the transaction data. block = icon_service.get_block(height) # pprint.pprint(block) self.assertTrue(validate_block(block)) # Except for the genesis block if height > 0: for transaction_in_block in block[ "confirmed_transaction_list"]: # Scenario 3: Get all of the transaction result data on that transaction # and validate the transaction result data. transaction_result = icon_service.get_transaction_result( transaction_in_block["txHash"]) # logger.debug(transaction_result) # pprint.pprint(transaction_result) self.assertTrue( validate_transaction_result(transaction_result)) # Scenario 4: Repeatedly, get the other blocks from the last to the first # and validate all of three kinds of the data. transaction = icon_service.get_transaction( transaction_in_block["txHash"]) # logger.debug(transaction) # pprint.pprint(transaction) self.assertTrue(validate_transaction(transaction))
def process_transaction(self, request: SignedTransaction, network: IconService = None, block_confirm_interval: int = tbears_server_config[TbConf.BLOCK_CONFIRM_INTERVAL]) -> dict: try: if network is not None: # Send the transaction to network tx_hash = network.send_transaction(request) sleep(block_confirm_interval) # Get transaction result tx_result = network.get_transaction_result(tx_hash) else: # process the transaction in local tx_result = self._process_transaction_in_local(request.signed_transaction_dict) except IconServiceBaseException as e: tx_result = e.message return tx_result
def txresult(self, conf): """Query transaction result using given transaction hash. :param conf: txresult command configuration. :return: result of query. """ uri, version = uri_parser(conf['uri']) icon_service = IconService(HTTPProvider(uri, version)) response = icon_service.get_transaction_result(conf['hash'], True) if "error" in response: print('Got an error response') print(f"Can not get transaction \n{json.dumps(response, indent=4)}") else: print(f"Transaction : {json.dumps(response, indent=4)}") return response
def process_message_tx(self, network: IconService = None, msg: str = "dummy", block_confirm_interval: int = -1) -> dict: if self._network_only and network is None: raise URLException("Set network URL") if block_confirm_interval == -1: block_confirm_interval = self._block_confirm_interval msg_byte = msg.encode('utf-8') # build message tx transaction = MessageTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(self._test1.get_address()) \ .step_limit(10000000000) \ .nid(3) \ .nonce(100) \ .data(f"0x{msg_byte.hex()}") \ .build() # signing message tx request = SignedTransaction(transaction, self._test1) try: if network is not None: # Send the transaction to network tx_hash = network.send_transaction(request) sleep(block_confirm_interval) # Get transaction result tx_result = network.get_transaction_result(tx_hash) else: # process the transaction in local tx_results = self._process_transaction_in_local( request.signed_transaction_dict) except IconServiceBaseException as e: tx_result = e.message return tx_result
def test_integrate_converter(self): """ Test integrating for the converter which checks that all of the data about the block, transaction, and transaction result have the right format. [Purpose] Check all of the data about the block, transaction, and transaction result. [Scenario] 1. Get the last block data and validate the block data. 2. Get all of the transaction data on that block and validate the transaction data. 3. Get all of the transaction result data on that transaction and validate the transaction result data. 4. Repeatedly, get the other blocks from the last to the first and validate all of three kinds of the data. """ icon_service = IconService(HTTPProvider(BASE_DOMAIN_URL_V3_FOR_TEST, VERSION_FOR_TEST)) # Scenario 1: Get the last block data and validate the block data. last_block_height = icon_service.get_block("latest")["height"] for height in range(0, last_block_height if last_block_height < 30 else 30): # Scenario 2: Get all of the transaction data on that block and validate the transaction data. block = icon_service.get_block(height) # pprint.pprint(block) self.assertTrue(validate_block(block)) # Except for the genesis block if height > 0: for transaction_in_block in block["confirmed_transaction_list"]: # Scenario 3: Get all of the transaction result data on that transaction # and validate the transaction result data. transaction_result = icon_service.get_transaction_result(transaction_in_block["txHash"]) # logger.debug(transaction_result) # pprint.pprint(transaction_result) self.assertTrue(validate_transaction_result(transaction_result)) # Scenario 4: Repeatedly, get the other blocks from the last to the first # and validate all of three kinds of the data. transaction = icon_service.get_transaction(transaction_in_block["txHash"]) # logger.debug(transaction) # pprint.pprint(transaction) self.assertTrue(validate_transaction(transaction))
def process_transaction(self, request: SignedTransaction, network: IconService = None, block_confirm_interval: int = -1) -> dict: if self._network_only and network is None: raise URLException("Set network URL") if block_confirm_interval == -1: block_confirm_interval = self._block_confirm_interval if network is not None: # Send the transaction to network tx_hash: str = network.send_transaction(request) sleep(block_confirm_interval + 0.1) # Get transaction result tx_result: dict = network.get_transaction_result(tx_hash) else: # process the transaction in local tx_hash: str = self._process_transaction_in_local( request.signed_transaction_dict) tx_result: dict = self._get_tx_result(tx_hash) return tx_result
def process_transaction_bulk(self, requests: list, network: IconService = None, block_confirm_interval: int = -1) -> list: if self._network_only and network is None: raise URLException("Set network URL") if block_confirm_interval == -1: block_confirm_interval = self._block_confirm_interval tx_results: list = [] try: if network is not None: tx_hashes: list = [] for req in requests: # Send the transaction to network tx_hash = network.send_transaction(req) tx_hashes.append(tx_hash) sleep(block_confirm_interval) # Get transaction result for h in tx_hashes: tx_result = network.get_transaction_result(h) tx_results.append(tx_result) else: for req in requests: # process the transaction in local tx_result = self._process_transaction_in_local( req.signed_transaction_dict) tx_results.append(tx_result) except IconServiceBaseException as e: tx_result = e.message tx_results.append(tx_result) return tx_results
class TestGetterMethods(unittest.TestCase): def setUp(self): self.wallet = KeyWallet.load(keystore_path, keystore_pw) self.tester_addr = self.wallet.get_address() self.icon_service = IconService(HTTPProvider(node_uri)) def tearDown(self): pass def test_name(self): call = CallBuilder().from_(self.tester_addr)\ .to(hello_world_address)\ .method("name")\ .build() result = self.icon_service.call(call) self.assertEqual(result, 'HelloWorld') def test_hello(self): call = CallBuilder().from_(self.tester_addr)\ .to(hello_world_address)\ .method("hello")\ .build() result = self.icon_service.call(call) self.assertEqual(result, 'Hello') def test_send_token_to_ca(self): call = CallBuilder().from_(self.tester_addr)\ .to(token_address)\ .method("balanceOf")\ .params({"_owner": hello_world_address})\ .build() balance_before = self.icon_service.call(call) token_value = "0x1" transaction = CallTransactionBuilder()\ .from_(self.tester_addr)\ .to(token_address)\ .step_limit(2000000)\ .nid(network_id)\ .method("transfer")\ .params({"_to":hello_world_address, "_value":token_value})\ .build() signed_transaction = SignedTransaction(transaction, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) self.assertEqual(result['status'], 1) self.assertFalse(result['eventLogs'] is None) balance_after = self.icon_service.call(call) self.assertEqual(int(balance_before,0)+int(token_value,0), int(balance_after,0)) def test_send_icx_to_ca(self): balance_before = self.icon_service.get_balance(hello_world_address) icx_value = 1 transaction = TransactionBuilder()\ .from_(self.tester_addr)\ .to(hello_world_address)\ .value(icx_value)\ .step_limit(2000000)\ .nid(network_id)\ .build() signed_transaction = SignedTransaction(transaction, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) self.assertEqual(result['status'], 1) self.assertFalse(result['eventLogs'] is None) balance_after = self.icon_service.get_balance(hello_world_address) self.assertEqual(balance_before+icx_value, balance_after)
class TestGetterMethods(unittest.TestCase): def setUp(self): self.wallet = KeyWallet.load(keystore_path, keystore_pw) self.tester_addr = self.wallet.get_address() self.icon_service = IconService(HTTPProvider(node_uri)) def test_vote_list(self): call = CallBuilder().from_(self.tester_addr)\ .to(vote_dao_address)\ .method("vote_list")\ .build() self.icon_service.call(call) def test_add_user(self): send = CallTransactionBuilder().from_(self.tester_addr) \ .version(3) \ .step_limit(3000000000000000000000) \ .timestamp(0x573117f1d6568) \ .nid(0x3) \ .to(vote_dao_address) \ .method("add_user") \ .params({"contents": "hx8d29ac2645805452a6e921c888b23c58be862cf0"}) \ .build() signed_transaction = SignedTransaction(send, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) assert result['status'] == 0 or 1 def test_remove_user(self): send = CallTransactionBuilder().from_(self.tester_addr) \ .version(3) \ .step_limit(3000000000000000000000) \ .timestamp(0x573117f1d6568) \ .nid(0x3) \ .to(vote_dao_address) \ .method("remove_user") \ .params({"contents": "hx8d29ac2645805452a6e921c888b23c58be862cf0"}) \ .build() signed_transaction = SignedTransaction(send, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) assert result['status'] == 0 or 1 def test_ox(self): send = CallTransactionBuilder().from_(self.tester_addr) \ .version(3) \ .step_limit(3000000000000000000000) \ .timestamp(0x573117f1d6568) \ .nid(0x3) \ .to(vote_dao_address) \ .method("ox") \ .params({"contents": "tests"}) \ .build() signed_transaction = SignedTransaction(send, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) assert result['status'] == 0 or 1 def vote(self): send = CallTransactionBuilder().from_(self.tester_addr) \ .version(3) \ .step_limit(3000000000000000000000) \ .timestamp(0x573117f1d6568) \ .nid(0x3) \ .to(vote_dao_address) \ .method("vote") \ .params({"code": "O0","vote_res": "2"}) \ .build() signed_transaction = SignedTransaction(send, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) assert result['status'] == 0 or 1 def delete(self): send = CallTransactionBuilder().from_(self.tester_addr) \ .version(3) \ .step_limit(3000000000000000000000) \ .timestamp(0x573117f1d6568) \ .nid(0x3) \ .to(vote_dao_address) \ .method("delete") \ .params({"code": "O0"}) \ .build() signed_transaction = SignedTransaction(send, self.wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) sleep(10) result = self.icon_service.get_transaction_result(tx_hash) assert result['status'] == 0 or 1
class ServiceManager: def __init__(self, node_conf_path: str, wallet_path: str, passwd: str): # Node configuration to be connected with open(node_conf_path, "r") as f: node_conf = json.load(f) self._my_chain_name = node_conf["chain_name"] self._nid = int(node_conf["nid"], 16) self.web_protocol = node_conf["web_protocol"] if self.web_protocol == "ssl": self._icon_service = IconService( HTTPProvider("https://" + node_conf["address"], 3)) self._ws_block = f"wss://{node_conf['address']}/api/ws/{node_conf['channel']}" elif self.web_protocol == "http": self._icon_service = IconService( HTTPProvider("http://" + node_conf["address"], 3)) self._ws_block = f"ws://{node_conf['address']}/api/node/{node_conf['channel']}" else: print("[error] Not supported web_protocol") sys.exit() # Set wallet of actor self._wallet = KeyWallet.load(wallet_path, passwd) self._score_info = node_conf["scores"] # TODO 실제로는 없어도 되는 method def get_block(self, value=None) -> dict: block = self._icon_service.get_block(value) return block def get_rep_list(self): resp = self.query("cx0000000000000000000000000000000000000000", "getPRepTerm", {}) preps_info = resp["preps"] preps_list = [] for item in preps_info: preps_list.append(item["address"]) return preps_list def get_rep_list_local(self): node_info = f"http://localhost:9100/api/node" headers = {"content-type": "application/json"} body = {"jsonrpc": "2.0", "method": "node_getChannelInfos", "id": 1234} resp = requests.post(node_info, data=json.dumps(body), headers=headers).json() assert resp["jsonrpc"] assert resp["id"] preps_list = [] for item in resp["result"]["channel_infos"]["icon_dex"]["peers"]: preps_list.append(item["id"]) return preps_list def get_tx_result_by_hash(self, tx_hash: str) -> dict: tx_result = self._icon_service.get_transaction_result(tx_hash) for key, value in tx_result.items(): if isinstance(value, int): tx_result[key] = hex(value) try: tx_result["logsBloom"] = "0x" + tx_result["logsBloom"].hex() except KeyError: pass return tx_result def call_tx(self, score_addr: str, method: str, params: dict) -> dict: transaction = CallTransactionBuilder() \ .from_(self._wallet.get_address()) \ .to(score_addr) \ .step_limit(STEP_LIMIT) \ .nid(self._nid) \ .nonce(NONCE) \ .method(method) \ .params(params) \ .build() return self._send_transaction(transaction) def query(self, score_addr: str, method: str, params: dict): query = CallBuilder() \ .from_(self._wallet.get_address()) \ .to(score_addr) \ .method(method) \ .params(params) \ .build() return self._icon_service.call(query) def dummy_tx_send(self, loop: int): for i in range(loop): transaction = CallTransactionBuilder().\ from_(self._wallet.get_address()).\ to(self._wallet.get_address()).\ step_limit(STEP_LIMIT).\ value(1).\ nid(self.nid).\ nonce(NONCE).\ method("transfer").build() signed_tx = SignedTransaction(transaction, self._wallet) tx_hash = self.icon_service.send_transaction(signed_tx) print(f"[dc_log] dummy tx hash: {tx_hash}") def _send_transaction(self, transaction) -> dict: signed_tx = SignedTransaction(transaction, self._wallet) tx_hash = self._icon_service.send_transaction(signed_tx) sleep(SLEEP_TIMER) return self.get_tx_result_by_hash(tx_hash) @staticmethod def print_result(data: dict): print( "----------------------------------------------------------------------------------" ) print("<Tx_result>") print(f" - txHash: {data['txHash']}") print(f" - height: {data['blockHeight']}") print(f" - blockHash: {data['blockHash']}") try: print(f" - scoreAddr: {data['scoreAddress']}") except KeyError: pass print(f" - stepUsed: {data['stepUsed']}") print(f" - status: {data['status']}") print( "----------------------------------------------------------------------------------\n\n" ) @property def ws_addr(self): return self._ws_block @property def chain_name(self): return self._my_chain_name @property def nid(self): return self._nid @property def from_account(self): return self._wallet.get_address() @property def icon_service(self): return self._icon_service
class TestUcBase(unittest.TestCase): _scoreAddrOfContractRegistry = '' _scoreAddrOfStoreAgentProxy = '' _scoreAddrOfOrderAgentProxy = '' _scoreAddrOfStoreAgent = '' _scoreAddrOfOrderAgent = '' @classmethod def setUpClass(self): self._currentDirPath = path.abspath(path.dirname(__file__)) self._walletOfTest1 = KeyWallet.load( f'{self._currentDirPath}/.keystore/{TEST_KEYSTORE_TEST1}', 'test1_Account') self._walletOfUc = KeyWallet.load( f'{self._currentDirPath}/.keystore/{TEST_KEYSTORE_UC}', TEST_KEYSTORE_PW) self._walletOfProvider = KeyWallet.load( f'{self._currentDirPath}/.keystore/{TEST_KEYSTORE_PROVIDER}', TEST_KEYSTORE_PW) self._walletOfCustomer = KeyWallet.load( f'{self._currentDirPath}/.keystore/{TEST_KEYSTORE_CUSTOMER}', TEST_KEYSTORE_PW) self._iconService = IconService( HTTPProvider(TEST_HTTP_ENDPOINT_URI_V3)) def setUp(self): self._scoreAddrOfContractRegistry = self.__class__._scoreAddrOfContractRegistry self._scoreAddrOfOrderAgentProxy = self.__class__._scoreAddrOfOrderAgentProxy self._scoreAddrOfStoreAgentProxy = self.__class__._scoreAddrOfStoreAgentProxy self._scoreAddrOfOrderAgent = self.__class__._scoreAddrOfOrderAgent self._scoreAddrOfStoreAgent = self.__class__._scoreAddrOfStoreAgent def _deploy(self, _installContentBytes: bytes, _params: object) -> str: transaction = DeployTransactionBuilder()\ .from_(self._walletOfUc.get_address())\ .to('cx0000000000000000000000000000000000000000')\ .step_limit(1000000000)\ .nid(3)\ .nonce(100)\ .content_type('application/zip')\ .content(_installContentBytes)\ .params(_params)\ .build() signedTransaction = SignedTransaction(transaction, self._walletOfUc) txHash = self._iconService.send_transaction(signedTransaction) scoreAddr = '' for i in range(1, 11): sleep(1) try: txResult = self._iconService.get_transaction_result(txHash) except: continue else: break self.assertNotEqual(txResult, None) scoreAddr = txResult['scoreAddress'] self.assertNotEqual(scoreAddr, '') return scoreAddr def _sendTransaction(self, _transaction: object, _wallet: object) -> object: signedTransaction = SignedTransaction(_transaction, _wallet) txHash = self._iconService.send_transaction(signedTransaction) txResult = None for i in range(1, 11): sleep(1) try: txResult = self._iconService.get_transaction_result(txHash) except: continue else: break self.assertNotEqual(txResult, None) self.assertEqual(txResult['status'], 0x1) return txResult def _sendCall(self, _call: object) -> object: return self._iconService.call(_call) def _getBalance(self, _owner: str) -> int: return self._iconService.get_balance(_owner)
class Deployer: def __init__(self, node_conf_path: str, wallet_path: str, passwd: str): # Node configuration to be connected with open(node_conf_path, "r") as f: node_conf = json.load(f) self._my_chain_name = node_conf["chain_name"] self._nid = int(node_conf["nid"], 16) if node_conf["web_protocol"] == "ssl": self._icon_service = IconService( HTTPProvider("https://" + node_conf["address"], 3)) else: self._icon_service = IconService( HTTPProvider("http://" + node_conf["address"], 3)) print( f"--------------------------------<Connecting node>--------------------------------" ) print(f" - address : {node_conf['address']}") print(f" - chain_name : {self._my_chain_name}") print(f" - nid : {self._nid}") print( f"---------------------------------------------------------------------------------" ) # Set wallet of deployer self._wallet = KeyWallet.load(wallet_path, passwd) # print(f"pk: {self._wallet.get_private_key()}") # Set deployed score address self._score_addr = "" # It will be set after deployment self._score_path = "" self._score_params = {} self._score_info = "" def deploy_score(self) -> dict: tx_result = self._deploy_score(self._score_path, self._score_params) try: self._score_addr = tx_result["scoreAddress"] except KeyError: sys.exit() return { "deploy_txHash": tx_result["txHash"], "score_addr": self._score_addr, "info": self._score_info } def _deploy_score(self, score_path: str, params: dict) -> dict: # Make zipfile of a score # score_content = gen_deploy_data_content(score_path) shutil.make_archive("./tmp", "zip", score_path) with open("./tmp.zip", "rb") as z: score_content = z.read() os.remove("./tmp.zip") transaction = DeployTransactionBuilder() \ .from_(self._wallet.get_address()) \ .to("cx0000000000000000000000000000000000000000") \ .step_limit(STEP_LIMIT) \ .nid(self._nid) \ .nonce(NONCE) \ .content_type("application/zip") \ .content(score_content) \ .params(params) \ .build() return self._send_transaction(transaction) def _call_tx(self, score_addr: str, method: str, params: dict) -> dict: transaction = CallTransactionBuilder() \ .from_(self._wallet.get_address()) \ .to(score_addr) \ .step_limit(STEP_LIMIT) \ .nid(self._nid) \ .nonce(NONCE) \ .method(method) \ .params(params) \ .build() return self._send_transaction(transaction) def _send_transaction(self, transaction): signed_tx = SignedTransaction(transaction, self._wallet) tx_hash = self._icon_service.send_transaction(signed_tx) sleep(SLEEP_TIMER) tx_result = self._icon_service.get_transaction_result(tx_hash) self.print_result(tx_result) return tx_result @property def score_addr(self): return self._score_addr @score_addr.setter def score_addr(self, my_addr): self._score_addr = my_addr @staticmethod def print_result(data: dict): print( "-----------------------------------<Tx_result>-----------------------------------" ) print(f" - txHash: {data['txHash']}") print(f" - height: {data['blockHeight']}") try: print( f" - failure: {data['failure']['code']}.{data['failure']['message']}" ) print(f" - scoreAddr: {data['scoreAddress']}") except KeyError: pass print(f" - stepUsed: {data['stepUsed']}") print(f" - status: {data['status']}") print( "---------------------------------------------------------------------------------\n\n" )
def test_integrate_converter(self): """ Test integrating for the converter which checks that all of the data about the block, transaction, and transaction result have the right format. [Purpose] Check all of the data about the block, transaction, and transaction result. [Scenario] 1. Get the last block data and validate the block data. 2. Get all of the transaction data on that block and validate the transaction data. 3. Get all of the transaction result data on that transaction and validate the transaction result data. 4. Repeatedly, get the other blocks from the last to the first and validate all of three kinds of the data. """ test_domains = self.domains + [BASE_DOMAIN_URL_V3_FOR_TEST] max_block_height = 100 for domain in test_domains: icon_service = IconService(HTTPProvider(domain, VERSION_FOR_TEST)) last_block_height = icon_service.get_block("latest")["height"] block_versions = [BLOCK_0_1A_VERSION, BLOCK_0_3_VERSION] for block_version in block_versions: if block_version == BLOCK_0_1A_VERSION: block_template = BLOCK_0_1a key_name_of_transactions = 'confirmed_transaction_list' else: # After Mainnet apply for block 0.3, remove this remark right away. continue block_template = BLOCK_0_3 key_name_of_transactions = 'transactions' for height in range(last_block_height if last_block_height < max_block_height else max_block_height): # Check block block = icon_service.get_block(height, full_response=True, block_version=block_version) block = block['result'] converted_block = icon_service.get_block( height, block_version=block_version) block_template = get_block_template_to_convert_transactions_for_genesis( block, block_template) self.assertTrue( validate_block(block_template, block, converted_block)) if block["height"] == 0: continue for transaction_in_block in converted_block[ key_name_of_transactions]: # Check transaction result tx_result = icon_service.get_transaction_result( transaction_in_block["txHash"], True) tx_result = tx_result['result'] converted_transaction_result = icon_service.get_transaction_result( transaction_in_block["txHash"]) self.assertTrue( validate_transaction_result( TRANSACTION_RESULT, tx_result, converted_transaction_result)) # Check transaction transaction = icon_service.get_transaction( transaction_in_block["txHash"], True) transaction = transaction['result'] converted_transaction = icon_service.get_transaction( transaction_in_block["txHash"]) self.assertTrue( validate_transaction(TRANSACTION, transaction, converted_transaction))
class TestTest(IconIntegrateTestBase): TEST_HTTP_ENDPOINT_URI_V3 = "https://zicon.net.solidwallet.io/api/v3" #Address of recently deployed contract def setUp(self): super().setUp() self.contracts = {} self.contracts['sicx1'] = "cx20fa65cffc720db31e78fba6db5d58f58babd933" self.contracts['staking1'] = "cx25c39ed0d27853e44af8ab2739d6af832f35d533" self.contracts['staking2'] = "cx8b250e76bc919f73068571c26cadecde69e63b46" self.contracts['staking3'] = "cx3502e9af253098d187578ca826fe71032f116e47" # WARNING: ICON service emulation is not working with IISS. # You can stake and delegate but can't get any I-Score for reward. # If you want to test IISS stuff correctly, set self.icon_service and send requests to the network self.icon_service = IconService(HTTPProvider(self.TEST_HTTP_ENDPOINT_URI_V3)) private2="093f12dba9dc75da81ecafc88de73ef9b311b555939aeb5a875dc6ad8feef424" private3="167f6ec1694ab63243efdce98f6f6bfdcef0575cefbb86ffe3826f8373f12b85" self._test2 = KeyWallet.load(bytes.fromhex(private2)) self._test3 = KeyWallet.load(bytes.fromhex(private3)) # # If you want to send requests to the network, uncomment next line and set self.TEST_HTTP_ENDPOINT_URI_V3 @retry(JSONRPCException, tries=10, delay=1, back_off=2) def _get_tx_result(self,_tx_hash): tx_result = self.icon_service.get_transaction_result(_tx_hash) return tx_result # Sends the call request @retry(JSONRPCException, tries=10, delay=1, back_off=2) def get_tx_result(self,_call): tx_result = self.icon_service.call(_call) return tx_result def test_add_collateral(self): print('======================================================================') print('Test Add Collateral') print('----------------------------------------------------------------------') settings = [ #{'name': 'Sending 30 ICX from test_account1', 'from' : self._test1.get_address(),'value':25 * 10 ** 18, 'params' : {'_to': self._test1.get_address()},'sign':self._test1}, #{'name': 'Sending 80 ICX from test_account1', 'from' : self._test1.get_address(),'value':40 * 10 ** 18, 'params' : {'_to': self._test1.get_address()},'sign': self._test1}, {'name': 'Sending 15 ICX from test_account2', 'from' : self._test2.get_address(),'value':15 * 10 ** 18, 'params' : {'_to': self._test2.get_address()},'sign': self._test2} # {'name': 'Sending 15 ICX from test_account2', 'from' : self._test3.get_address(),'value':15 * 10 ** 18, 'params' : {'_to': self._test3.get_address()},'sign': self._test3} ] for sett in settings: print('======================================================================') print(sett['name']) print('----------------------------------------------------------------------') transaction = CallTransactionBuilder() \ .from_(sett['from']) \ .to(self.contracts['staking1']) \ .value (sett['value']) \ .step_limit(10000000) \ .nid(80) \ .nonce(100) \ .method('addCollateral') \ .params(sett['params']) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, sett['sign']) # process the transaction in zicon tx_hash = self.icon_service.send_transaction(signed_transaction) _tx_result= self._get_tx_result(tx_hash) #check Transaction result print (_tx_result) self.assertTrue('status' in _tx_result) self.assertEqual(True, _tx_result['status']) # contract_delegation_call = CallBuilder().from_(sett['from']) \ # .to(self.contracts['staking1']) \ # .method("getDelegationFromNetwork") \ # .build() # response_delegation_contract = self.get_tx_result(contract_delegation_call) # print('----------------------------------------------------------------------') # print('Delegation List from Network') # print('----------------------------------------------------------------------') # delegation_from_contract = {} # #Iterating through contract delegations # for i in response_delegation_contract["delegations"]: # delegation_from_contract[i['address']] = i['value'] # print(delegation_from_contract) # check call result # if sett['name'] == 'Test Case 1.3': # self.assertEqual(response_delegation,delegation_from_contract) # def test_update_delegation(self): # print('======================================================================') # print(' *******************Test Update Delegations***************************') # print('----------------------------------------------------------------------') # settings = [{'name': 'Test Case 1.1', 'wAddress':'staking3', 'params' : {'_user_delegations':[{'_address': 'hxc5772df538f620e1f61ef2cc3cddcea9d6ff5063', '_votes_in_per' : "50"}, # {'_address': 'hx7ce8e9c5e1ee02c6167b99b5bb4d00bdf63d0a30', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.1', 'wAddress':'staking1', "params" : {'_user_delegations':[{'_address': 'hxc5772df538f620e1f61ef2cc3cddcea9d6ff5063', '_votes_in_per' : "5"},{'_address': 'hx7ce8e9c5e1ee02c6167b99b5bb4d00bdf63d0a30', '_votes_in_per' : "10"}, # {'_address': 'hxbdc3baae0632fad453d62130d3379900a323f5b4', '_votes_in_per' : "15"}]}}, # {'name': 'Test Case 2.2', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx95248f3757afcb50efa99f529183ba401a82273c', '_votes_in_per' : "50"},{'_address': 'hx95248f3757afcb50efa99f529183ba401a82273c', '_votes_in_per' : "50"}, # {'_address': 'hxc89dfd4bf903b39ca98db905443ca9020f955e8c', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.3', 'wAddress':'staking1', 'params' : {}}, # {'name': 'Test Case 2.4', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx4917005bf4b8188b9591da520fc1c6dab8fe717f', '_votes_in_per' : "50"}, # {'_address': 'hx9a24e7a53e031ab6aa7b831b1dbe4200bd3f9483', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.5', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx8573a132f3df5c34a292fc16cb33737ffe10b367', '_votes_in_per' : "40"},{'_address': 'hx6bd3a3b1390e99194ced786725e0f0725fc1960b', '_votes_in_per' : "15"}, # {'_address': 'hx7cc2bb9d84ff3b5843f83d07818ebcff31be29e5', '_votes_in_per' : "45"}]}}, # {'name': 'Test Case 2.6', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx2d058aa34a76b2039e7cc59f18633aabd272d89f', '_votes_in_per' : "100"}]}}, # ] # for sett in settings: # print('======================================================================') # print(sett['name']) # print('----------------------------------------------------------------------') # call_transaction = CallTransactionBuilder() \ # .from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .nid(80) \ # .step_limit(10000000) \ # .nonce(100) \ # .method('updateDelegations') \ # .params(sett['params']) \ # .build() # # Returns the signed transaction object having a signature # signed_transaction = SignedTransaction(call_transaction, self._test1) # # process the transaction in zicon # tx_hash = self.icon_service.send_transaction(signed_transaction) # _tx_result= self._get_tx_result(tx_hash) # #check Transaction result # print (_tx_result) # if sett['name'] == 'Test Case 1.1' or sett['name'] == 'Test Case 2.1' or sett['name'] == 'Test Case 2.2' or sett['name'] == 'Test Case 2.3': # self.assertEqual(_tx_result,_tx_result) # else: # self.assertTrue('status' in _tx_result) # self.assertEqual(True, _tx_result['status']) # delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getPrepDelegations") \ # .build() # contract_delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getDelegationFromNetwork") \ # .build() # response_delegation = self.get_tx_result(delegation_call) # response_delegation_contract = self.get_tx_result(contract_delegation_call) # print('----------------------------------------------------------------------') # print('Delegation List') # print('----------------------------------------------------------------------') # print (response_delegation) # print('----------------------------------------------------------------------') # print('Delegation List from Network') # print('----------------------------------------------------------------------') # delegation_from_contract = {} # #Iterating through contract delegations # for i in response_delegation_contract["delegations"]: # delegation_from_contract[i['address']] = i['value'] # print(delegation_from_contract) # def test_wclaim_iscore(self): # print('======================================================================') # print(' **********************Test Claim IScore*****************************') # print('----------------------------------------------------------------------') # transaction = CallTransactionBuilder() \ # .from_(self._test1.get_address()) \ # .to(self.contracts['staking1']) \ # .step_limit(10000000) \ # .nid(80) \ # .nonce(100) \ # .method('_claim_iscore') \ # .build() # # # Returns the signed transaction object having a signature # signed_transaction = SignedTransaction(transaction, self._test1) # # # process the transaction in zicon # tx_hash = self.icon_service.send_transaction(signed_transaction) # _tx_result= self._get_tx_result(tx_hash) # print (_tx_result) # # #check Transaction result # self.assertTrue('status' in _tx_result) # self.assertEqual(True, _tx_result['status']) # contract_delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts['staking1']) \ # .method("getLifetimeReward") \ # .build() # response_delegation_contract = self.get_tx_result(contract_delegation_call) # print('----------------------------------------------------------------------') # print('Delegation List from Network') # print('----------------------------------------------------------------------') # delegation_from_contract = {} # # #Iterating through contract delegations # # for i in response_delegation_contract["delegations"]: # # delegation_from_contract[i['address']] = i['value'] # # print(delegation_from_contract) # print(response_delegation_contract) # def test_tr(self): # print('======================================================================') # print(' *******************Test Update Delegations***************************') # print('----------------------------------------------------------------------') # settings = [{'name': 'Test Case 1.1', 'wAddress':'staking3', 'params' : {'_user_delegations':[{'_address': 'hxc5772df538f620e1f61ef2cc3cddcea9d6ff5063', '_votes_in_per' : "50"}, # {'_address': 'hx7ce8e9c5e1ee02c6167b99b5bb4d00bdf63d0a30', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.1', 'wAddress':'staking1', "params" : {'_user_delegations':[{'_address': 'hxc5772df538f620e1f61ef2cc3cddcea9d6ff5063', '_votes_in_per' : "5"},{'_address': 'hx7ce8e9c5e1ee02c6167b99b5bb4d00bdf63d0a30', '_votes_in_per' : "10"}, # {'_address': 'hxbdc3baae0632fad453d62130d3379900a323f5b4', '_votes_in_per' : "15"}]}}, # {'name': 'Test Case 2.2', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx95248f3757afcb50efa99f529183ba401a82273c', '_votes_in_per' : "50"},{'_address': 'hx95248f3757afcb50efa99f529183ba401a82273c', '_votes_in_per' : "50"}, # {'_address': 'hxc89dfd4bf903b39ca98db905443ca9020f955e8c', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.3', 'wAddress':'staking1', 'params' : {}}, # {'name': 'Test Case 2.4', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx4917005bf4b8188b9591da520fc1c6dab8fe717f', '_votes_in_per' : "50"}, # {'_address': 'hx9a24e7a53e031ab6aa7b831b1dbe4200bd3f9483', '_votes_in_per' : "50"}]}}, # {'name': 'Test Case 2.5', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx8573a132f3df5c34a292fc16cb33737ffe10b367', '_votes_in_per' : "40"},{'_address': 'hx6bd3a3b1390e99194ced786725e0f0725fc1960b', '_votes_in_per' : "15"}, # {'_address': 'hx7cc2bb9d84ff3b5843f83d07818ebcff31be29e5', '_votes_in_per' : "45"}]}}, # {'name': 'Test Case 2.6', 'wAddress':'staking1', 'params' : {'_user_delegations':[{'_address': 'hx23dfce82d36268f4cc3b943fa65d4c9632d23e76', '_votes_in_per' : "100"}]}}, # ] # for sett in settings: # print('======================================================================') # print(sett['name']) # print('----------------------------------------------------------------------') # call_transaction = CallTransactionBuilder() \ # .from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .nid(80) \ # .step_limit(10000000) \ # .nonce(100) \ # .method('updateDelegations') \ # .params(sett['params']) \ # .build() # # Returns the signed transaction object having a signature # signed_transaction = SignedTransaction(call_transaction, self._test1) # # process the transaction in zicon # tx_hash = self.icon_service.send_transaction(signed_transaction) # _tx_result= self._get_tx_result(tx_hash) # #check Transaction result # print (_tx_result) # if sett['name'] == 'Test Case 1.1' or sett['name'] == 'Test Case 2.1' or sett['name'] == 'Test Case 2.2' or sett['name'] == 'Test Case 2.3': # self.assertEqual(_tx_result,_tx_result) # else: # self.assertTrue('status' in _tx_result) # self.assertEqual(True, _tx_result['status']) # delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getPrepDelegations") \ # .build() # contract_delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getDelegationFromNetwork") \ # .build() # response_delegation = self.get_tx_result(delegation_call) # response_delegation_contract = self.get_tx_result(contract_delegation_call) # print('----------------------------------------------------------------------') # print('Delegation List') # print('----------------------------------------------------------------------') # print (response_delegation) # print('----------------------------------------------------------------------') # print('Delegation List from Network') # print('----------------------------------------------------------------------') # delegation_from_contract = {} # #Iterating through contract delegations # for i in response_delegation_contract["delegations"]: # delegation_from_contract[i['address']] = i['value'] # print(delegation_from_contract) # def test_unstake(self): # print('======================================================================') # print('Test Unstake') # print('----------------------------------------------------------------------') # data = "{\"method\": \"unstake\"}".encode("utf-8") # settings = [ # # {'name': 'Test Case 1.1', 'from' : self._test1.get_address(), 'wAddress':'sicx1', 'params' : {'_to': self.contracts['staking1'],'_value': 20 * 10**18,'_data':data},'sign': self._test1,'delegation_address':'staking1'}, # {'name': 'Test Case 1.2', 'from' : self._test2.get_address(), 'wAddress':'sicx1', 'params' : {'_to': self.contracts['staking1'], '_value': 20 * 10**18,'_data':data},'sign': self._test2,'delegation_address':'staking1'}, # ] # for sett in settings: # print('======================================================================') # print(sett['name']) # print('----------------------------------------------------------------------') # transaction = CallTransactionBuilder() \ # .from_(sett['from']) \ # .to(self.contracts[sett['wAddress']]) \ # .step_limit(10000000) \ # .nid(80) \ # .nonce(100) \ # .method('transfer') \ # .params(sett['params']) \ # .build() # # Returns the signed transaction object having a signature # signed_transaction = SignedTransaction(transaction, sett['sign']) # # process the transaction in zicon # tx_hash = self.icon_service.send_transaction(signed_transaction) # _tx_result= self._get_tx_result(tx_hash) # #check Transaction result # print (_tx_result) # self.assertTrue('status' in _tx_result) # self.assertEqual(True, _tx_result['status']) # # Address =[self._test1.get_address(),self._test2.get_address()] # # for test in Address: # # contract_delegation_call = CallBuilder().from_(test) \ # # .to(self.contracts[sett['delegation_address']]) \ # # .method("getDelegationFromNetwork") \ # # .build() # # response_delegation_contract = self.get_tx_result(contract_delegation_call) # # print('----------------------------------------------------------------------') # # print('Delegation List from Network') # # print('----------------------------------------------------------------------') # # delegation_from_contract = {} # # #Iterating through contract delegations # # for i in response_delegation_contract["delegations"]: # # delegation_from_contract[i['address']] = i['value'] # # print(delegation_from_contract) # # check call result # # if sett['name'] == 'Test Case 1.3': # # self.assertEqual(response_delegation,delegation_from_contract) # def test_send_ICX(self): # print('======================================================================') # print('Test Send ICX') # print('----------------------------------------------------------------------') # settings = [ # {'name': 'Test Case 1.1', 'from' : self._test1.get_address(), 'wAddress':'staking1', 'params' : {'_to': self._test2.get_address(),'_value': 800 }} # ] # for sett in settings: # print('======================================================================') # print(sett['name']) # print('----------------------------------------------------------------------') # call_transaction = CallTransactionBuilder() \ # .from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .nid(80) \ # .step_limit(10000000) \ # .nonce(100) \ # .method('_send_ICX') \ # .params(sett['params']) \ # .build() # # Returns the signed transaction object having a signature # signed_transaction = SignedTransaction(call_transaction, self._test1) # # process the transaction in zicon # tx_hash = self.icon_service.send_transaction(signed_transaction) # _tx_result= self._get_tx_result(tx_hash) # #check Transaction result # print (_tx_result) # self.assertTrue('status' in _tx_result) # self.assertEqual(True, _tx_result['status']) # delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getPrepDelegations") \ # .build() # contract_delegation_call = CallBuilder().from_(self._test1.get_address()) \ # .to(self.contracts[sett['wAddress']]) \ # .method("getDelegationFromNetwork") \ # .build() # response_delegation = self.get_tx_result(delegation_call) # response_delegation_contract = self.get_tx_result(contract_delegation_call) # print('----------------------------------------------------------------------') # print('Delegation List') # print('----------------------------------------------------------------------') # print (response_delegation) # print('----------------------------------------------------------------------') # print('Delegation List from Network') # print('----------------------------------------------------------------------') # delegation_from_contract = {} # #Iterating through contract delegations # for i in response_delegation_contract["delegations"]: # delegation_from_contract[i['address']] = i['value'] # print(delegation_from_contract) def test_lifeTime(self): print('======================================================================') print('getLifetimeReward') print('----------------------------------------------------------------------') _call = CallBuilder().from_(self._test1.get_address()) \ .to(self.contracts['staking1']) \ .method("getLifetimeReward") \ .build() response = self.get_tx_result(_call) # check call result print (response) def test_getRate(self): print('======================================================================') print('Test getRate ') print('----------------------------------------------------------------------') _call = CallBuilder().from_(self._test1.get_address()) \ .to(self.contracts['staking1']) \ .method("getRate") \ .build() response = self.get_tx_result(_call) # check call result print (response) def test_getTodayRate(self): print('======================================================================') print('Test getTodayRate') print('----------------------------------------------------------------------') _call = CallBuilder().from_(self._test1.get_address()) \ .to(self.contracts['staking1']) \ .method("getTodayRate") \ .build() response = self.get_tx_result(_call) # check call result print (response)
class IconNetwork: def __init__(self, endpoint, network_id): self.endpoint = endpoint self.network_id = network_id self.icon_service = IconService(HTTPProvider(endpoint, network_id)) def get_max_step_limit(self, wallet_address): params = {'contextType': 'invoke'} call_data = CallBuilder() \ .from_(wallet_address) \ .to(GOVERNANCE_ADDRESS) \ .method('getMaxStepLimit') \ .params(params) \ .build() result = self.icon_service.call(call_data) return convert_hex_str_to_int(result) def deploy_contract(self, contract_info, account_info): wallet = KeyWallet.load(bytes.fromhex(account_info['wallet_key'])) contract_content_bytes = gen_deploy_data_content( contract_info['contract_file']) deploy_transaction = DeployTransactionBuilder() \ .from_(wallet.get_address()) \ .to(SCORE_INSTALL_ADDRESS) \ .step_limit(self.get_max_step_limit(wallet.get_address())) \ .nid(self.network_id) \ .nonce(self.network_id) \ .content_type('application/zip') \ .content(contract_content_bytes) \ .params(contract_info['params']) \ .version(self.network_id) \ .build() signed_transaction = SignedTransaction(deploy_transaction, wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) # print('tx_hash:', tx_hash) tx_result = self.get_transaction_result(tx_hash) return tx_result def get_transaction_result(self, tx_hash): max_retries = 10 retry_count = 0 sleep_seconds = 5 tx_result = None while retry_count < max_retries: tx_result = self.get_transaction_result_once(tx_hash) if None != tx_result: retry_count = max_retries else: retry_count += 1 # print('Retrying {0} in {1} seconds'.format(retry_count, sleep_seconds)) time.sleep(sleep_seconds) # tx_result might be still None if all retries failed. return tx_result def get_transaction_result_once(self, tx_hash): try: tx_result = self.icon_service.get_transaction_result(tx_hash) # print('tx_result:', tx_result) return tx_result except: error = sys.exc_info() # print('get_transaction_result error:', error[1]) return None def read_data(self, contract_address, table_name, wallet_key, params): wallet = KeyWallet.load(bytes.fromhex(wallet_key)) call_data = CallBuilder() \ .from_(wallet.get_address()) \ .to(contract_address) \ .method('get' + table_name) \ .params(params) \ .build() result = self.icon_service.call(call_data) return result def write_data(self, contract_address, action_name, wallet_key, params): wallet = KeyWallet.load(bytes.fromhex(wallet_key)) call_transaction = CallTransactionBuilder() \ .from_(wallet.get_address()) \ .to(contract_address) \ .step_limit(self.get_max_step_limit(wallet.get_address())) \ .nid(self.network_id) \ .nonce(self.network_id) \ .method(action_name) \ .params(params) \ .build() signed_transaction = SignedTransaction(call_transaction, wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) # print('tx_hash:', tx_hash) tx_result = self.get_transaction_result(tx_hash) return tx_result def create_data(self, contract_address, table_name, wallet_key, data): return self.write_data(contract_address, 'cre' + table_name, wallet_key, data) def update_data(self, contract_address, table_name, wallet_key, data): return self.write_data(contract_address, 'upd' + table_name, wallet_key, data) def delete_data(self, contract_address, table_name, wallet_key, data): return self.write_data(contract_address, 'del' + table_name, wallet_key, data)
class RPCmanager(object): def __init__(self, _conf_rpc: dict) -> None: # Key Wallet with Password self.key_wallet = KeyWallet.load(_conf_rpc["KeyWallet"]["File"], _conf_rpc["KeyWallet"]["Password"]) # Service Endpoint (URL) self.service_endpoint = IconService( HTTPProvider(_conf_rpc["Service Endpoint"])) # Smart Contract Address self.id_contract_address = _conf_rpc["ID Contract Address"] self.ptm_contract_address = _conf_rpc["PTM Contract Address"] self.pgm_contract_address = _conf_rpc["PGM Contract Address"] # Network ID self.nid = int(_conf_rpc["Network ID"]) def getMethod(self, _method: dict, type: str) -> str: if type == "DIR": contract_address = self.id_contract_address elif type == "PTM": contract_address = self.ptm_contract_address elif type == "PGM": contract_address = self.pgm_contract_address else: print("Not supported contract type") pass call = CallBuilder() \ .from_(self.key_wallet.get_address()) \ .to(contract_address) \ .method(_method["name"]) \ .params(_method["params"]) \ .build() result = self.service_endpoint.call(call) print(result) return result def setMethod(self, _method: dict, type: str) -> dict: result = {} if type == "DIR": contract_address = self.id_contract_address elif type == "PTM": contract_address = self.ptm_contract_address elif type == "PGM": contract_address = self.pgm_contract_address else: print("Not supported contract type") result["status"] = "failure" result["message"] = "" return result if not _method.__contains__("params"): _method["params"] = "" transaction = CallTransactionBuilder() \ .from_(self.key_wallet.get_address()) \ .to(contract_address) \ .step_limit(10000000) \ .nid(self.nid) \ .method(_method["name"]) \ .params(_method["params"]) \ .build() # sign the transaction with key wallet signed_tx = SignedTransaction(transaction, self.key_wallet) # commit(send) the signed transaction to the service endpoint tx_hash = self.service_endpoint.send_transaction(signed_tx) sleep(3) # wait a second for the transaction to be finalized tx_result = self.service_endpoint.get_transaction_result(tx_hash) print(tx_result) if "failure" in tx_result: result["status"] = "failure" result["message"] = tx_result["failure"] else: result["status"] = "success" result["message"] = tx_result["eventLogs"][0]["data"] return result