def process_call(self, call: Call, network: IconService = None): if self._network_only and network is None: raise URLException("Set network URL") try: if network is not None: response = network.call(call) else: request = { "from": Address.from_string(call.from_), "to": Address.from_string(call.to), "dataType": "call", "data": { "method": call.method } } if isinstance(call.params, dict): request["data"]["params"] = call.params response = self._query(request=request) except IconServiceBaseException as e: response = e.message return response
def _get_channel(path: str): tokens = re.split("/(?=[^/]+$)", path.rstrip('/')) if tokens[0] == '/api/v3': return tokens[1] elif tokens == ['/api', 'v3']: return '' raise URLException('Invalid URI path')
def __init__(self, base_domain_url: str, version: int, request_kwargs: dict = None): """ The initializer to be set with base domain URL and version. :param base_domain_url: base domain URL as like <scheme>://<host>:<port> :param version: version for RPC server :param request_kwargs: kwargs for setting to head of request """ if not self._validate_base_domain_url(base_domain_url): logger.error( f"While setting HTTPProvider, raised URLException because the URL is invalid. " f"URL: {base_domain_url}") raise URLException( "Invalid base domain URL. " "Valid base domain URL format is as like <scheme>://<host>:<port>." ) self._full_path_url = None self._base_domain_url = base_domain_url self._version = version self._request_kwargs = request_kwargs or {} logger.info( f"Set HTTPProvider. " f"Base domain URL: {base_domain_url}, Version: {version}, Request kwargs: {self._request_kwargs}" )
def _return_customed_response(response): if response.ok: content_as_dict = json.loads(response.content) return content_as_dict["result"] else: try: content_as_dict = json.loads(response.content) except (JSONDecodeError, KeyError): raise URLException(response.content.decode("utf-8")) else: raise JSONRPCException(content_as_dict["error"])
def __init__(self, base_domain_url: str, version: int, request_kwargs: dict = None): """ The new initializer to be set with base domain URL and version. :param base_domain_url: base domain URL as like <scheme>://<host>:<port> :param version: version for RPC server :param request_kwargs: kwargs for setting to head of request """ if not self.validate_base_domain_url(base_domain_url): raise URLException("Invalid base domain URL. " "Valid base domain URL format is as like <scheme>://<host>:<port>.") self.base_domain_url = base_domain_url self.version = version self._request_kwargs = request_kwargs or {}
def __init__(self, full_path_url: str, request_kwargs: dict = None): """ The previous initializer to be set with full path url which is only as like <scheme>://<host>/api/v3 without version. :param full_path_url: full path URL as like <scheme>://<host>:<port>/api/v3 :param request_kwargs: kwargs for setting to head of request """ warn('This initializer is deprecated and replaced with new initializer ' 'where parameters are not only endpoint but also version.') url_components = urlparse(full_path_url) if url_components.path != '/api/v3': raise URLException("Invalid full path URL. " "The only valid full path for the previous initializer is " "'<scheme>://<host>:<port>/api/v3'.") self.__init__(url_components.geturl(), int(url_components.path[-1:])) self._request_kwargs = request_kwargs or {}
def __init__(self, base_domain_url: str, version: int, request_kwargs: dict = None): """ The initializer to be set with base domain URL and version. :param base_domain_url: base domain URL as like <scheme>://<host>:<port> :param version: version for RPC server :param request_kwargs: kwargs for setting to head of request """ uri = urlparse(base_domain_url) if uri.path != '': raise URLException('Path is not allowed') self._serverUri = f'{uri.scheme}://{uri.netloc}' self._channel = '' self._version = version self._request_kwargs = request_kwargs or {} self._generate_url_map()
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 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 _return_custom_response( response: requests.Response, full_response: bool = False) -> Union[str, list, dict]: if full_response: return json.loads(response.content) if response.ok: content_as_dict = json.loads(response.content) return content_as_dict["result"] else: try: content_as_dict = json.loads(response.content) except (JSONDecodeError, KeyError): logger.exception( f"Raised URLException while returning the custom response. " f"Response content: {response.content.decode('utf-8')}") raise URLException(response.content.decode("utf-8")) else: logger.error( f"Raised JSONRPCException while returning the custom response. " f"Error message: {content_as_dict['error']}") raise JSONRPCException(content_as_dict["error"])
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