near-jsonrpc-client 1.0.5__py3-none-any.whl

near_jsonrpc_models/current_epoch_validator_info.py

@@ -0,0 +1,35 @@
+"""Describes information about the current epoch validator"""
+
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.near_token import NearToken
+from near_jsonrpc_models.public_key import PublicKey
+from near_jsonrpc_models.shard_id import ShardId
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import conint
+from typing import List
+
+
+class CurrentEpochValidatorInfo(BaseModel):
+    account_id: AccountId
+    is_slashed: bool
+    num_expected_blocks: conint(ge=0, le=18446744073709551615)
+    num_expected_chunks: conint(ge=0, le=18446744073709551615) = 0
+    # Number of chunks this validator was expected to produce in each shard.
+    # Each entry in the array corresponds to the shard in the `shards_produced` array.
+    num_expected_chunks_per_shard: List[conint(ge=0, le=18446744073709551615)] = Field(default_factory=lambda: [])
+    num_expected_endorsements: conint(ge=0, le=18446744073709551615) = 0
+    # Number of chunks this validator was expected to validate and endorse in each shard.
+    # Each entry in the array corresponds to the shard in the `shards_endorsed` array.
+    num_expected_endorsements_per_shard: List[conint(ge=0, le=18446744073709551615)] = Field(default_factory=lambda: [])
+    num_produced_blocks: conint(ge=0, le=18446744073709551615)
+    num_produced_chunks: conint(ge=0, le=18446744073709551615) = 0
+    num_produced_chunks_per_shard: List[conint(ge=0, le=18446744073709551615)] = Field(default_factory=lambda: [])
+    num_produced_endorsements: conint(ge=0, le=18446744073709551615) = 0
+    num_produced_endorsements_per_shard: List[conint(ge=0, le=18446744073709551615)] = Field(default_factory=lambda: [])
+    public_key: PublicKey
+    # Shards this validator is assigned to as chunk producer in the current epoch.
+    shards: List[ShardId]
+    # Shards this validator is assigned to as chunk validator in the current epoch.
+    shards_endorsed: List[ShardId] = Field(default_factory=lambda: [ShardId(**item) for item in []])
+    stake: NearToken

near_jsonrpc_models/data_receipt_creation_config_view.py

@@ -0,0 +1,20 @@
+"""The fees settings for a data receipt creation"""
+
+from near_jsonrpc_models.fee import Fee
+from pydantic import BaseModel
+
+
+class DataReceiptCreationConfigView(BaseModel):
+    # Base cost of creating a data receipt.
+    # Both `send` and `exec` costs are burned when a new receipt has input dependencies. The gas
+    # is charged for each input dependency. The dependencies are specified when a receipt is
+    # created using `promise_then` and `promise_batch_then`.
+    # NOTE: Any receipt with output dependencies will produce data receipts. Even if it fails.
+    # Even if the last action is not a function call (in case of success it will return empty
+    # value).
+    base_cost: Fee = None
+    # Additional cost per byte sent.
+    # Both `send` and `exec` costs are burned when a function call finishes execution and returns
+    # `N` bytes of data to every output dependency. For each output dependency the cost is
+    # `(send(sir) + exec()) * N`.
+    cost_per_byte: Fee = None

near_jsonrpc_models/data_receiver_view.py

@@ -0,0 +1,8 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from pydantic import BaseModel
+
+
+class DataReceiverView(BaseModel):
+    data_id: CryptoHash
+    receiver_id: AccountId

near_jsonrpc_models/delegate_action.py

