near-jsonrpc-client 1.0.4__py3-none-any.whl → 1.0.13__py3-none-any.whl

{client → near_jsonrpc_client}/api_methods_sync.py

@@ -8,443 +8,443 @@ that exposes `_call(...)`.
 
 from .base_client import NearBaseClientSync
 
-import models
+import near_jsonrpc_models
 
 
 class APIMixinSync:
 
 
-    def experimental_call_function(self: NearBaseClientSync, *, params: models.RpcCallFunctionRequest) -> models.RpcCallFunctionResponse:
+    def experimental_call_function(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcCallFunctionRequest) -> near_jsonrpc_models.RpcCallFunctionResponse:
         """
         Calls a view function on a contract and returns the result.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalCallFunction,
-            response_model=models.JsonRpcResponseForRpcCallFunctionResponseAndRpcCallFunctionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalCallFunction,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcCallFunctionResponseAndRpcCallFunctionError,
             params=params,
         )
 
-    def experimental_changes(self: NearBaseClientSync, *, params: models.RpcStateChangesInBlockByTypeRequest) -> models.RpcStateChangesInBlockResponse:
+    def experimental_changes(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcStateChangesInBlockByTypeRequest) -> near_jsonrpc_models.RpcStateChangesInBlockResponse:
         """
         [Deprecated] Returns changes for a given account, contract or contract code for given block height or hash. Consider using changes instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalChanges,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalChanges,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
             params=params,
         )
 
-    def experimental_changes_in_block(self: NearBaseClientSync, *, params: models.RpcStateChangesInBlockRequest) -> models.RpcStateChangesInBlockByTypeResponse:
+    def experimental_changes_in_block(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcStateChangesInBlockRequest) -> near_jsonrpc_models.RpcStateChangesInBlockByTypeResponse:
         """
         [Deprecated] Returns changes in block for given block height or hash over all transactions for all the types. Includes changes like account_touched, access_key_touched, data_touched, contract_code_touched. Consider using block_effects instead
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalChangesInBlock,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalChangesInBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
             params=params,
         )
 
-    def experimental_congestion_level(self: NearBaseClientSync, *, params: models.RpcCongestionLevelRequest) -> models.RpcCongestionLevelResponse:
+    def experimental_congestion_level(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcCongestionLevelRequest) -> near_jsonrpc_models.RpcCongestionLevelResponse:
         """
         Queries the congestion level of a shard. More info about congestion [here](https://near.github.io/nearcore/architecture/how/receipt-congestion.html?highlight=congestion#receipt-congestion)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalCongestionLevel,
-            response_model=models.JsonRpcResponseForRpcCongestionLevelResponseAndRpcChunkError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalCongestionLevel,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcCongestionLevelResponseAndRpcChunkError,
             params=params,
         )
 
-    def experimental_genesis_config(self: NearBaseClientSync) -> models.GenesisConfig:
+    def experimental_genesis_config(self: NearBaseClientSync) -> near_jsonrpc_models.GenesisConfig:
         """
         [Deprecated] Get initial state and parameters for the genesis block. Consider genesis_config instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.GenesisConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.GenesisConfigRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalGenesisConfig,
-            response_model=models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalGenesisConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
             params=params,
         )
 
-    def experimental_light_client_block_proof(self: NearBaseClientSync, *, params: models.RpcLightClientBlockProofRequest) -> models.RpcLightClientBlockProofResponse:
+    def experimental_light_client_block_proof(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcLightClientBlockProofRequest) -> near_jsonrpc_models.RpcLightClientBlockProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalLightClientBlockProof,
-            response_model=models.JsonRpcResponseForRpcLightClientBlockProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalLightClientBlockProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientBlockProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    def experimental_light_client_proof(self: NearBaseClientSync, *, params: models.RpcLightClientExecutionProofRequest) -> models.RpcLightClientExecutionProofResponse:
+    def experimental_light_client_proof(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcLightClientExecutionProofRequest) -> near_jsonrpc_models.RpcLightClientExecutionProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalLightClientProof,
-            response_model=models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalLightClientProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    def experimental_maintenance_windows(self: NearBaseClientSync, *, params: models.RpcMaintenanceWindowsRequest) -> models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
+    def experimental_maintenance_windows(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcMaintenanceWindowsRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
         """
         [Deprecated] Returns the future windows for maintenance in current epoch for the specified account. In the maintenance windows, the node will not be block producer or chunk producer. Consider using maintenance_windows instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalMaintenanceWindows,
-            response_model=models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalMaintenanceWindows,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
             params=params,
         )
 
