def _query(self, request: dict): response = None try: method = request['method'] if method == 'debug_estimateStep': converted_request = TypeConverter.convert( request, ParamType.INVOKE_TRANSACTION) value = self._icon_service_engine.estimate_step( converted_request) else: converted_request = TypeConverter.convert( request, ParamType.QUERY) value = self._icon_service_engine.query( method, converted_request['params']) if isinstance(value, Address): value = str(value) response = MakeResponse.make_response(value) except IconServiceBaseException as icon_e: self._log_exception(icon_e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( icon_e.code, icon_e.message) except Exception as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SERVER_ERROR, str(e)) finally: Logger.info(f'query response with {response}', ICON_INNER_LOG_TAG) return response
def test_get_balance_with_malformed_address_and_type_converter(self): empty_address = MalformedAddress.from_string('') short_address_without_hx = MalformedAddress.from_string('12341234') short_address = MalformedAddress.from_string('hx1234512345') long_address_without_hx = MalformedAddress.from_string( 'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf') long_address = MalformedAddress.from_string( 'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf' ) malformed_addresses = [ '', '12341234', 'hx1234123456', 'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf', 'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf' ] method: str = 'icx_getBalance' for address in malformed_addresses: request = {'method': method, 'params': {'address': address}} converted_request = TypeConverter.convert(request, ParamType.QUERY) self.assertEqual(method, converted_request['method']) params: dict = converted_request['params'] self.assertEqual(MalformedAddress.from_string(address), params['address']) balance: int = self._engine.query(converted_request['method'], converted_request['params']) self.assertEqual(0, balance)
def _rollback(self, request: dict) -> dict: Logger.info(tag=ICON_INNER_LOG_TAG, msg=f"_rollback() start: {request}") response = {} try: converted_params = TypeConverter.convert(request, ParamType.ROLLBACK) block_height: int = converted_params[ConstantKeys.BLOCK_HEIGHT] block_hash: bytes = converted_params[ConstantKeys.BLOCK_HASH] response: dict = self._icon_service_engine.rollback( block_height, block_hash) response = MakeResponse.make_response(response) except FatalException as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) self._close() except IconServiceBaseException as icon_e: self._log_exception(icon_e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( icon_e.code, icon_e.message) except BaseException as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) finally: Logger.info(tag=ICON_INNER_LOG_TAG, msg=f"_rollback() end: {response}") return response
def _invoke(self, request: dict): """Process transactions in a block :param request: :return: """ response = None try: params = TypeConverter.convert(request, ParamType.INVOKE) converted_block_params = params['block'] block = Block.from_dict(converted_block_params) converted_tx_requests = params['transactions'] tx_results, state_root_hash = self._icon_service_engine.invoke( block=block, tx_requests=converted_tx_requests) convert_tx_results = \ {bytes.hex(tx_result.tx_hash): tx_result.to_dict(to_camel_case) for tx_result in tx_results} results = { 'txResults': convert_tx_results, 'stateRootHash': bytes.hex(state_root_hash) } response = MakeResponse.make_response(results) except IconServiceBaseException as icon_e: self._log_exception(icon_e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( icon_e.code, icon_e.message) except Exception as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SERVER_ERROR, str(e)) finally: Logger.info(f'invoke response with {response}', ICON_INNER_LOG_TAG) return response
def test_deploy_data_convert(): content_type = 'application/zip' content = CONTENT data_from = create_address() data_to = create_address() data_value = 1 * ICX_FACTOR request = { ConstantKeys.CONTENT_TYPE: content_type, ConstantKeys.CONTENT: content, ConstantKeys.PARAMS: { ConstantKeys.FROM: str(data_from), ConstantKeys.TO: str(data_to), ConstantKeys.VALUE: hex(data_value) } } ret_params = TypeConverter.convert(request, ParamType.DEPLOY_DATA) assert content_type == ret_params[ConstantKeys.CONTENT_TYPE] assert content == ret_params[ConstantKeys.CONTENT] params = ret_params[ConstantKeys.PARAMS] assert data_from != params[ConstantKeys.FROM] assert data_to != params[ConstantKeys.TO] assert data_value != params[ConstantKeys.VALUE]
def _test_base_transaction_convert(data: dict, method: str = "icx_sendTransaction"): version = 3 timestamp = 12345 data_type = 'base' nonce = 123 request = { ConstantKeys.METHOD: method, ConstantKeys.PARAMS: { ConstantKeys.VERSION: hex(version), ConstantKeys.TIMESTAMP: hex(timestamp), ConstantKeys.NONCE: hex(nonce), ConstantKeys.DATA_TYPE: data_type, ConstantKeys.DATA: {} } } data_params = request[ConstantKeys.PARAMS][ConstantKeys.DATA] for group in data.keys(): data_params[group] = { key: hex(value) for key, value in data[group].items() } ret_params = TypeConverter.convert(request, ParamType.INVOKE_TRANSACTION) assert method == ret_params[ConstantKeys.METHOD] assert version == ret_params[ConstantKeys.PARAMS][ConstantKeys.VERSION] assert timestamp == ret_params[ConstantKeys.PARAMS][ConstantKeys.TIMESTAMP] assert nonce == ret_params[ConstantKeys.PARAMS][ConstantKeys.NONCE] assert data_type == ret_params[ConstantKeys.PARAMS][ConstantKeys.DATA_TYPE] ret_data_params = ret_params[ConstantKeys.PARAMS][ConstantKeys.DATA] for group in data.keys(): for key in data[group].keys(): assert data[group][key] == ret_data_params[group][key]
def test_icx_call_convert(self): version = 3 from_addr = create_address() to_addr = create_address(1) data_type = "call" data_method = "get_balance" data_addr = create_address() request = { ConstantKeys.VERSION: hex(version), ConstantKeys.FROM: str(from_addr), ConstantKeys.TO: str(to_addr), ConstantKeys.DATA_TYPE: data_type, ConstantKeys.DATA: { ConstantKeys.METHOD: data_method, ConstantKeys.PARAMS: { ConstantKeys.ADDRESS: str(data_addr) } } } ret_params = TypeConverter.convert(request, ParamType.ICX_CALL) self.assertEqual(version, ret_params[ConstantKeys.VERSION]) self.assertEqual(from_addr, ret_params[ConstantKeys.FROM]) self.assertEqual(to_addr, ret_params[ConstantKeys.TO]) self.assertEqual(data_type, ret_params[ConstantKeys.DATA_TYPE]) data_params = ret_params[ConstantKeys.DATA] self.assertEqual(data_method, data_params[ConstantKeys.METHOD]) data_params_params = data_params[ConstantKeys.PARAMS] self.assertNotEqual(data_addr, data_params_params[ConstantKeys.ADDRESS])
def _remove_precommit_state(self, request: dict): response = None try: converted_block_params = TypeConverter.convert( request, ParamType.WRITE_PRECOMMIT) block_height, instant_block_hash, _ = \ self._get_block_info_for_precommit_state(converted_block_params) self._icon_service_engine.remove_precommit_state( block_height, instant_block_hash) response = MakeResponse.make_response(ExceptionCode.OK) except FatalException as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) self._close() except IconServiceBaseException as icon_e: self._log_exception(icon_e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( icon_e.code, icon_e.message) except Exception as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) finally: Logger.info(f'remove_precommit_state response with {response}', ICON_INNER_LOG_TAG) return response
def test_deploy_data_convert(self): content_type = 'application/zip' content = self.content data_from = create_address() data_to = create_address() data_value = 1 * self.icx_factor request = { ConstantKeys.CONTENT_TYPE: content_type, ConstantKeys.CONTENT: content, ConstantKeys.PARAMS: { ConstantKeys.FROM: str(data_from), ConstantKeys.TO: str(data_to), ConstantKeys.VALUE: hex(data_value) } } ret_params = TypeConverter.convert(request, ParamType.DEPLOY_DATA) self.assertEqual(content_type, ret_params[ConstantKeys.CONTENT_TYPE]) self.assertEqual(content, ret_params[ConstantKeys.CONTENT]) params = ret_params[ConstantKeys.PARAMS] self.assertNotEqual(data_from, params[ConstantKeys.FROM]) self.assertNotEqual(data_to, params[ConstantKeys.TO]) self.assertNotEqual(data_value, params[ConstantKeys.VALUE])
def _write_precommit_state(self, request: dict) -> dict: Logger.info(tag=_TAG, msg=f'WRITE_PRECOMMIT_STATE Request: {request}') try: converted_params = TypeConverter.convert(request, ParamType.WRITE_PRECOMMIT) block_height: int = converted_params[ConstantKeys.BLOCK_HEIGHT] instant_block_hash: bytes = converted_params[ConstantKeys.OLD_BLOCK_HASH] block_hash = converted_params[ConstantKeys.NEW_BLOCK_HASH] Logger.info(tag=_TAG, msg=f'WRITE_PRECOMMIT_STATE: ' f'BH={block_height} ' f'instant_block_hash={bytes_to_hex(instant_block_hash)} ' f'block_hash={bytes_to_hex(block_hash)}') self._icon_service_engine.commit(block_height, instant_block_hash, block_hash) response = MakeResponse.make_response(ExceptionCode.OK) except FatalException as e: self._log_exception(e, _TAG) response = MakeResponse.make_error_response(ExceptionCode.SYSTEM_ERROR, str(e)) self._close() except IconServiceBaseException as icon_e: self._log_exception(icon_e, _TAG) response = MakeResponse.make_error_response(icon_e.code, icon_e.message) except Exception as e: self._log_exception(e, _TAG) response = MakeResponse.make_error_response(ExceptionCode.SYSTEM_ERROR, str(e)) Logger.info(tag=_TAG, msg=f'WRITE_PRECOMMIT_STATE Response: {response}') return response
def test_icx_call_convert(): version = 3 from_addr = create_address() to_addr = create_address(1) data_type = "call" data_method = "get_balance" data_addr = create_address() request = { ConstantKeys.VERSION: hex(version), ConstantKeys.FROM: str(from_addr), ConstantKeys.TO: str(to_addr), ConstantKeys.DATA_TYPE: data_type, ConstantKeys.DATA: { ConstantKeys.METHOD: data_method, ConstantKeys.PARAMS: { ConstantKeys.ADDRESS: str(data_addr) } } } ret_params = TypeConverter.convert(request, ParamType.ICX_CALL) assert version == ret_params[ConstantKeys.VERSION] assert from_addr == ret_params[ConstantKeys.FROM] assert to_addr == ret_params[ConstantKeys.TO] assert data_type == ret_params[ConstantKeys.DATA_TYPE] data_params = ret_params[ConstantKeys.DATA] assert data_method == data_params[ConstantKeys.METHOD] data_params_params = data_params[ConstantKeys.PARAMS] assert data_addr != data_params_params[ConstantKeys.ADDRESS]
def _rollback(self, request: dict) -> dict: Logger.info(tag=_TAG, msg=f"ROLLBACK Request: {request}") try: converted_params = TypeConverter.convert(request, ParamType.ROLLBACK) block_height: int = converted_params[ConstantKeys.BLOCK_HEIGHT] block_hash: bytes = converted_params[ConstantKeys.BLOCK_HASH] Logger.info( tag=_TAG, msg= f"ROLLBACK: BH={block_height} block_hash={bytes_to_hex(block_hash)}" ) response: dict = self._icon_service_engine.rollback( block_height, block_hash) response = MakeResponse.make_response(response) except FatalException as e: self._log_exception(e, _TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) self._close() except IconServiceBaseException as icon_e: self._log_exception(icon_e, _TAG) response = MakeResponse.make_error_response( icon_e.code, icon_e.message) except BaseException as e: self._log_exception(e, _TAG) response = MakeResponse.make_error_response( ExceptionCode.SYSTEM_ERROR, str(e)) Logger.info(tag=_TAG, msg=f"ROLLBACK Response: {response}") return response
def test_icx_total_supply_convert(): version = 3 request = {ConstantKeys.VERSION: hex(version)} ret_params = TypeConverter.convert(request, ParamType.ICX_GET_TOTAL_SUPPLY) assert version == ret_params[ConstantKeys.VERSION]
def test_get_stake(): address = create_address() request = { ConstantKeys.ADDRESS: str(address), } ret_params = TypeConverter.convert(request, ParamType.IISS_GET_STAKE) assert address == ret_params[ConstantKeys.ADDRESS]
def test_query_i_score(): address = create_address() request = { ConstantKeys.ADDRESS: str(address), } ret_params = TypeConverter.convert(request, ParamType.IISS_QUERY_ISCORE) assert address == ret_params[ConstantKeys.ADDRESS]
def test_get_delegation(): address = create_address() request = { ConstantKeys.ADDRESS: str(address), } ret_params = TypeConverter.convert(request, ParamType.IISS_GET_DELEGATION) assert address == ret_params[ConstantKeys.ADDRESS]
def test_set_governance_variable(): irep = 12345 request = { ConstantKeys.IREP: hex(irep), } ret_params = TypeConverter.convert(request, ParamType.IISS_SET_GOVERNANCE_VARIABLES) assert irep == ret_params[ConstantKeys.IREP]
def test_set_stake(): stake = 1 * 10 ** 18 request = { ConstantKeys.VALUE: hex(stake), } ret_params = TypeConverter.convert(request, ParamType.IISS_SET_STAKE) assert stake == ret_params[ConstantKeys.VALUE]
def test_get_prep_list(): start_rank = 10 end_rank = 20 request = { ConstantKeys.START_RANKING: hex(start_rank), ConstantKeys.END_RANKING: hex(end_rank) } ret_params = TypeConverter.convert(request, ParamType.IISS_GET_PREP_LIST) assert start_rank == ret_params[ConstantKeys.START_RANKING] assert end_rank == ret_params[ConstantKeys.END_RANKING]
def test_remove_precommit_convert(self): block_height = 1001 block_hash = create_block_hash() request = { ConstantKeys.BLOCK_HEIGHT: hex(block_height), ConstantKeys.BLOCK_HASH: bytes.hex(block_hash) } ret_params = TypeConverter.convert(request, ParamType.REMOVE_PRECOMMIT) self.assertEqual(block_height, ret_params[ConstantKeys.BLOCK_HEIGHT]) self.assertEqual(block_hash, ret_params[ConstantKeys.BLOCK_HASH])
def test_write_precommit_convert(): block_height = 1001 block_hash = create_block_hash() request = { ConstantKeys.BLOCK_HEIGHT: hex(block_height), ConstantKeys.BLOCK_HASH: bytes.hex(block_hash) } ret_params = TypeConverter.convert(request, ParamType.WRITE_PRECOMMIT) assert block_height == ret_params[ConstantKeys.BLOCK_HEIGHT] assert block_hash == ret_params[ConstantKeys.BLOCK_HASH]
def test_icx_get_balance_convert(self): version = 3 addr1 = create_address() request = { ConstantKeys.VERSION: hex(version), ConstantKeys.ADDRESS: str(addr1) } ret_params = TypeConverter.convert(request, ParamType.ICX_GET_BALANCE) self.assertEqual(version, ret_params[ConstantKeys.VERSION]) self.assertEqual(addr1, ret_params[ConstantKeys.ADDRESS])
def test_icx_get_score_api_convert(): version = 3 score_addr = create_address(1) request = { ConstantKeys.VERSION: hex(version), ConstantKeys.ADDRESS: str(score_addr) } ret_params = TypeConverter.convert(request, ParamType.ICX_GET_SCORE_API) assert version == ret_params[ConstantKeys.VERSION] assert score_addr == ret_params[ConstantKeys.ADDRESS]
def _test_account_convert(balance: int): name = 'genesis' address = create_address() request = { ConstantKeys.NAME: name, ConstantKeys.ADDRESS: str(address), ConstantKeys.BALANCE: hex(balance) } ret_params = TypeConverter.convert(request, ParamType.ACCOUNT_DATA) assert name == ret_params[ConstantKeys.NAME] assert address == ret_params[ConstantKeys.ADDRESS] assert balance == ret_params[ConstantKeys.BALANCE]
def _test_account_convert(self, balance: int): name = 'genesis' address = create_address() request = { ConstantKeys.NAME: name, ConstantKeys.ADDRESS: str(address), ConstantKeys.BALANCE: hex(balance) } ret_params = TypeConverter.convert(request, ParamType.ACCOUNT_DATA) self.assertEqual(name, ret_params[ConstantKeys.NAME]) self.assertEqual(address, ret_params[ConstantKeys.ADDRESS]) self.assertEqual(balance, ret_params[ConstantKeys.BALANCE])
def _process_transaction_in_local(self, request: dict) -> dict: params = TypeConverter.convert(request, ParamType.TRANSACTION_PARAMS_DATA) params['txHash'] = create_tx_hash() tx = { 'method': 'icx_sendTransaction', 'params': params } prev_block, tx_results = self._make_and_req_block([tx]) self._write_precommit_state(prev_block) # convert TX result as sdk style convert_transaction_result(tx_results[0]) return tx_results[0]
def _validate_transaction(self, request: dict): response = None try: converted_request = TypeConverter.convert( request, ParamType.VALIDATE_TRANSACTION) self._icon_service_engine.validate_transaction(converted_request) response = MakeResponse.make_response(ExceptionCode.OK) except IconServiceBaseException as icon_e: self._log_exception(icon_e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response(icon_e.code, icon_e.message) except Exception as e: self._log_exception(e, ICON_SERVICE_LOG_TAG) response = MakeResponse.make_error_response(ExceptionCode.SERVER_ERROR, str(e)) finally: Logger.info(f'pre_validate_check response with {response}', ICON_INNER_LOG_TAG) return response
def test_query_convert_icx_get_total_supply(): method = "icx_getTotalSupply" version = 3 request = { ConstantKeys.METHOD: method, ConstantKeys.PARAMS: { ConstantKeys.VERSION: hex(version) } } ret_params = TypeConverter.convert(request, ParamType.QUERY) assert method == ret_params[ConstantKeys.METHOD] params_params = ret_params[ConstantKeys.PARAMS] assert version == params_params[ConstantKeys.VERSION]
def test_query_convert_icx_get_total_supply(self): method = "icx_getTotalSupply" version = 3 request = { ConstantKeys.METHOD: method, ConstantKeys.PARAMS: { ConstantKeys.VERSION: hex(version) } } ret_params = TypeConverter.convert(request, ParamType.QUERY) self.assertEqual(method, ret_params[ConstantKeys.METHOD]) params_params = ret_params[ConstantKeys.PARAMS] self.assertEqual(version, params_params[ConstantKeys.VERSION])
def test_write_precommit_convert_new_format(): # newly defined interface (jira issue LC-306) block_height = 1001 old_block_hash = create_block_hash() new_block_hash = create_block_hash() request = { ConstantKeys.BLOCK_HEIGHT: hex(block_height), ConstantKeys.OLD_BLOCK_HASH: bytes.hex(old_block_hash), ConstantKeys.NEW_BLOCK_HASH: bytes.hex(new_block_hash) } ret_params = TypeConverter.convert(request, ParamType.WRITE_PRECOMMIT) assert block_height == ret_params[ConstantKeys.BLOCK_HEIGHT] assert old_block_hash == ret_params[ConstantKeys.OLD_BLOCK_HASH] assert new_block_hash == ret_params[ConstantKeys.NEW_BLOCK_HASH]