@@ -0,0 +1,28 @@
+"""This action allows to execute the inner actions behalf of the defined sender."""
+
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.non_delegate_action import NonDelegateAction
+from near_jsonrpc_models.public_key import PublicKey
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class DelegateAction(BaseModel):
+    # List of actions to be executed.
+    # 
+    # With the meta transactions MVP defined in NEP-366, nested
+    # DelegateActions are not allowed. A separate type is used to enforce it.
+    actions: List[NonDelegateAction]
+    # The maximal height of the block in the blockchain below which the given DelegateAction is valid.
+    max_block_height: conint(ge=0, le=18446744073709551615)
+    # Nonce to ensure that the same delegate action is not sent twice by a
+    # relayer and should match for given account's `public_key`.
+    # After this action is processed it will increment.
+    nonce: conint(ge=0, le=18446744073709551615)
+    # Public key used to sign this delegated action.
+    public_key: PublicKey
+    # Receiver of the delegated actions.
+    receiver_id: AccountId
+    # Signer of the delegated actions
+    sender_id: AccountId

near_jsonrpc_models/delete_account_action.py

@@ -0,0 +1,6 @@
+from near_jsonrpc_models.account_id import AccountId
+from pydantic import BaseModel
+
+
+class DeleteAccountAction(BaseModel):
+    beneficiary_id: AccountId

near_jsonrpc_models/delete_gas_key_action.py

@@ -0,0 +1,6 @@
+from near_jsonrpc_models.public_key import PublicKey
+from pydantic import BaseModel
+
+
+class DeleteGasKeyAction(BaseModel):
+    public_key: PublicKey

near_jsonrpc_models/delete_key_action.py

@@ -0,0 +1,7 @@
+from near_jsonrpc_models.public_key import PublicKey
+from pydantic import BaseModel
+
+
+class DeleteKeyAction(BaseModel):
+    # A public key associated with the access_key to be deleted.
+    public_key: PublicKey

near_jsonrpc_models/deploy_contract_action.py

@@ -0,0 +1,8 @@
+"""Deploy contract action"""
+
+from pydantic import BaseModel
+
+
+class DeployContractAction(BaseModel):
+    # WebAssembly binary
+    code: str

near_jsonrpc_models/deploy_global_contract_action.py

@@ -0,0 +1,10 @@
+"""Deploy global contract action"""
+
+from near_jsonrpc_models.global_contract_deploy_mode import GlobalContractDeployMode
+from pydantic import BaseModel
+
+
+class DeployGlobalContractAction(BaseModel):
+    # WebAssembly binary
+    code: str
+    deploy_mode: GlobalContractDeployMode

near_jsonrpc_models/detailed_debug_status.py

@@ -0,0 +1,15 @@
+from near_jsonrpc_models.block_status_view import BlockStatusView
+from near_jsonrpc_models.catchup_status_view import CatchupStatusView
+from near_jsonrpc_models.network_info_view import NetworkInfoView
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class DetailedDebugStatus(BaseModel):
+    block_production_delay_millis: conint(ge=0, le=18446744073709551615)
+    catchup_status: List[CatchupStatusView]
+    current_head_status: BlockStatusView
+    current_header_head_status: BlockStatusView
+    network_info: NetworkInfoView
+    sync_status: str

near_jsonrpc_models/deterministic_account_state_init.py

@@ -0,0 +1,13 @@
+from near_jsonrpc_models.deterministic_account_state_init_v1 import DeterministicAccountStateInitV1
+from near_jsonrpc_models.strict_model import StrictBaseModel
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class DeterministicAccountStateInitV1Option(StrictBaseModel):
+    V1: DeterministicAccountStateInitV1
+
+class DeterministicAccountStateInit(RootModel[Union[DeterministicAccountStateInitV1Option]]):
+    pass
+

near_jsonrpc_models/deterministic_account_state_init_v1.py

@@ -0,0 +1,8 @@
+from near_jsonrpc_models.global_contract_identifier import GlobalContractIdentifier
+from pydantic import BaseModel
+from typing import Dict
+
+
+class DeterministicAccountStateInitV1(BaseModel):
+    code: GlobalContractIdentifier
+    data: Dict[str, str]

near_jsonrpc_models/deterministic_state_init_action.py