-    def experimental_protocol_config(self: NearBaseClientSync, *, params: models.RpcProtocolConfigRequest) -> models.RpcProtocolConfigResponse:
+    def experimental_protocol_config(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcProtocolConfigRequest) -> near_jsonrpc_models.RpcProtocolConfigResponse:
         """
         A configuration that defines the protocol-level parameters such as gas/storage costs, limits, feature flags, other settings
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalProtocolConfig,
-            response_model=models.JsonRpcResponseForRpcProtocolConfigResponseAndRpcProtocolConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalProtocolConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcProtocolConfigResponseAndRpcProtocolConfigError,
             params=params,
         )
 
-    def experimental_receipt(self: NearBaseClientSync, *, params: models.RpcReceiptRequest) -> models.RpcReceiptResponse:
+    def experimental_receipt(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcReceiptRequest) -> near_jsonrpc_models.RpcReceiptResponse:
         """
         Fetches a receipt by its ID (as is, without a status or execution outcome)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalReceipt,
-            response_model=models.JsonRpcResponseForRpcReceiptResponseAndRpcReceiptError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalReceipt,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcReceiptResponseAndRpcReceiptError,
             params=params,
         )
 
-    def experimental_split_storage_info(self: NearBaseClientSync, *, params: models.RpcSplitStorageInfoRequest) -> models.RpcSplitStorageInfoResponse:
+    def experimental_split_storage_info(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcSplitStorageInfoRequest) -> near_jsonrpc_models.RpcSplitStorageInfoResponse:
         """
         Contains the split storage information. More info on split storage [here](https://near-nodes.io/archival/split-storage-archival)
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalSplitStorageInfo,
-            response_model=models.JsonRpcResponseForRpcSplitStorageInfoResponseAndRpcSplitStorageInfoError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalSplitStorageInfo,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcSplitStorageInfoResponseAndRpcSplitStorageInfoError,
             params=params,
         )
 
-    def experimental_tx_status(self: NearBaseClientSync, *, params: models.RpcTransactionStatusRequest) -> models.RpcTransactionResponse:
+    def experimental_tx_status(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcTransactionStatusRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Queries status of a transaction by hash, returning the final transaction result and details of all receipts.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalTxStatus,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalTxStatus,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    def experimental_validators_ordered(self: NearBaseClientSync, *, params: models.RpcValidatorsOrderedRequest) -> models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError:
+    def experimental_validators_ordered(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcValidatorsOrderedRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError:
         """
         Returns the current epoch validators ordered in the block producer order with repetition. This endpoint is solely used for bridge currently and is not intended for other external use cases.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalValidatorsOrdered,
-            response_model=models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalValidatorsOrdered,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfValidatorStakeViewAndRpcValidatorError,
             params=params,
         )
 
-    def experimental_view_access_key(self: NearBaseClientSync, *, params: models.RpcViewAccessKeyRequest) -> models.RpcViewAccessKeyResponse:
+    def experimental_view_access_key(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewAccessKeyRequest) -> near_jsonrpc_models.RpcViewAccessKeyResponse:
         """
         Returns information about a single access key for given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccessKey,
-            response_model=models.JsonRpcResponseForRpcViewAccessKeyResponseAndRpcViewAccessKeyError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccessKey,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccessKeyResponseAndRpcViewAccessKeyError,
             params=params,
         )
 
-    def experimental_view_access_key_list(self: NearBaseClientSync, *, params: models.RpcViewAccessKeyListRequest) -> models.RpcViewAccessKeyListResponse:
+    def experimental_view_access_key_list(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewAccessKeyListRequest) -> near_jsonrpc_models.RpcViewAccessKeyListResponse:
         """
         Returns all access keys for a given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccessKeyList,
-            response_model=models.JsonRpcResponseForRpcViewAccessKeyListResponseAndRpcViewAccessKeyListError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccessKeyList,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccessKeyListResponseAndRpcViewAccessKeyListError,
             params=params,
         )
 
-    def experimental_view_account(self: NearBaseClientSync, *, params: models.RpcViewAccountRequest) -> models.RpcViewAccountResponse:
+    def experimental_view_account(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewAccountRequest) -> near_jsonrpc_models.RpcViewAccountResponse:
         """
         Returns information about an account for given account_id.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewAccount,
-            response_model=models.JsonRpcResponseForRpcViewAccountResponseAndRpcViewAccountError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewAccount,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewAccountResponseAndRpcViewAccountError,
             params=params,
         )
 
-    def experimental_view_code(self: NearBaseClientSync, *, params: models.RpcViewCodeRequest) -> models.RpcViewCodeResponse:
+    def experimental_view_code(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewCodeRequest) -> near_jsonrpc_models.RpcViewCodeResponse:
         """
         Returns the contract code (Wasm binary) deployed to the account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewCode,
