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

near_jsonrpc_models/rpc_view_account_request.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_id import BlockId
+from near_jsonrpc_models.finality import Finality
+from near_jsonrpc_models.sync_checkpoint import SyncCheckpoint
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class RpcViewAccountRequestBlockId(BaseModel):
+    account_id: AccountId
+    block_id: BlockId
+
+class RpcViewAccountRequestFinality(BaseModel):
+    account_id: AccountId
+    finality: Finality
+
+class RpcViewAccountRequestSyncCheckpoint(BaseModel):
+    account_id: AccountId
+    sync_checkpoint: SyncCheckpoint
+
+class RpcViewAccountRequest(RootModel[Union[RpcViewAccountRequestBlockId, RpcViewAccountRequestFinality, RpcViewAccountRequestSyncCheckpoint]]):
+    pass
+

near_jsonrpc_models/rpc_view_account_response.py

@@ -0,0 +1,20 @@
+"""A view of the account"""
+
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from near_jsonrpc_models.near_token import NearToken
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class RpcViewAccountResponse(BaseModel):
+    amount: NearToken
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    code_hash: CryptoHash
+    global_contract_account_id: AccountId | None = None
+    global_contract_hash: CryptoHash | None = None
+    locked: NearToken
+    # TODO(2271): deprecated.
+    storage_paid_at: conint(ge=0, le=18446744073709551615) = 0
+    storage_usage: conint(ge=0, le=18446744073709551615)

near_jsonrpc_models/rpc_view_code_error.py

@@ -0,0 +1,54 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_reference import BlockReference
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from pydantic import BaseModel
+from pydantic import RootModel
+from pydantic import conint
+from typing import Literal
+from typing import Union
+
+
+class RpcViewCodeErrorUnknownBlockInfo(BaseModel):
+    block_reference: BlockReference
+
+class RpcViewCodeErrorUnknownBlock(BaseModel):
+    info: RpcViewCodeErrorUnknownBlockInfo
+    name: Literal['UNKNOWN_BLOCK']
+
+class RpcViewCodeErrorInvalidAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewCodeErrorInvalidAccount(BaseModel):
+    info: RpcViewCodeErrorInvalidAccountInfo
+    name: Literal['INVALID_ACCOUNT']
+
+class RpcViewCodeErrorUnknownAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewCodeErrorUnknownAccount(BaseModel):
+    info: RpcViewCodeErrorUnknownAccountInfo
+    name: Literal['UNKNOWN_ACCOUNT']
+
+class RpcViewCodeErrorNoContractCodeInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    contract_account_id: AccountId
+
+class RpcViewCodeErrorNoContractCode(BaseModel):
+    info: RpcViewCodeErrorNoContractCodeInfo
+    name: Literal['NO_CONTRACT_CODE']
+
+class RpcViewCodeErrorInternalErrorInfo(BaseModel):
+    error_message: str
+
+class RpcViewCodeErrorInternalError(BaseModel):
+    info: RpcViewCodeErrorInternalErrorInfo
+    name: Literal['INTERNAL_ERROR']
+
+class RpcViewCodeError(RootModel[Union[RpcViewCodeErrorUnknownBlock, RpcViewCodeErrorInvalidAccount, RpcViewCodeErrorUnknownAccount, RpcViewCodeErrorNoContractCode, RpcViewCodeErrorInternalError]]):
+    pass
+

near_jsonrpc_models/rpc_view_code_request.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_id import BlockId
+from near_jsonrpc_models.finality import Finality
+from near_jsonrpc_models.sync_checkpoint import SyncCheckpoint
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class RpcViewCodeRequestBlockId(BaseModel):
+    account_id: AccountId
+    block_id: BlockId
+
+class RpcViewCodeRequestFinality(BaseModel):
+    account_id: AccountId
+    finality: Finality
+
+class RpcViewCodeRequestSyncCheckpoint(BaseModel):
+    account_id: AccountId
+    sync_checkpoint: SyncCheckpoint
+
+class RpcViewCodeRequest(RootModel[Union[RpcViewCodeRequestBlockId, RpcViewCodeRequestFinality, RpcViewCodeRequestSyncCheckpoint]]):
+    pass
+

near_jsonrpc_models/rpc_view_code_response.py