@@ -0,0 +1,8 @@
+from near_jsonrpc_models.deterministic_account_state_init import DeterministicAccountStateInit
+from near_jsonrpc_models.near_token import NearToken
+from pydantic import BaseModel
+
+
+class DeterministicStateInitAction(BaseModel):
+    deposit: NearToken
+    state_init: DeterministicAccountStateInit

near_jsonrpc_models/direction.py

@@ -0,0 +1,7 @@
+from pydantic import RootModel
+from typing import Literal
+
+
+class Direction(RootModel[Literal['Left', 'Right']]):
+    pass
+

near_jsonrpc_models/dump_config.py

@@ -0,0 +1,20 @@
+"""Configures how to dump state to external storage."""
+
+from near_jsonrpc_models.duration_as_std_schema_provider import DurationAsStdSchemaProvider
+from near_jsonrpc_models.external_storage_location import ExternalStorageLocation
+from near_jsonrpc_models.shard_id import ShardId
+from pydantic import BaseModel
+from typing import List
+
+
+class DumpConfig(BaseModel):
+    # Location of a json file with credentials allowing access to the bucket.
+    credentials_file: str | None = None
+    # How often to check if a new epoch has started.
+    # Feel free to set to `None`, defaults are sensible.
+    iteration_delay: DurationAsStdSchemaProvider | None = None
+    # Specifies where to write the obtained state parts.
+    location: ExternalStorageLocation = None
+    # Use in case a node that dumps state to the external storage
+    # gets in trouble.
+    restart_dump_for_shards: List[ShardId] | None = None

near_jsonrpc_models/duration_as_std_schema_provider.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class DurationAsStdSchemaProvider(BaseModel):
+    nanos: conint(ge=-2147483648, le=2147483647)
+    secs: int

near_jsonrpc_models/dynamic_resharding_config_view.py

@@ -0,0 +1,23 @@
+"""Configuration for dynamic resharding feature"""
+
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class DynamicReshardingConfigView(BaseModel):
+    # Maximum number of shards in the network.
+    # 
+    # See [`CongestionControlConfig`] for more details.
+    max_number_of_shards: conint(ge=0, le=18446744073709551615)
+    # Memory threshold over which a shard is marked for a split.
+    # 
+    # See [`CongestionControlConfig`] for more details.
+    memory_usage_threshold: conint(ge=0, le=18446744073709551615)
+    # Minimum memory usage of a child shard.
+    # 
+    # See [`CongestionControlConfig`] for more details.
+    min_child_memory_usage: conint(ge=0, le=18446744073709551615)
+    # Minimum number of epochs until next resharding can be scheduled.
+    # 
+    # See [`CongestionControlConfig`] for more details.
+    min_epochs_between_resharding: conint(ge=0, le=18446744073709551615)

near_jsonrpc_models/epoch_id.py

@@ -0,0 +1,8 @@
+"""Epoch identifier -- wrapped hash, to make it easier to distinguish.
+EpochId of epoch T is the hash of last block in T-2
+EpochId of first two epochs is 0"""
+
+from near_jsonrpc_models.crypto_hash import CryptoHash
+
+
+EpochId = CryptoHash

near_jsonrpc_models/epoch_sync_config.py

@@ -0,0 +1,25 @@
+from near_jsonrpc_models.duration_as_std_schema_provider import DurationAsStdSchemaProvider
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class EpochSyncConfig(BaseModel):
+    # If true, even if the node started from genesis, it will not perform epoch sync.
+    # There should be no reason to set this flag in production, because on both mainnet
+    # and testnet it would be infeasible to catch up from genesis without epoch sync.
+    disable_epoch_sync_for_bootstrapping: bool = False
+    # This serves as two purposes: (1) the node will not epoch sync and instead resort to
+    # header sync, if the genesis block is within this many blocks from the current block;
+    # (2) the node will reject an epoch sync proof if the provided proof is for an epoch
+    # that is more than this many blocks behind the current block.
+    epoch_sync_horizon: conint(ge=0, le=18446744073709551615) = None
+    # If true, the node will ignore epoch sync requests from the network. It is strongly
+    # recommended not to set this flag, because it will prevent other nodes from
+    # bootstrapping. This flag is only included as a kill-switch and may be removed in a
+    # future release. Please note that epoch sync requests are heavily rate limited and
+    # cached, and therefore should not affect the performance of the node or introduce
+    # any non-negligible increase in network traffic.
+    ignore_epoch_sync_network_requests: bool = False
+    # Timeout for epoch sync requests. The node will continue retrying indefinitely even
+    # if this timeout is exceeded.
+    timeout_for_epoch_sync: DurationAsStdSchemaProvider = None