-            response_model=models.JsonRpcResponseForRpcViewCodeResponseAndRpcViewCodeError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewCode,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewCodeResponseAndRpcViewCodeError,
             params=params,
         )
 
-    def experimental_view_gas_key(self: NearBaseClientSync, *, params: models.RpcViewGasKeyRequest) -> models.RpcViewGasKeyResponse:
+    def experimental_view_gas_key(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewGasKeyRequest) -> near_jsonrpc_models.RpcViewGasKeyResponse:
         """
         Returns information about a single gas key for given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewGasKey,
-            response_model=models.JsonRpcResponseForRpcViewGasKeyResponseAndRpcViewGasKeyError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewGasKey,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewGasKeyResponseAndRpcViewGasKeyError,
             params=params,
         )
 
-    def experimental_view_gas_key_list(self: NearBaseClientSync, *, params: models.RpcViewGasKeyListRequest) -> models.RpcViewGasKeyListResponse:
+    def experimental_view_gas_key_list(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewGasKeyListRequest) -> near_jsonrpc_models.RpcViewGasKeyListResponse:
         """
         Returns all gas keys for a given account.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewGasKeyList,
-            response_model=models.JsonRpcResponseForRpcViewGasKeyListResponseAndRpcViewGasKeyListError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewGasKeyList,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewGasKeyListResponseAndRpcViewGasKeyListError,
             params=params,
         )
 
-    def experimental_view_state(self: NearBaseClientSync, *, params: models.RpcViewStateRequest) -> models.RpcViewStateResponse:
+    def experimental_view_state(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcViewStateRequest) -> near_jsonrpc_models.RpcViewStateResponse:
         """
         Returns the state (key-value pairs) of a contract based on the key prefix.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForExperimentalViewState,
-            response_model=models.JsonRpcResponseForRpcViewStateResponseAndRpcViewStateError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForExperimentalViewState,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcViewStateResponseAndRpcViewStateError,
             params=params,
         )
 
-    def block(self: NearBaseClientSync, *, params: models.RpcBlockRequest) -> models.RpcBlockResponse:
+    def block(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcBlockRequest) -> near_jsonrpc_models.RpcBlockResponse:
         """
         Returns block details for given height or hash
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForBlock,
-            response_model=models.JsonRpcResponseForRpcBlockResponseAndRpcBlockError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcBlockResponseAndRpcBlockError,
             params=params,
         )
 
-    def block_effects(self: NearBaseClientSync, *, params: models.RpcStateChangesInBlockRequest) -> models.RpcStateChangesInBlockByTypeResponse:
+    def block_effects(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcStateChangesInBlockRequest) -> near_jsonrpc_models.RpcStateChangesInBlockByTypeResponse:
         """
         Returns changes in block for given block height or hash over all transactions for all the types. Includes changes like account_touched, access_key_touched, data_touched, contract_code_touched.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForBlockEffects,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBlockEffects,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockByTypeResponseAndRpcStateChangesError,
             params=params,
         )
 
-    def broadcast_tx_async(self: NearBaseClientSync, *, params: models.RpcSendTransactionRequest) -> models.CryptoHash:
+    def broadcast_tx_async(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.CryptoHash:
         """
         [Deprecated] Sends a transaction and immediately returns transaction hash. Consider using send_tx instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForBroadcastTxAsync,
-            response_model=models.JsonRpcResponseForCryptoHashAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBroadcastTxAsync,
+            response_model=near_jsonrpc_models.JsonRpcResponseForCryptoHashAndRpcTransactionError,
             params=params,
         )
 
-    def broadcast_tx_commit(self: NearBaseClientSync, *, params: models.RpcSendTransactionRequest) -> models.RpcTransactionResponse:
+    def broadcast_tx_commit(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         [Deprecated] Sends a transaction and waits until transaction is fully complete. (Has a 10 second timeout). Consider using send_tx instead.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForBroadcastTxCommit,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForBroadcastTxCommit,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    def changes(self: NearBaseClientSync, *, params: models.RpcStateChangesInBlockByTypeRequest) -> models.RpcStateChangesInBlockResponse:
+    def changes(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcStateChangesInBlockByTypeRequest) -> near_jsonrpc_models.RpcStateChangesInBlockResponse:
         """
         Returns changes for a given account, contract or contract code for given block height or hash.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForChanges,
-            response_model=models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForChanges,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStateChangesInBlockResponseAndRpcStateChangesError,
             params=params,
         )
 
-    def chunk(self: NearBaseClientSync, *, params: models.RpcChunkRequest) -> models.RpcChunkResponse:
+    def chunk(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcChunkRequest) -> near_jsonrpc_models.RpcChunkResponse:
         """
         Returns details of a specific chunk. You can run a block details query to get a valid chunk hash.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForChunk,
-            response_model=models.JsonRpcResponseForRpcChunkResponseAndRpcChunkError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForChunk,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcChunkResponseAndRpcChunkError,
             params=params,
         )
 