@@ -0,0 +1,12 @@
+"""A view of the contract code."""
+
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class RpcViewCodeResponse(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    code_base64: str
+    hash: CryptoHash

near_jsonrpc_models/rpc_view_gas_key_error.py

@@ -0,0 +1,55 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_reference import BlockReference
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from near_jsonrpc_models.public_key import PublicKey
+from pydantic import BaseModel
+from pydantic import RootModel
+from pydantic import conint
+from typing import Literal
+from typing import Union
+
+
+class RpcViewGasKeyErrorUnknownBlockInfo(BaseModel):
+    block_reference: BlockReference
+
+class RpcViewGasKeyErrorUnknownBlock(BaseModel):
+    info: RpcViewGasKeyErrorUnknownBlockInfo
+    name: Literal['UNKNOWN_BLOCK']
+
+class RpcViewGasKeyErrorInvalidAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewGasKeyErrorInvalidAccount(BaseModel):
+    info: RpcViewGasKeyErrorInvalidAccountInfo
+    name: Literal['INVALID_ACCOUNT']
+
+class RpcViewGasKeyErrorUnknownAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewGasKeyErrorUnknownAccount(BaseModel):
+    info: RpcViewGasKeyErrorUnknownAccountInfo
+    name: Literal['UNKNOWN_ACCOUNT']
+
+class RpcViewGasKeyErrorUnknownGasKeyInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    public_key: PublicKey
+
+class RpcViewGasKeyErrorUnknownGasKey(BaseModel):
+    info: RpcViewGasKeyErrorUnknownGasKeyInfo
+    name: Literal['UNKNOWN_GAS_KEY']
+
+class RpcViewGasKeyErrorInternalErrorInfo(BaseModel):
+    error_message: str
+
+class RpcViewGasKeyErrorInternalError(BaseModel):
+    info: RpcViewGasKeyErrorInternalErrorInfo
+    name: Literal['INTERNAL_ERROR']
+
+class RpcViewGasKeyError(RootModel[Union[RpcViewGasKeyErrorUnknownBlock, RpcViewGasKeyErrorInvalidAccount, RpcViewGasKeyErrorUnknownAccount, RpcViewGasKeyErrorUnknownGasKey, RpcViewGasKeyErrorInternalError]]):
+    pass
+

near_jsonrpc_models/rpc_view_gas_key_list_error.py

@@ -0,0 +1,45 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_reference import BlockReference
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from pydantic import BaseModel
+from pydantic import RootModel
+from pydantic import conint
+from typing import Literal
+from typing import Union
+
+
+class RpcViewGasKeyListErrorUnknownBlockInfo(BaseModel):
+    block_reference: BlockReference
+
+class RpcViewGasKeyListErrorUnknownBlock(BaseModel):
+    info: RpcViewGasKeyListErrorUnknownBlockInfo
+    name: Literal['UNKNOWN_BLOCK']
+
+class RpcViewGasKeyListErrorInvalidAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewGasKeyListErrorInvalidAccount(BaseModel):
+    info: RpcViewGasKeyListErrorInvalidAccountInfo
+    name: Literal['INVALID_ACCOUNT']
+
+class RpcViewGasKeyListErrorUnknownAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewGasKeyListErrorUnknownAccount(BaseModel):
+    info: RpcViewGasKeyListErrorUnknownAccountInfo
+    name: Literal['UNKNOWN_ACCOUNT']
+
+class RpcViewGasKeyListErrorInternalErrorInfo(BaseModel):
+    error_message: str
+
+class RpcViewGasKeyListErrorInternalError(BaseModel):
+    info: RpcViewGasKeyListErrorInternalErrorInfo
+    name: Literal['INTERNAL_ERROR']
+
+class RpcViewGasKeyListError(RootModel[Union[RpcViewGasKeyListErrorUnknownBlock, RpcViewGasKeyListErrorInvalidAccount, RpcViewGasKeyListErrorUnknownAccount, RpcViewGasKeyListErrorInternalError]]):
+    pass
+

near_jsonrpc_models/rpc_view_gas_key_list_request.py

@@ -0,0 +1,24 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_id import BlockId
+from near_jsonrpc_models.finality import Finality
+from near_jsonrpc_models.sync_checkpoint import SyncCheckpoint
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class RpcViewGasKeyListRequestBlockId(BaseModel):
+    account_id: AccountId
+    block_id: BlockId
+
+class RpcViewGasKeyListRequestFinality(BaseModel):
+    account_id: AccountId
+    finality: Finality
+
+class RpcViewGasKeyListRequestSyncCheckpoint(BaseModel):
+    account_id: AccountId
+    sync_checkpoint: SyncCheckpoint
+
+class RpcViewGasKeyListRequest(RootModel[Union[RpcViewGasKeyListRequestBlockId, RpcViewGasKeyListRequestFinality, RpcViewGasKeyListRequestSyncCheckpoint]]):
+    pass
+

near_jsonrpc_models/rpc_view_gas_key_list_response.py

@@ -0,0 +1,11 @@
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from near_jsonrpc_models.gas_key_info_view import GasKeyInfoView
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class RpcViewGasKeyListResponse(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    keys: List[GasKeyInfoView]

near_jsonrpc_models/rpc_view_gas_key_request.py

@@ -0,0 +1,28 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_id import BlockId
+from near_jsonrpc_models.finality import Finality
+from near_jsonrpc_models.public_key import PublicKey
+from near_jsonrpc_models.sync_checkpoint import SyncCheckpoint
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class RpcViewGasKeyRequestBlockId(BaseModel):
+    account_id: AccountId
+    public_key: PublicKey
+    block_id: BlockId
+
+class RpcViewGasKeyRequestFinality(BaseModel):
+    account_id: AccountId
+    public_key: PublicKey
+    finality: Finality
+
+class RpcViewGasKeyRequestSyncCheckpoint(BaseModel):
+    account_id: AccountId
+    public_key: PublicKey
+    sync_checkpoint: SyncCheckpoint
+
+class RpcViewGasKeyRequest(RootModel[Union[RpcViewGasKeyRequestBlockId, RpcViewGasKeyRequestFinality, RpcViewGasKeyRequestSyncCheckpoint]]):
+    pass
+

near_jsonrpc_models/rpc_view_gas_key_response.py

@@ -0,0 +1,15 @@
+from near_jsonrpc_models.access_key_permission_view import AccessKeyPermissionView
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from near_jsonrpc_models.near_token import NearToken
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class RpcViewGasKeyResponse(BaseModel):
+    balance: NearToken
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    nonces: List[conint(ge=0, le=18446744073709551615)]
+    num_nonces: conint(ge=0, le=4294967295)
+    permission: AccessKeyPermissionView

near_jsonrpc_models/rpc_view_state_error.py

@@ -0,0 +1,54 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_reference import BlockReference
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from pydantic import BaseModel
+from pydantic import RootModel
+from pydantic import conint
+from typing import Literal
+from typing import Union
+
+
+class RpcViewStateErrorUnknownBlockInfo(BaseModel):
+    block_reference: BlockReference
+
+class RpcViewStateErrorUnknownBlock(BaseModel):
+    info: RpcViewStateErrorUnknownBlockInfo
+    name: Literal['UNKNOWN_BLOCK']
+
+class RpcViewStateErrorInvalidAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewStateErrorInvalidAccount(BaseModel):
+    info: RpcViewStateErrorInvalidAccountInfo
+    name: Literal['INVALID_ACCOUNT']
+
+class RpcViewStateErrorUnknownAccountInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    requested_account_id: AccountId
+
+class RpcViewStateErrorUnknownAccount(BaseModel):
+    info: RpcViewStateErrorUnknownAccountInfo
+    name: Literal['UNKNOWN_ACCOUNT']
+
+class RpcViewStateErrorTooLargeContractStateInfo(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    contract_account_id: AccountId
+
+class RpcViewStateErrorTooLargeContractState(BaseModel):
+    info: RpcViewStateErrorTooLargeContractStateInfo
+    name: Literal['TOO_LARGE_CONTRACT_STATE']
+
+class RpcViewStateErrorInternalErrorInfo(BaseModel):
+    error_message: str
+
+class RpcViewStateErrorInternalError(BaseModel):
+    info: RpcViewStateErrorInternalErrorInfo
+    name: Literal['INTERNAL_ERROR']
+
+class RpcViewStateError(RootModel[Union[RpcViewStateErrorUnknownBlock, RpcViewStateErrorInvalidAccount, RpcViewStateErrorUnknownAccount, RpcViewStateErrorTooLargeContractState, RpcViewStateErrorInternalError]]):
+    pass
+

near_jsonrpc_models/rpc_view_state_request.py

@@ -0,0 +1,31 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.block_id import BlockId
+from near_jsonrpc_models.finality import Finality
+from near_jsonrpc_models.store_key import StoreKey
+from near_jsonrpc_models.sync_checkpoint import SyncCheckpoint
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class RpcViewStateRequestBlockId(BaseModel):
+    account_id: AccountId
+    include_proof: bool = False
+    prefix_base64: StoreKey
+    block_id: BlockId
+
+class RpcViewStateRequestFinality(BaseModel):
+    account_id: AccountId
+    include_proof: bool = False
+    prefix_base64: StoreKey
+    finality: Finality
+
+class RpcViewStateRequestSyncCheckpoint(BaseModel):
+    account_id: AccountId
+    include_proof: bool = False
+    prefix_base64: StoreKey
+    sync_checkpoint: SyncCheckpoint
+
+class RpcViewStateRequest(RootModel[Union[RpcViewStateRequestBlockId, RpcViewStateRequestFinality, RpcViewStateRequestSyncCheckpoint]]):
+    pass
+

near_jsonrpc_models/rpc_view_state_response.py

@@ -0,0 +1,14 @@
+"""Resulting state values for a view state query request"""
+
+from near_jsonrpc_models.crypto_hash import CryptoHash
+from near_jsonrpc_models.state_item import StateItem
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class RpcViewStateResponse(BaseModel):
+    block_hash: CryptoHash
+    block_height: conint(ge=0, le=18446744073709551615)
+    proof: List[str] = None
+    values: List[StateItem]

near_jsonrpc_models/runtime_config_view.py

@@ -0,0 +1,30 @@
+"""View that preserves JSON format of the runtime config."""
+
+from near_jsonrpc_models.account_creation_config_view import AccountCreationConfigView
+from near_jsonrpc_models.congestion_control_config_view import CongestionControlConfigView
+from near_jsonrpc_models.dynamic_resharding_config_view import DynamicReshardingConfigView
+from near_jsonrpc_models.near_token import NearToken
+from near_jsonrpc_models.runtime_fees_config_view import RuntimeFeesConfigView
+from near_jsonrpc_models.vmconfig_view import VMConfigView
+from near_jsonrpc_models.witness_config_view import WitnessConfigView
+from pydantic import BaseModel
+from pydantic import Field
+
+
+class RuntimeConfigView(BaseModel):
+    # Config that defines rules for account creation.
+    account_creation_config: AccountCreationConfigView = None
+    # The configuration for congestion control.
+    congestion_control_config: CongestionControlConfigView = None
+    # Configuration for dynamic resharding feature.
+    dynamic_resharding_config: DynamicReshardingConfigView = Field(default_factory=lambda: DynamicReshardingConfigView(**{'max_number_of_shards': 999999999999999, 'memory_usage_threshold': 999999999999999, 'min_child_memory_usage': 999999999999999, 'min_epochs_between_resharding': 999999999999999}))
+    # Amount of yN per byte required to have on the account.  See
+    # <https://nomicon.io/Economics/Economics.html#state-stake> for details.
+    storage_amount_per_byte: NearToken = None
+    # Costs of different actions that need to be performed when sending and
+    # processing transaction and receipts.
+    transaction_costs: RuntimeFeesConfigView = None
+    # Config of wasm operations.
+    wasm_config: VMConfigView = None
+    # Configuration specific to ChunkStateWitness.
+    witness_config: WitnessConfigView = None

near_jsonrpc_models/runtime_fees_config_view.py

@@ -0,0 +1,29 @@
+"""Describes different fees for the runtime"""
+
+from near_jsonrpc_models.action_creation_config_view import ActionCreationConfigView
+from near_jsonrpc_models.data_receipt_creation_config_view import DataReceiptCreationConfigView
+from near_jsonrpc_models.fee import Fee
+from near_jsonrpc_models.storage_usage_config_view import StorageUsageConfigView
+from pydantic import BaseModel
+from pydantic import conint
+from pydantic import conlist
+from typing import List
+
+
+class RuntimeFeesConfigView(BaseModel):
+    # Describes the cost of creating a certain action, `Action`. Includes all variants.
+    action_creation_config: ActionCreationConfigView = None
+    # Describes the cost of creating an action receipt, `ActionReceipt`, excluding the actual cost
+    # of actions.
+    # - `send` cost is burned when a receipt is created using `promise_create` or
+    #     `promise_batch_create`
+    # - `exec` cost is burned when the receipt is being executed.
+    action_receipt_creation_config: Fee = None
+    # Fraction of the burnt gas to reward to the contract account for execution.
+    burnt_gas_reward: conlist(conint(ge=-2147483648, le=2147483647), min_length=2, max_length=2) = None
+    # Describes the cost of creating a data receipt, `DataReceipt`.
+    data_receipt_creation_config: DataReceiptCreationConfigView = None
+    # Pessimistic gas price inflation ratio.
+    pessimistic_gas_price_inflation_ratio: conlist(conint(ge=-2147483648, le=2147483647), min_length=2, max_length=2) = None
+    # Describes fees for storage.
+    storage_usage_config: StorageUsageConfigView = None

near_jsonrpc_models/shard_id.py

@@ -0,0 +1,16 @@
+"""The shard identifier. It may be an arbitrary number - it does not need to be
+a number in the range 0..NUM_SHARDS. The shard ids do not need to be
+sequential or contiguous.
+
+The shard id is wrapped in a new type to prevent the old pattern of using
+indices in range 0..NUM_SHARDS and casting to ShardId. Once the transition
+if fully complete it potentially may be simplified to a regular type alias."""
+
+from pydantic import BaseModel
+from pydantic import RootModel
+from pydantic import conint
+
+
+class ShardId(RootModel[conint(ge=0, le=18446744073709551615)]):
+    pass
+

near_jsonrpc_models/shard_layout.py

@@ -0,0 +1,34 @@
+"""A versioned struct that contains all information needed to assign accounts to shards.
+
+Because of re-sharding, the chain may use different shard layout to split shards at different
+times. Currently, `ShardLayout` is stored as part of `EpochConfig`, which is generated each
+epoch given the epoch protocol version. In mainnet/testnet, we use two shard layouts since
+re-sharding has only happened once. It is stored as part of genesis config, see
+default_simple_nightshade_shard_layout() Below is an overview for some important
+functionalities of ShardLayout interface."""
+
+from near_jsonrpc_models.shard_layout_v0 import ShardLayoutV0
+from near_jsonrpc_models.shard_layout_v1 import ShardLayoutV1
+from near_jsonrpc_models.shard_layout_v2 import ShardLayoutV2
+from near_jsonrpc_models.shard_layout_v3 import ShardLayoutV3
+from near_jsonrpc_models.strict_model import StrictBaseModel
+from pydantic import BaseModel
+from pydantic import RootModel
+from typing import Union
+
+
+class ShardLayoutV0Option(StrictBaseModel):
+    V0: ShardLayoutV0
+
+class ShardLayoutV1Option(StrictBaseModel):
+    V1: ShardLayoutV1
+
+class ShardLayoutV2Option(StrictBaseModel):
+    V2: ShardLayoutV2
+
+class ShardLayoutV3Option(StrictBaseModel):
+    V3: ShardLayoutV3
+
+class ShardLayout(RootModel[Union[ShardLayoutV0Option, ShardLayoutV1Option, ShardLayoutV2Option, ShardLayoutV3Option]]):
+    pass
+

near_jsonrpc_models/shard_layout_v0.py

@@ -0,0 +1,15 @@
+"""A shard layout that maps accounts evenly across all shards -- by calculate the hash of account
+id and mod number of shards. This is added to capture the old `account_id_to_shard_id` algorithm,
+to keep backward compatibility for some existing tests.
+`parent_shards` for `ShardLayoutV1` is always `None`, meaning it can only be the first shard layout
+a chain uses."""
+
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class ShardLayoutV0(BaseModel):
+    # Map accounts evenly across all shards
+    num_shards: conint(ge=0, le=18446744073709551615)
+    # Version of the shard layout, this is useful for uniquely identify the shard layout
+    version: conint(ge=0, le=4294967295)

near_jsonrpc_models/shard_layout_v1.py

@@ -0,0 +1,22 @@
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.shard_id import ShardId
+from pydantic import BaseModel
+from pydantic import conint
+from typing import List
+
+
+class ShardLayoutV1(BaseModel):
+    # The boundary accounts are the accounts on boundaries between shards.
+    # Each shard contains a range of accounts from one boundary account to
+    # another - or the smallest or largest account possible. The total
+    # number of shards is equal to the number of boundary accounts plus 1.
+    boundary_accounts: List[AccountId]
+    # Maps shards from the last shard layout to shards that it splits to in this shard layout,
+    # Useful for constructing states for the shards.
+    # None for the genesis shard layout
+    shards_split_map: List[List[ShardId]] | None = None
+    # Maps shard in this shard layout to their parent shard
+    # Since shard_ids always range from 0 to num_shards - 1, we use vec instead of a hashmap
+    to_parent_shard_map: List[ShardId] | None = None
+    # Version of the shard layout, this is useful for uniquely identify the shard layout
+    version: conint(ge=0, le=4294967295)

near_jsonrpc_models/shard_layout_v2.py

@@ -0,0 +1,19 @@
+"""Counterpart to `ShardLayoutV2` composed of maps with string keys to aid
+serde serialization."""
+
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.shard_id import ShardId
+from pydantic import BaseModel
+from pydantic import conint
+from typing import Dict
+from typing import List
+
+
+class ShardLayoutV2(BaseModel):
+    boundary_accounts: List[AccountId]
+    id_to_index_map: Dict[str, conint(ge=0, le=4294967295)]
+    index_to_id_map: Dict[str, ShardId]
+    shard_ids: List[ShardId]
+    shards_parent_map: Dict[str, ShardId] | None = None
+    shards_split_map: Dict[str, List[ShardId]] | None = None
+    version: conint(ge=0, le=4294967295)

near_jsonrpc_models/shard_layout_v3.py

@@ -0,0 +1,17 @@
+"""Counterpart to `ShardLayoutV3` composed of maps with string keys to aid
+serde serialization."""
+
+from near_jsonrpc_models.account_id import AccountId
+from near_jsonrpc_models.shard_id import ShardId
+from pydantic import BaseModel
+from pydantic import conint
+from typing import Dict
+from typing import List
+
+
+class ShardLayoutV3(BaseModel):
+    boundary_accounts: List[AccountId]
+    id_to_index_map: Dict[str, conint(ge=0, le=4294967295)]
+    last_split: ShardId
+    shard_ids: List[ShardId]
+    shards_split_map: Dict[str, List[ShardId]]

near_jsonrpc_models/shard_uid.py

@@ -0,0 +1,17 @@
+"""`ShardUId` is a unique representation for shards from different shard layouts.
+
+Comparing to `ShardId`, which is just an ordinal number ranging from 0 to NUM_SHARDS-1,
+`ShardUId` provides a way to unique identify shards when shard layouts may change across epochs.
+This is important because we store states indexed by shards in our database, so we need a
+way to unique identify shard even when shards change across epochs.
+Another difference between `ShardUId` and `ShardId` is that `ShardUId` should only exist in
+a node's internal state while `ShardId` can be exposed to outside APIs and used in protocol
+level information (for example, `ShardChunkHeader` contains `ShardId` instead of `ShardUId`)"""
+
+from pydantic import BaseModel
+from pydantic import conint
+
+
+class ShardUId(BaseModel):
+    shard_id: conint(ge=0, le=4294967295)
+    version: conint(ge=0, le=4294967295)

near_jsonrpc_models/signature.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from pydantic import RootModel
+
+
+class Signature(RootModel[str]):
+    pass
+

near_jsonrpc_models/signed_delegate_action.py

@@ -0,0 +1,8 @@
+from near_jsonrpc_models.delegate_action import DelegateAction
+from near_jsonrpc_models.signature import Signature
+from pydantic import BaseModel
+
+
+class SignedDelegateAction(BaseModel):
+    delegate_action: DelegateAction
+    signature: Signature

near_jsonrpc_models/signed_transaction.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from pydantic import RootModel
+
+
+class SignedTransaction(RootModel[str]):
+    pass
+