near_jsonrpc_models/error_wrapper_for_genesis_config_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.genesis_config_error import GenesisConfigError
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForGenesisConfigErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForGenesisConfigErrorHandlerError(BaseModel):
+    cause: GenesisConfigError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForGenesisConfigErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForGenesisConfigError(RootModel[Union[ErrorWrapperForGenesisConfigErrorRequestValidationError, ErrorWrapperForGenesisConfigErrorHandlerError, ErrorWrapperForGenesisConfigErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_block_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_block_error import RpcBlockError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcBlockErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcBlockErrorHandlerError(BaseModel):
+    cause: RpcBlockError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcBlockErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcBlockError(RootModel[Union[ErrorWrapperForRpcBlockErrorRequestValidationError, ErrorWrapperForRpcBlockErrorHandlerError, ErrorWrapperForRpcBlockErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_call_function_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_call_function_error import RpcCallFunctionError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcCallFunctionErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcCallFunctionErrorHandlerError(BaseModel):
+    cause: RpcCallFunctionError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcCallFunctionErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcCallFunctionError(RootModel[Union[ErrorWrapperForRpcCallFunctionErrorRequestValidationError, ErrorWrapperForRpcCallFunctionErrorHandlerError, ErrorWrapperForRpcCallFunctionErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_chunk_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_chunk_error import RpcChunkError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcChunkErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcChunkErrorHandlerError(BaseModel):
+    cause: RpcChunkError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcChunkErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcChunkError(RootModel[Union[ErrorWrapperForRpcChunkErrorRequestValidationError, ErrorWrapperForRpcChunkErrorHandlerError, ErrorWrapperForRpcChunkErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_client_config_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_client_config_error import RpcClientConfigError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcClientConfigErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcClientConfigErrorHandlerError(BaseModel):
+    cause: RpcClientConfigError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcClientConfigErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcClientConfigError(RootModel[Union[ErrorWrapperForRpcClientConfigErrorRequestValidationError, ErrorWrapperForRpcClientConfigErrorHandlerError, ErrorWrapperForRpcClientConfigErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_gas_price_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_gas_price_error import RpcGasPriceError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcGasPriceErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcGasPriceErrorHandlerError(BaseModel):
+    cause: RpcGasPriceError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcGasPriceErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcGasPriceError(RootModel[Union[ErrorWrapperForRpcGasPriceErrorRequestValidationError, ErrorWrapperForRpcGasPriceErrorHandlerError, ErrorWrapperForRpcGasPriceErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_light_client_next_block_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_light_client_next_block_error import RpcLightClientNextBlockError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcLightClientNextBlockErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcLightClientNextBlockErrorHandlerError(BaseModel):
+    cause: RpcLightClientNextBlockError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcLightClientNextBlockErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcLightClientNextBlockError(RootModel[Union[ErrorWrapperForRpcLightClientNextBlockErrorRequestValidationError, ErrorWrapperForRpcLightClientNextBlockErrorHandlerError, ErrorWrapperForRpcLightClientNextBlockErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_light_client_proof_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_light_client_proof_error import RpcLightClientProofError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcLightClientProofErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcLightClientProofErrorHandlerError(BaseModel):
+    cause: RpcLightClientProofError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcLightClientProofErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcLightClientProofError(RootModel[Union[ErrorWrapperForRpcLightClientProofErrorRequestValidationError, ErrorWrapperForRpcLightClientProofErrorHandlerError, ErrorWrapperForRpcLightClientProofErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_maintenance_windows_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_maintenance_windows_error import RpcMaintenanceWindowsError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcMaintenanceWindowsErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcMaintenanceWindowsErrorHandlerError(BaseModel):
+    cause: RpcMaintenanceWindowsError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcMaintenanceWindowsErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcMaintenanceWindowsError(RootModel[Union[ErrorWrapperForRpcMaintenanceWindowsErrorRequestValidationError, ErrorWrapperForRpcMaintenanceWindowsErrorHandlerError, ErrorWrapperForRpcMaintenanceWindowsErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_network_info_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_network_info_error import RpcNetworkInfoError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcNetworkInfoErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcNetworkInfoErrorHandlerError(BaseModel):
+    cause: RpcNetworkInfoError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcNetworkInfoErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcNetworkInfoError(RootModel[Union[ErrorWrapperForRpcNetworkInfoErrorRequestValidationError, ErrorWrapperForRpcNetworkInfoErrorHandlerError, ErrorWrapperForRpcNetworkInfoErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_protocol_config_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_protocol_config_error import RpcProtocolConfigError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcProtocolConfigErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcProtocolConfigErrorHandlerError(BaseModel):
+    cause: RpcProtocolConfigError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcProtocolConfigErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcProtocolConfigError(RootModel[Union[ErrorWrapperForRpcProtocolConfigErrorRequestValidationError, ErrorWrapperForRpcProtocolConfigErrorHandlerError, ErrorWrapperForRpcProtocolConfigErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_query_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_query_error import RpcQueryError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcQueryErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcQueryErrorHandlerError(BaseModel):
+    cause: RpcQueryError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcQueryErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcQueryError(RootModel[Union[ErrorWrapperForRpcQueryErrorRequestValidationError, ErrorWrapperForRpcQueryErrorHandlerError, ErrorWrapperForRpcQueryErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_receipt_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_receipt_error import RpcReceiptError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcReceiptErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcReceiptErrorHandlerError(BaseModel):
+    cause: RpcReceiptError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcReceiptErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcReceiptError(RootModel[Union[ErrorWrapperForRpcReceiptErrorRequestValidationError, ErrorWrapperForRpcReceiptErrorHandlerError, ErrorWrapperForRpcReceiptErrorInternalError]]):
+    pass
+

near_jsonrpc_models/error_wrapper_for_rpc_split_storage_info_error.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.internal_error import InternalError
+from near_jsonrpc_models.rpc_request_validation_error_kind import RpcRequestValidationErrorKind
+from near_jsonrpc_models.rpc_split_storage_info_error import RpcSplitStorageInfoError
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Literal
+from typing import Union
+
+
+class ErrorWrapperForRpcSplitStorageInfoErrorRequestValidationError(BaseModel):
+    cause: RpcRequestValidationErrorKind
+    name: Literal['REQUEST_VALIDATION_ERROR']
+
+class ErrorWrapperForRpcSplitStorageInfoErrorHandlerError(BaseModel):
+    cause: RpcSplitStorageInfoError
+    name: Literal['HANDLER_ERROR']
+
+class ErrorWrapperForRpcSplitStorageInfoErrorInternalError(BaseModel):
+    cause: InternalError
+    name: Literal['INTERNAL_ERROR']
+
+class ErrorWrapperForRpcSplitStorageInfoError(RootModel[Union[ErrorWrapperForRpcSplitStorageInfoErrorRequestValidationError, ErrorWrapperForRpcSplitStorageInfoErrorHandlerError, ErrorWrapperForRpcSplitStorageInfoErrorInternalError]]):
+    pass
+