-    def client_config(self: NearBaseClientSync) -> models.RpcClientConfigResponse:
+    def client_config(self: NearBaseClientSync) -> near_jsonrpc_models.RpcClientConfigResponse:
         """
         Queries client node configuration
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcClientConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcClientConfigRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForClientConfig,
-            response_model=models.JsonRpcResponseForRpcClientConfigResponseAndRpcClientConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForClientConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcClientConfigResponseAndRpcClientConfigError,
             params=params,
         )
 
-    def gas_price(self: NearBaseClientSync, *, params: models.RpcGasPriceRequest) -> models.RpcGasPriceResponse:
+    def gas_price(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcGasPriceRequest) -> near_jsonrpc_models.RpcGasPriceResponse:
         """
         Returns gas price for a specific block_height or block_hash. Using [null] will return the most recent block's gas price.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForGasPrice,
-            response_model=models.JsonRpcResponseForRpcGasPriceResponseAndRpcGasPriceError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForGasPrice,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcGasPriceResponseAndRpcGasPriceError,
             params=params,
         )
 
-    def genesis_config(self: NearBaseClientSync) -> models.GenesisConfig:
+    def genesis_config(self: NearBaseClientSync) -> near_jsonrpc_models.GenesisConfig:
         """
         Get initial state and parameters for the genesis block
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.GenesisConfigRequest.model_validate(None)
+        params = near_jsonrpc_models.GenesisConfigRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForGenesisConfig,
-            response_model=models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForGenesisConfig,
+            response_model=near_jsonrpc_models.JsonRpcResponseForGenesisConfigAndGenesisConfigError,
             params=params,
         )
 
-    def health(self: NearBaseClientSync) -> models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError:
+    def health(self: NearBaseClientSync) -> near_jsonrpc_models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError:
         """
         Returns the current health status of the RPC node the client connects to.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcHealthRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcHealthRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForHealth,
-            response_model=models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForHealth,
+            response_model=near_jsonrpc_models.JsonRpcResponseForNullableRpcHealthResponseAndRpcStatusError,
             params=params,
         )
 
-    def light_client_proof(self: NearBaseClientSync, *, params: models.RpcLightClientExecutionProofRequest) -> models.RpcLightClientExecutionProofResponse:
+    def light_client_proof(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcLightClientExecutionProofRequest) -> near_jsonrpc_models.RpcLightClientExecutionProofResponse:
         """
         Returns the proofs for a transaction execution.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForLightClientProof,
-            response_model=models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForLightClientProof,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientExecutionProofResponseAndRpcLightClientProofError,
             params=params,
         )
 
-    def maintenance_windows(self: NearBaseClientSync, *, params: models.RpcMaintenanceWindowsRequest) -> models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
+    def maintenance_windows(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcMaintenanceWindowsRequest) -> near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError:
         """
         Returns the future windows for maintenance in current epoch for the specified account. In the maintenance windows, the node will not be block producer or chunk producer.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForMaintenanceWindows,
-            response_model=models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForMaintenanceWindows,
+            response_model=near_jsonrpc_models.JsonRpcResponseForArrayOfRangeOfUint64AndRpcMaintenanceWindowsError,
             params=params,
         )
 
-    def network_info(self: NearBaseClientSync) -> models.RpcNetworkInfoResponse:
+    def network_info(self: NearBaseClientSync) -> near_jsonrpc_models.RpcNetworkInfoResponse:
         """
         Queries the current state of node network connections. This includes information about active peers, transmitted data, known producers, etc.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcNetworkInfoRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcNetworkInfoRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForNetworkInfo,
-            response_model=models.JsonRpcResponseForRpcNetworkInfoResponseAndRpcNetworkInfoError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForNetworkInfo,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcNetworkInfoResponseAndRpcNetworkInfoError,
             params=params,
         )
 
-    def next_light_client_block(self: NearBaseClientSync, *, params: models.RpcLightClientNextBlockRequest) -> models.RpcLightClientNextBlockResponse:
+    def next_light_client_block(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcLightClientNextBlockRequest) -> near_jsonrpc_models.RpcLightClientNextBlockResponse:
         """
         Returns the next light client block.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForNextLightClientBlock,
-            response_model=models.JsonRpcResponseForRpcLightClientNextBlockResponseAndRpcLightClientNextBlockError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForNextLightClientBlock,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcLightClientNextBlockResponseAndRpcLightClientNextBlockError,
             params=params,
         )
 
-    def query(self: NearBaseClientSync, *, params: models.RpcQueryRequest) -> models.RpcQueryResponse:
+    def query(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcQueryRequest) -> near_jsonrpc_models.RpcQueryResponse:
         """
         This module allows you to make generic requests to the network.  The `RpcQueryRequest` struct takes in a [`BlockReference`](https://docs.rs/near-primitives/0.12.0/near_primitives/types/enum.BlockReference.html) and a [`QueryRequest`](https://docs.rs/near-primitives/0.12.0/near_primitives/views/enum.QueryRequest.html).  The `BlockReference` enum allows you to specify a block by `Finality`, `BlockId` or `SyncCheckpoint`.  The `QueryRequest` enum provides multiple variants for performing the following actions:  - View an account's details  - View a contract's code  - View the state of an account  - View the `AccessKey` of an account  - View the `AccessKeyList` of an account  - Call a function in a contract deployed on the network.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForQuery,
-            response_model=models.JsonRpcResponseForRpcQueryResponseAndRpcQueryError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForQuery,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcQueryResponseAndRpcQueryError,
             params=params,
         )
 
-    def send_tx(self: NearBaseClientSync, *, params: models.RpcSendTransactionRequest) -> models.RpcTransactionResponse:
+    def send_tx(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcSendTransactionRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Sends transaction. Returns the guaranteed execution status and the results the blockchain can provide at the moment.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForSendTx,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForSendTx,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    def status(self: NearBaseClientSync) -> models.RpcStatusResponse:
+    def status(self: NearBaseClientSync) -> near_jsonrpc_models.RpcStatusResponse:
         """
         Requests the status of the connected RPC node. This includes information about sync status, nearcore node version, protocol version, the current set of validators, etc.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
-        params = models.RpcStatusRequest.model_validate(None)
+        params = near_jsonrpc_models.RpcStatusRequest.model_validate(None)
         return self._call(
-            request_model=models.JsonRpcRequestForStatus,
-            response_model=models.JsonRpcResponseForRpcStatusResponseAndRpcStatusError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForStatus,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcStatusResponseAndRpcStatusError,
             params=params,
         )
 
-    def tx(self: NearBaseClientSync, *, params: models.RpcTransactionStatusRequest) -> models.RpcTransactionResponse:
+    def tx(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcTransactionStatusRequest) -> near_jsonrpc_models.RpcTransactionResponse:
         """
         Queries status of a transaction by hash and returns the final transaction result.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForTx,
-            response_model=models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForTx,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcTransactionResponseAndRpcTransactionError,
             params=params,
         )
 
-    def validators(self: NearBaseClientSync, *, params: models.RpcValidatorRequest) -> models.RpcValidatorResponse:
+    def validators(self: NearBaseClientSync, *, params: near_jsonrpc_models.RpcValidatorRequest) -> near_jsonrpc_models.RpcValidatorResponse:
         """
         Queries active validators on the network. Returns details and the state of validation on the blockchain.
         High-level method: returns the result model or raises NearClientError/NearRpcError/NearHttpError.
         """
         return self._call(
-            request_model=models.JsonRpcRequestForValidators,
-            response_model=models.JsonRpcResponseForRpcValidatorResponseAndRpcValidatorError,
+            request_model=near_jsonrpc_models.JsonRpcRequestForValidators,
+            response_model=near_jsonrpc_models.JsonRpcResponseForRpcValidatorResponseAndRpcValidatorError,
             params=params,
         )

{client → near_jsonrpc_client}/base_client.py

@@ -37,6 +37,11 @@ def _parse_response(response_model: Type[BaseModel], response_json: dict):
     try:
         parsed = response_model.model_validate(response_json)
     except Exception as e:
+        print(response_json)
+
+        if response_json["result"]["error"] is not None:
+            raise ClientError(response_json["result"]["error"]) from e
+
         raise ClientError("Invalid response format") from e
 
     inner = parsed.root

{client → near_jsonrpc_client}/client.py

@@ -1,5 +1,5 @@
-from .api_methods_async import APIMixinAsync
-from .api_methods_sync import APIMixinSync
+from near_jsonrpc_client.api_methods_async import APIMixinAsync
+from near_jsonrpc_client.api_methods_sync import APIMixinSync
 from .base_client import NearBaseClientAsync, NearBaseClientSync