near-api-ts 0.2.0 → 0.2.2

package/dist/index.js

@@ -19,7 +19,7 @@ var createSendRequest = (clientContext) => async ({ body }) => {
 };
 
 // src/client/createClient/account/getAccountState.ts
-import * as z2 from "zod/mini";
+import * as z from "zod/mini";
 
 // src/_common/transformers/toNative/blockReference.ts
 var toNativeBlockReference = (blockReference, defaultBlockReference) => {
@@ -40,1388 +40,8 @@ var toNativeBlockReference = (blockReference, defaultBlockReference) => {
   return { finality: "near-final" };
 };
 
-// ../../node_modules/.pnpm/@near-js+jsonrpc-types@1.3.4/node_modules/@near-js/jsonrpc-types/dist/index.mjs
-import { z } from "zod/mini";
-var AccessKeySchema = () => z.object({
-  nonce: z.number(),
-  permission: z.lazy(() => AccessKeyPermissionSchema())
-});
-var AccessKeyCreationConfigViewSchema = () => z.object({
-  fullAccessCost: z.lazy(() => FeeSchema()),
-  functionCallCost: z.lazy(() => FeeSchema()),
-  functionCallCostPerByte: z.lazy(() => FeeSchema())
-});
-var AccessKeyInfoViewSchema = () => z.object({
-  accessKey: z.lazy(() => AccessKeyViewSchema()),
-  publicKey: z.lazy(() => PublicKeySchema())
-});
-var AccessKeyListSchema = () => z.object({
-  keys: z.array(z.lazy(() => AccessKeyInfoViewSchema()))
-});
-var AccessKeyPermissionSchema = () => z.union([
-  z.object({
-    FunctionCall: z.lazy(() => FunctionCallPermissionSchema())
-  }),
-  z.enum(["FullAccess"])
-]);
-var AccessKeyPermissionViewSchema = () => z.union([
-  z.enum(["FullAccess"]),
-  z.object({
-    FunctionCall: z.object({
-      allowance: z.optional(
-        z.union([z.union([z.string(), z.null()]), z.null()])
-      ),
-      methodNames: z.array(z.string()),
-      receiverId: z.string()
-    })
-  })
-]);
-var AccessKeyViewSchema = () => z.object({
-  nonce: z.number(),
-  permission: z.lazy(() => AccessKeyPermissionViewSchema())
-});
-var AccountCreationConfigViewSchema = () => z.object({
-  minAllowedTopLevelAccountLength: z.number(),
-  registrarAccountId: z.lazy(() => AccountIdSchema())
-});
-var AccountIdSchema = () => z.string();
-var AccountIdValidityRulesVersionSchema = () => z.number();
-var AccountViewSchema = () => z.object({
-  amount: z.string(),
-  codeHash: z.lazy(() => CryptoHashSchema()),
-  globalContractAccountId: z.optional(
-    z.union([z.lazy(() => AccountIdSchema()), z.null()])
-  ),
-  globalContractHash: z.optional(
-    z.union([z.lazy(() => CryptoHashSchema()), z.null()])
-  ),
-  locked: z.string(),
-  storagePaidAt: z.optional(z.number()),
-  storageUsage: z.number()
-});
-var ActionCreationConfigViewSchema = () => z.object({
-  addKeyCost: z.lazy(() => AccessKeyCreationConfigViewSchema()),
-  createAccountCost: z.lazy(() => FeeSchema()),
-  delegateCost: z.lazy(() => FeeSchema()),
-  deleteAccountCost: z.lazy(() => FeeSchema()),
-  deleteKeyCost: z.lazy(() => FeeSchema()),
-  deployContractCost: z.lazy(() => FeeSchema()),
-  deployContractCostPerByte: z.lazy(() => FeeSchema()),
-  functionCallCost: z.lazy(() => FeeSchema()),
-  functionCallCostPerByte: z.lazy(() => FeeSchema()),
-  stakeCost: z.lazy(() => FeeSchema()),
-  transferCost: z.lazy(() => FeeSchema())
-});
-var ActionErrorSchema = () => z.object({
-  index: z.optional(z.union([z.union([z.number(), z.null()]), z.null()])),
-  kind: z.lazy(() => ActionErrorKindSchema())
-});
-var ActionErrorKindSchema = () => z.union([
-  z.object({
-    AccountAlreadyExists: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    AccountDoesNotExist: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    CreateAccountOnlyByRegistrar: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      predecessorId: z.lazy(() => AccountIdSchema()),
-      registrarAccountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    CreateAccountNotAllowed: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      predecessorId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    ActorNoPermission: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      actorId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    DeleteKeyDoesNotExist: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    AddKeyAlreadyExists: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    DeleteAccountStaking: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    LackBalanceForState: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      amount: z.string()
-    })
-  }),
-  z.object({
-    TriesToUnstake: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    TriesToStake: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      balance: z.string(),
-      locked: z.string(),
-      stake: z.string()
-    })
-  }),
-  z.object({
-    InsufficientStake: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      minimumStake: z.string(),
-      stake: z.string()
-    })
-  }),
-  z.object({
-    FunctionCallError: z.lazy(() => FunctionCallErrorSchema())
-  }),
-  z.object({
-    NewReceiptValidationError: z.lazy(() => ReceiptValidationErrorSchema())
-  }),
-  z.object({
-    OnlyImplicitAccountCreationAllowed: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    DeleteAccountWithLargeState: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.enum(["DelegateActionInvalidSignature"]),
-  z.object({
-    DelegateActionSenderDoesNotMatchTxReceiver: z.object({
-      receiverId: z.lazy(() => AccountIdSchema()),
-      senderId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.enum(["DelegateActionExpired"]),
-  z.object({
-    DelegateActionAccessKeyError: z.lazy(() => InvalidAccessKeyErrorSchema())
-  }),
-  z.object({
-    DelegateActionInvalidNonce: z.object({
-      akNonce: z.number(),
-      delegateNonce: z.number()
-    })
-  }),
-  z.object({
-    DelegateActionNonceTooLarge: z.object({
-      delegateNonce: z.number(),
-      upperBound: z.number()
-    })
-  }),
-  z.object({
-    GlobalContractDoesNotExist: z.object({
-      identifier: z.lazy(() => GlobalContractIdentifierSchema())
-    })
-  })
-]);
-var ActionViewSchema = () => z.union([
-  z.enum(["CreateAccount"]),
-  z.object({
-    DeployContract: z.object({
-      code: z.string()
-    })
-  }),
-  z.object({
-    FunctionCall: z.object({
-      args: z.lazy(() => FunctionArgsSchema()),
-      deposit: z.string(),
-      gas: z.number(),
-      methodName: z.string()
-    })
-  }),
-  z.object({
-    Transfer: z.object({
-      deposit: z.string()
-    })
-  }),
-  z.object({
-    Stake: z.object({
-      publicKey: z.lazy(() => PublicKeySchema()),
-      stake: z.string()
-    })
-  }),
-  z.object({
-    AddKey: z.object({
-      accessKey: z.lazy(() => AccessKeyViewSchema()),
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    DeleteKey: z.object({
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    DeleteAccount: z.object({
-      beneficiaryId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    Delegate: z.object({
-      delegateAction: z.lazy(() => DelegateActionSchema()),
-      signature: z.lazy(() => SignatureSchema())
-    })
-  }),
-  z.object({
-    DeployGlobalContract: z.object({
-      code: z.string()
-    })
-  }),
-  z.object({
-    DeployGlobalContractByAccountId: z.object({
-      code: z.string()
-    })
-  }),
-  z.object({
-    UseGlobalContract: z.object({
-      codeHash: z.lazy(() => CryptoHashSchema())
-    })
-  }),
-  z.object({
-    UseGlobalContractByAccountId: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  })
-]);
-var ActionsValidationErrorSchema = () => z.union([
-  z.enum(["DeleteActionMustBeFinal"]),
-  z.object({
-    TotalPrepaidGasExceeded: z.object({
-      limit: z.number(),
-      totalPrepaidGas: z.number()
-    })
-  }),
-  z.object({
-    TotalNumberOfActionsExceeded: z.object({
-      limit: z.number(),
-      totalNumberOfActions: z.number()
-    })
-  }),
-  z.object({
-    AddKeyMethodNamesNumberOfBytesExceeded: z.object({
-      limit: z.number(),
-      totalNumberOfBytes: z.number()
-    })
-  }),
-  z.object({
-    AddKeyMethodNameLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.enum(["IntegerOverflow"]),
-  z.object({
-    InvalidAccountId: z.object({
-      accountId: z.string()
-    })
-  }),
-  z.object({
-    ContractSizeExceeded: z.object({
-      limit: z.number(),
-      size: z.number()
-    })
-  }),
-  z.object({
-    FunctionCallMethodNameLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    FunctionCallArgumentsLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    UnsuitableStakingKey: z.object({
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.enum(["FunctionCallZeroAttachedGas"]),
-  z.enum(["DelegateActionMustBeOnlyOne"]),
-  z.object({
-    UnsupportedProtocolFeature: z.object({
-      protocolFeature: z.string(),
-      version: z.number()
-    })
-  })
-]);
-var AddKeyActionSchema = () => z.object({
-  accessKey: z.lazy(() => AccessKeySchema()),
-  publicKey: z.lazy(() => PublicKeySchema())
-});
-var BandwidthRequestSchema = () => z.object({
-  requestedValuesBitmap: z.lazy(() => BandwidthRequestBitmapSchema()),
-  toShard: z.number()
-});
-var BandwidthRequestBitmapSchema = () => z.object({
-  data: z.array(z.number())
-});
-var BandwidthRequestsSchema = () => z.object({
-  V1: z.lazy(() => BandwidthRequestsV1Schema())
-});
-var BandwidthRequestsV1Schema = () => z.object({
-  requests: z.array(z.lazy(() => BandwidthRequestSchema()))
-});
-var BlockHeaderViewSchema = () => z.object({
-  approvals: z.array(z.union([z.lazy(() => SignatureSchema()), z.null()])),
-  blockBodyHash: z.optional(
-    z.union([z.lazy(() => CryptoHashSchema()), z.null()])
-  ),
-  blockMerkleRoot: z.lazy(() => CryptoHashSchema()),
-  blockOrdinal: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  challengesResult: z.array(z.lazy(() => SlashedValidatorSchema())),
-  challengesRoot: z.lazy(() => CryptoHashSchema()),
-  chunkEndorsements: z.optional(
-    z.union([z.union([z.array(z.array(z.number())), z.null()]), z.null()])
-  ),
-  chunkHeadersRoot: z.lazy(() => CryptoHashSchema()),
-  chunkMask: z.array(z.boolean()),
-  chunkReceiptsRoot: z.lazy(() => CryptoHashSchema()),
-  chunkTxRoot: z.lazy(() => CryptoHashSchema()),
-  chunksIncluded: z.number(),
-  epochId: z.lazy(() => CryptoHashSchema()),
-  epochSyncDataHash: z.optional(
-    z.union([z.lazy(() => CryptoHashSchema()), z.null()])
-  ),
-  gasPrice: z.string(),
-  hash: z.lazy(() => CryptoHashSchema()),
-  height: z.number(),
-  lastDsFinalBlock: z.lazy(() => CryptoHashSchema()),
-  lastFinalBlock: z.lazy(() => CryptoHashSchema()),
-  latestProtocolVersion: z.number(),
-  nextBpHash: z.lazy(() => CryptoHashSchema()),
-  nextEpochId: z.lazy(() => CryptoHashSchema()),
-  outcomeRoot: z.lazy(() => CryptoHashSchema()),
-  prevHash: z.lazy(() => CryptoHashSchema()),
-  prevHeight: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  prevStateRoot: z.lazy(() => CryptoHashSchema()),
-  randomValue: z.lazy(() => CryptoHashSchema()),
-  rentPaid: z.string(),
-  signature: z.lazy(() => SignatureSchema()),
-  timestamp: z.number(),
-  timestampNanosec: z.string(),
-  totalSupply: z.string(),
-  validatorProposals: z.array(z.lazy(() => ValidatorStakeViewSchema())),
-  validatorReward: z.string()
-});
-var CallResultSchema = () => z.object({
-  logs: z.array(z.string()),
-  result: z.array(z.number())
-});
-var ChunkHeaderViewSchema = () => z.object({
-  balanceBurnt: z.string(),
-  bandwidthRequests: z.optional(
-    z.union([z.lazy(() => BandwidthRequestsSchema()), z.null()])
-  ),
-  chunkHash: z.lazy(() => CryptoHashSchema()),
-  congestionInfo: z.optional(
-    z.union([z.lazy(() => CongestionInfoViewSchema()), z.null()])
-  ),
-  encodedLength: z.number(),
-  encodedMerkleRoot: z.lazy(() => CryptoHashSchema()),
-  gasLimit: z.number(),
-  gasUsed: z.number(),
-  heightCreated: z.number(),
-  heightIncluded: z.number(),
-  outcomeRoot: z.lazy(() => CryptoHashSchema()),
-  outgoingReceiptsRoot: z.lazy(() => CryptoHashSchema()),
-  prevBlockHash: z.lazy(() => CryptoHashSchema()),
-  prevStateRoot: z.lazy(() => CryptoHashSchema()),
-  rentPaid: z.string(),
-  shardId: z.lazy(() => ShardIdSchema()),
-  signature: z.lazy(() => SignatureSchema()),
-  txRoot: z.lazy(() => CryptoHashSchema()),
-  validatorProposals: z.array(z.lazy(() => ValidatorStakeViewSchema())),
-  validatorReward: z.string()
-});
-var CompilationErrorSchema = () => z.union([
-  z.object({
-    CodeDoesNotExist: z.object({
-      accountId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    PrepareError: z.lazy(() => PrepareErrorSchema())
-  }),
-  z.object({
-    WasmerCompileError: z.object({
-      msg: z.string()
-    })
-  })
-]);
-var CongestionControlConfigViewSchema = () => z.object({
-  allowedShardOutgoingGas: z.number(),
-  maxCongestionIncomingGas: z.number(),
-  maxCongestionMemoryConsumption: z.number(),
-  maxCongestionMissedChunks: z.number(),
-  maxCongestionOutgoingGas: z.number(),
-  maxOutgoingGas: z.number(),
-  maxTxGas: z.number(),
-  minOutgoingGas: z.number(),
-  minTxGas: z.number(),
-  outgoingReceiptsBigSizeLimit: z.number(),
-  outgoingReceiptsUsualSizeLimit: z.number(),
-  rejectTxCongestionThreshold: z.number()
-});
-var CongestionInfoViewSchema = () => z.object({
-  allowedShard: z.number(),
-  bufferedReceiptsGas: z.string(),
-  delayedReceiptsGas: z.string(),
-  receiptBytes: z.number()
-});
-var CostGasUsedSchema = () => z.object({
-  cost: z.string(),
-  costCategory: z.string(),
-  gasUsed: z.string()
-});
-var CreateAccountActionSchema = () => z.record(z.string(), z.unknown());
-var CryptoHashSchema = () => z.string();
-var DataReceiptCreationConfigViewSchema = () => z.object({
-  baseCost: z.lazy(() => FeeSchema()),
-  costPerByte: z.lazy(() => FeeSchema())
-});
-var DataReceiverViewSchema = () => z.object({
-  dataId: z.lazy(() => CryptoHashSchema()),
-  receiverId: z.lazy(() => AccountIdSchema())
-});
-var DelegateActionSchema = () => z.object({
-  actions: z.array(z.lazy(() => NonDelegateActionSchema())),
-  maxBlockHeight: z.number(),
-  nonce: z.number(),
-  publicKey: z.lazy(() => PublicKeySchema()),
-  receiverId: z.lazy(() => AccountIdSchema()),
-  senderId: z.lazy(() => AccountIdSchema())
-});
-var DeleteAccountActionSchema = () => z.object({
-  beneficiaryId: z.lazy(() => AccountIdSchema())
-});
-var DeleteKeyActionSchema = () => z.object({
-  publicKey: z.lazy(() => PublicKeySchema())
-});
-var DeployContractActionSchema = () => z.object({
-  code: z.string()
-});
-var DeployGlobalContractActionSchema = () => z.object({
-  code: z.string(),
-  deployMode: z.lazy(() => GlobalContractDeployModeSchema())
-});
-var DirectionSchema = () => z.enum(["Left", "Right"]);
-var ExecutionMetadataViewSchema = () => z.object({
-  gasProfile: z.optional(
-    z.union([
-      z.union([z.array(z.lazy(() => CostGasUsedSchema())), z.null()]),
-      z.null()
-    ])
-  ),
-  version: z.number()
-});
-var ExecutionOutcomeViewSchema = () => z.object({
-  executorId: z.lazy(() => AccountIdSchema()),
-  gasBurnt: z.number(),
-  logs: z.array(z.string()),
-  metadata: z.optional(z.lazy(() => ExecutionMetadataViewSchema())),
-  receiptIds: z.array(z.lazy(() => CryptoHashSchema())),
-  status: z.lazy(() => ExecutionStatusViewSchema()),
-  tokensBurnt: z.string()
-});
-var ExecutionOutcomeWithIdViewSchema = () => z.object({
-  blockHash: z.lazy(() => CryptoHashSchema()),
-  id: z.lazy(() => CryptoHashSchema()),
-  outcome: z.lazy(() => ExecutionOutcomeViewSchema()),
-  proof: z.array(z.lazy(() => MerklePathItemSchema()))
-});
-var ExecutionStatusViewSchema = () => z.union([
-  z.enum(["Unknown"]),
-  z.object({
-    Failure: z.lazy(() => TxExecutionErrorSchema())
-  }),
-  z.object({
-    SuccessValue: z.string()
-  }),
-  z.object({
-    SuccessReceiptId: z.lazy(() => CryptoHashSchema())
-  })
-]);
-var ExtCostsConfigViewSchema = () => z.object({
-  altBn128G1MultiexpBase: z.number(),
-  altBn128G1MultiexpElement: z.number(),
-  altBn128G1SumBase: z.number(),
-  altBn128G1SumElement: z.number(),
-  altBn128PairingCheckBase: z.number(),
-  altBn128PairingCheckElement: z.number(),
-  base: z.number(),
-  bls12381G1MultiexpBase: z.number(),
-  bls12381G1MultiexpElement: z.number(),
-  bls12381G2MultiexpBase: z.number(),
-  bls12381G2MultiexpElement: z.number(),
-  bls12381MapFp2ToG2Base: z.number(),
-  bls12381MapFp2ToG2Element: z.number(),
-  bls12381MapFpToG1Base: z.number(),
-  bls12381MapFpToG1Element: z.number(),
-  bls12381P1DecompressBase: z.number(),
-  bls12381P1DecompressElement: z.number(),
-  bls12381P1SumBase: z.number(),
-  bls12381P1SumElement: z.number(),
-  bls12381P2DecompressBase: z.number(),
-  bls12381P2DecompressElement: z.number(),
-  bls12381P2SumBase: z.number(),
-  bls12381P2SumElement: z.number(),
-  bls12381PairingBase: z.number(),
-  bls12381PairingElement: z.number(),
-  contractCompileBase: z.number(),
-  contractCompileBytes: z.number(),
-  contractLoadingBase: z.number(),
-  contractLoadingBytes: z.number(),
-  ecrecoverBase: z.number(),
-  ed25519VerifyBase: z.number(),
-  ed25519VerifyByte: z.number(),
-  keccak256Base: z.number(),
-  keccak256Byte: z.number(),
-  keccak512Base: z.number(),
-  keccak512Byte: z.number(),
-  logBase: z.number(),
-  logByte: z.number(),
-  promiseAndBase: z.number(),
-  promiseAndPerPromise: z.number(),
-  promiseReturn: z.number(),
-  readCachedTrieNode: z.number(),
-  readMemoryBase: z.number(),
-  readMemoryByte: z.number(),
-  readRegisterBase: z.number(),
-  readRegisterByte: z.number(),
-  ripemd160Base: z.number(),
-  ripemd160Block: z.number(),
-  sha256Base: z.number(),
-  sha256Byte: z.number(),
-  storageHasKeyBase: z.number(),
-  storageHasKeyByte: z.number(),
-  storageIterCreateFromByte: z.number(),
-  storageIterCreatePrefixBase: z.number(),
-  storageIterCreatePrefixByte: z.number(),
-  storageIterCreateRangeBase: z.number(),
-  storageIterCreateToByte: z.number(),
-  storageIterNextBase: z.number(),
-  storageIterNextKeyByte: z.number(),
-  storageIterNextValueByte: z.number(),
-  storageLargeReadOverheadBase: z.number(),
-  storageLargeReadOverheadByte: z.number(),
-  storageReadBase: z.number(),
-  storageReadKeyByte: z.number(),
-  storageReadValueByte: z.number(),
-  storageRemoveBase: z.number(),
-  storageRemoveKeyByte: z.number(),
-  storageRemoveRetValueByte: z.number(),
-  storageWriteBase: z.number(),
-  storageWriteEvictedByte: z.number(),
-  storageWriteKeyByte: z.number(),
-  storageWriteValueByte: z.number(),
-  touchingTrieNode: z.number(),
-  utf16DecodingBase: z.number(),
-  utf16DecodingByte: z.number(),
-  utf8DecodingBase: z.number(),
-  utf8DecodingByte: z.number(),
-  validatorStakeBase: z.number(),
-  validatorTotalStakeBase: z.number(),
-  writeMemoryBase: z.number(),
-  writeMemoryByte: z.number(),
-  writeRegisterBase: z.number(),
-  writeRegisterByte: z.number(),
-  yieldCreateBase: z.number(),
-  yieldCreateByte: z.number(),
-  yieldResumeBase: z.number(),
-  yieldResumeByte: z.number()
-});
-var FeeSchema = () => z.object({
-  execution: z.number(),
-  sendNotSir: z.number(),
-  sendSir: z.number()
-});
-var FinalExecutionOutcomeViewSchema = () => z.object({
-  receiptsOutcome: z.array(z.lazy(() => ExecutionOutcomeWithIdViewSchema())),
-  status: z.lazy(() => FinalExecutionStatusSchema()),
-  transaction: z.lazy(() => SignedTransactionViewSchema()),
-  transactionOutcome: z.lazy(() => ExecutionOutcomeWithIdViewSchema())
-});
-var FinalExecutionOutcomeWithReceiptViewSchema = () => z.object({
-  receipts: z.array(z.lazy(() => ReceiptViewSchema())),
-  receiptsOutcome: z.array(z.lazy(() => ExecutionOutcomeWithIdViewSchema())),
-  status: z.lazy(() => FinalExecutionStatusSchema()),
-  transaction: z.lazy(() => SignedTransactionViewSchema()),
-  transactionOutcome: z.lazy(() => ExecutionOutcomeWithIdViewSchema())
-});
-var FinalExecutionStatusSchema = () => z.union([
-  z.enum(["NotStarted"]),
-  z.enum(["Started"]),
-  z.object({
-    Failure: z.lazy(() => TxExecutionErrorSchema())
-  }),
-  z.object({
-    SuccessValue: z.string()
-  })
-]);
-var FunctionArgsSchema = () => z.string();
-var FunctionCallActionSchema = () => z.object({
-  args: z.string(),
-  deposit: z.string(),
-  gas: z.number(),
-  methodName: z.string()
-});
-var FunctionCallErrorSchema = () => z.union([
-  z.enum(["WasmUnknownError", "_EVMError"]),
-  z.object({
-    CompilationError: z.lazy(() => CompilationErrorSchema())
-  }),
-  z.object({
-    LinkError: z.object({
-      msg: z.string()
-    })
-  }),
-  z.object({
-    MethodResolveError: z.lazy(() => MethodResolveErrorSchema())
-  }),
-  z.object({
-    WasmTrap: z.lazy(() => WasmTrapSchema())
-  }),
-  z.object({
-    HostError: z.lazy(() => HostErrorSchema())
-  }),
-  z.object({
-    ExecutionError: z.string()
-  })
-]);
-var FunctionCallPermissionSchema = () => z.object({
-  allowance: z.optional(z.union([z.union([z.string(), z.null()]), z.null()])),
-  methodNames: z.array(z.string()),
-  receiverId: z.string()
-});
-var GlobalContractDeployModeSchema = () => z.union([z.enum(["CodeHash"]), z.enum(["AccountId"])]);
-var GlobalContractIdentifierSchema = () => z.union([
-  z.object({
-    CodeHash: z.lazy(() => CryptoHashSchema())
-  }),
-  z.object({
-    AccountId: z.lazy(() => AccountIdSchema())
-  })
-]);
-var HostErrorSchema = () => z.union([
-  z.enum(["BadUTF16"]),
-  z.enum(["BadUTF8"]),
-  z.enum(["GasExceeded"]),
-  z.enum(["GasLimitExceeded"]),
-  z.enum(["BalanceExceeded"]),
-  z.enum(["EmptyMethodName"]),
-  z.object({
-    GuestPanic: z.object({
-      panicMsg: z.string()
-    })
-  }),
-  z.enum(["IntegerOverflow"]),
-  z.object({
-    InvalidPromiseIndex: z.object({
-      promiseIdx: z.number()
-    })
-  }),
-  z.enum(["CannotAppendActionToJointPromise"]),
-  z.enum(["CannotReturnJointPromise"]),
-  z.object({
-    InvalidPromiseResultIndex: z.object({
-      resultIdx: z.number()
-    })
-  }),
-  z.object({
-    InvalidRegisterId: z.object({
-      registerId: z.number()
-    })
-  }),
-  z.object({
-    IteratorWasInvalidated: z.object({
-      iteratorIndex: z.number()
-    })
-  }),
-  z.enum(["MemoryAccessViolation"]),
-  z.object({
-    InvalidReceiptIndex: z.object({
-      receiptIndex: z.number()
-    })
-  }),
-  z.object({
-    InvalidIteratorIndex: z.object({
-      iteratorIndex: z.number()
-    })
-  }),
-  z.enum(["InvalidAccountId"]),
-  z.enum(["InvalidMethodName"]),
-  z.enum(["InvalidPublicKey"]),
-  z.object({
-    ProhibitedInView: z.object({
-      methodName: z.string()
-    })
-  }),
-  z.object({
-    NumberOfLogsExceeded: z.object({
-      limit: z.number()
-    })
-  }),
-  z.object({
-    KeyLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    ValueLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    TotalLogLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    NumberPromisesExceeded: z.object({
-      limit: z.number(),
-      numberOfPromises: z.number()
-    })
-  }),
-  z.object({
-    NumberInputDataDependenciesExceeded: z.object({
-      limit: z.number(),
-      numberOfInputDataDependencies: z.number()
-    })
-  }),
-  z.object({
-    ReturnedValueLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    ContractSizeExceeded: z.object({
-      limit: z.number(),
-      size: z.number()
-    })
-  }),
-  z.object({
-    Deprecated: z.object({
-      methodName: z.string()
-    })
-  }),
-  z.object({
-    ECRecoverError: z.object({
-      msg: z.string()
-    })
-  }),
-  z.object({
-    AltBn128InvalidInput: z.object({
-      msg: z.string()
-    })
-  }),
-  z.object({
-    Ed25519VerifyInvalidInput: z.object({
-      msg: z.string()
-    })
-  })
-]);
-var InvalidAccessKeyErrorSchema = () => z.union([
-  z.object({
-    AccessKeyNotFound: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    ReceiverMismatch: z.object({
-      akReceiver: z.string(),
-      txReceiver: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    MethodNameMismatch: z.object({
-      methodName: z.string()
-    })
-  }),
-  z.enum(["RequiresFullAccess"]),
-  z.object({
-    NotEnoughAllowance: z.object({
-      accountId: z.lazy(() => AccountIdSchema()),
-      allowance: z.string(),
-      cost: z.string(),
-      publicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.enum(["DepositWithFunctionCall"])
-]);
-var InvalidTxErrorSchema = () => z.union([
-  z.object({
-    InvalidAccessKeyError: z.lazy(() => InvalidAccessKeyErrorSchema())
-  }),
-  z.object({
-    InvalidSignerId: z.object({
-      signerId: z.string()
-    })
-  }),
-  z.object({
-    SignerDoesNotExist: z.object({
-      signerId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    InvalidNonce: z.object({
-      akNonce: z.number(),
-      txNonce: z.number()
-    })
-  }),
-  z.object({
-    NonceTooLarge: z.object({
-      txNonce: z.number(),
-      upperBound: z.number()
-    })
-  }),
-  z.object({
-    InvalidReceiverId: z.object({
-      receiverId: z.string()
-    })
-  }),
-  z.enum(["InvalidSignature"]),
-  z.object({
-    NotEnoughBalance: z.object({
-      balance: z.string(),
-      cost: z.string(),
-      signerId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.object({
-    LackBalanceForState: z.object({
-      amount: z.string(),
-      signerId: z.lazy(() => AccountIdSchema())
-    })
-  }),
-  z.enum(["CostOverflow"]),
-  z.enum(["InvalidChain"]),
-  z.enum(["Expired"]),
-  z.object({
-    ActionsValidation: z.lazy(() => ActionsValidationErrorSchema())
-  }),
-  z.object({
-    TransactionSizeExceeded: z.object({
-      limit: z.number(),
-      size: z.number()
-    })
-  }),
-  z.enum(["InvalidTransactionVersion"]),
-  z.object({
-    StorageError: z.lazy(() => StorageErrorSchema())
-  }),
-  z.object({
-    ShardCongested: z.object({
-      congestionLevel: z.number(),
-      shardId: z.number()
-    })
-  }),
-  z.object({
-    ShardStuck: z.object({
-      missedChunks: z.number(),
-      shardId: z.number()
-    })
-  })
-]);
-var LimitConfigSchema = () => z.object({
-  accountIdValidityRulesVersion: z.optional(
-    z.lazy(() => AccountIdValidityRulesVersionSchema())
-  ),
-  initialMemoryPages: z.number(),
-  maxActionsPerReceipt: z.number(),
-  maxArgumentsLength: z.number(),
-  maxContractSize: z.number(),
-  maxElementsPerContractTable: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  maxFunctionsNumberPerContract: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  maxGasBurnt: z.number(),
-  maxLengthMethodName: z.number(),
-  maxLengthReturnedData: z.number(),
-  maxLengthStorageKey: z.number(),
-  maxLengthStorageValue: z.number(),
-  maxLocalsPerContract: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  maxMemoryPages: z.number(),
-  maxNumberBytesMethodNames: z.number(),
-  maxNumberInputDataDependencies: z.number(),
-  maxNumberLogs: z.number(),
-  maxNumberRegisters: z.number(),
-  maxPromisesPerFunctionCallAction: z.number(),
-  maxReceiptSize: z.number(),
-  maxRegisterSize: z.number(),
-  maxStackHeight: z.number(),
-  maxTablesPerContract: z.optional(
-    z.union([z.union([z.number(), z.null()]), z.null()])
-  ),
-  maxTotalLogLength: z.number(),
-  maxTotalPrepaidGas: z.number(),
-  maxTransactionSize: z.number(),
-  maxYieldPayloadSize: z.number(),
-  perReceiptStorageProofSizeLimit: z.number(),
-  registersMemoryLimit: z.number(),
-  yieldTimeoutLengthInBlocks: z.number()
-});
-var MerklePathItemSchema = () => z.object({
-  direction: z.lazy(() => DirectionSchema()),
-  hash: z.lazy(() => CryptoHashSchema())
-});
-var MethodResolveErrorSchema = () => z.enum(["MethodEmptyName", "MethodNotFound", "MethodInvalidSignature"]);
-var MissingTrieValueSchema = () => z.object({
-  context: z.lazy(() => MissingTrieValueContextSchema()),
-  hash: z.lazy(() => CryptoHashSchema())
-});
-var MissingTrieValueContextSchema = () => z.union([
-  z.enum(["TrieIterator"]),
-  z.enum(["TriePrefetchingStorage"]),
-  z.enum(["TrieMemoryPartialStorage"]),
-  z.enum(["TrieStorage"])
-]);
-var NonDelegateActionSchema = () => z.union([
-  z.object({
-    CreateAccount: z.lazy(() => CreateAccountActionSchema())
-  }),
-  z.object({
-    DeployContract: z.lazy(() => DeployContractActionSchema())
-  }),
-  z.object({
-    FunctionCall: z.lazy(() => FunctionCallActionSchema())
-  }),
-  z.object({
-    Transfer: z.lazy(() => TransferActionSchema())
-  }),
-  z.object({
-    Stake: z.lazy(() => StakeActionSchema())
-  }),
-  z.object({
-    AddKey: z.lazy(() => AddKeyActionSchema())
-  }),
-  z.object({
-    DeleteKey: z.lazy(() => DeleteKeyActionSchema())
-  }),
-  z.object({
-    DeleteAccount: z.lazy(() => DeleteAccountActionSchema())
-  }),
-  z.object({
-    DeployGlobalContract: z.lazy(() => DeployGlobalContractActionSchema())
-  }),
-  z.object({
-    UseGlobalContract: z.lazy(() => UseGlobalContractActionSchema())
-  })
-]);
-var PrepareErrorSchema = () => z.union([
-  z.enum(["Serialization"]),
-  z.enum(["Deserialization"]),
-  z.enum(["InternalMemoryDeclared"]),
-  z.enum(["GasInstrumentation"]),
-  z.enum(["StackHeightInstrumentation"]),
-  z.enum(["Instantiate"]),
-  z.enum(["Memory"]),
-  z.enum(["TooManyFunctions"]),
-  z.enum(["TooManyLocals"]),
-  z.enum(["TooManyTables"]),
-  z.enum(["TooManyTableElements"])
-]);
-var PublicKeySchema = () => z.string();
-var ReceiptEnumViewSchema = () => z.union([
-  z.object({
-    Action: z.object({
-      actions: z.array(z.lazy(() => ActionViewSchema())),
-      gasPrice: z.string(),
-      inputDataIds: z.array(z.lazy(() => CryptoHashSchema())),
-      isPromiseYield: z.optional(z.boolean()),
-      outputDataReceivers: z.array(z.lazy(() => DataReceiverViewSchema())),
-      signerId: z.lazy(() => AccountIdSchema()),
-      signerPublicKey: z.lazy(() => PublicKeySchema())
-    })
-  }),
-  z.object({
-    Data: z.object({
-      data: z.optional(z.union([z.union([z.string(), z.null()]), z.null()])),
-      dataId: z.lazy(() => CryptoHashSchema()),
-      isPromiseResume: z.optional(z.boolean())
-    })
-  }),
-  z.object({
-    GlobalContractDistribution: z.object({
-      alreadyDeliveredShards: z.array(z.lazy(() => ShardIdSchema())),
-      code: z.string(),
-      id: z.lazy(() => GlobalContractIdentifierSchema()),
-      targetShard: z.lazy(() => ShardIdSchema())
-    })
-  })
-]);
-var ReceiptValidationErrorSchema = () => z.union([
-  z.object({
-    InvalidPredecessorId: z.object({
-      accountId: z.string()
-    })
-  }),
-  z.object({
-    InvalidReceiverId: z.object({
-      accountId: z.string()
-    })
-  }),
-  z.object({
-    InvalidSignerId: z.object({
-      accountId: z.string()
-    })
-  }),
-  z.object({
-    InvalidDataReceiverId: z.object({
-      accountId: z.string()
-    })
-  }),
-  z.object({
-    ReturnedValueLengthExceeded: z.object({
-      length: z.number(),
-      limit: z.number()
-    })
-  }),
-  z.object({
-    NumberInputDataDependenciesExceeded: z.object({
-      limit: z.number(),
-      numberOfInputDataDependencies: z.number()
-    })
-  }),
-  z.object({
-    ActionsValidation: z.lazy(() => ActionsValidationErrorSchema())
-  }),
-  z.object({
-    ReceiptSizeExceeded: z.object({
-      limit: z.number(),
-      size: z.number()
-    })
-  })
-]);
-var ReceiptViewSchema = () => z.object({
-  predecessorId: z.lazy(() => AccountIdSchema()),
-  priority: z.optional(z.number()),
-  receipt: z.lazy(() => ReceiptEnumViewSchema()),
-  receiptId: z.lazy(() => CryptoHashSchema()),
-  receiverId: z.lazy(() => AccountIdSchema())
-});
-var RpcBlockResponseSchema = () => z.object({
-  author: z.lazy(() => AccountIdSchema()),
-  chunks: z.array(z.lazy(() => ChunkHeaderViewSchema())),
-  header: z.lazy(() => BlockHeaderViewSchema())
-});
-var RpcGasPriceResponseSchema = () => z.object({
-  gasPrice: z.string()
-});
-var RpcProtocolConfigResponseSchema = () => z.object({
-  avgHiddenValidatorSeatsPerShard: z.array(z.number()),
-  blockProducerKickoutThreshold: z.number(),
-  chainId: z.string(),
-  chunkProducerKickoutThreshold: z.number(),
-  chunkValidatorOnlyKickoutThreshold: z.number(),
-  dynamicResharding: z.boolean(),
-  epochLength: z.number(),
-  fishermenThreshold: z.string(),
-  gasLimit: z.number(),
-  gasPriceAdjustmentRate: z.array(z.number()),
-  genesisHeight: z.number(),
-  genesisTime: z.string(),
-  maxGasPrice: z.string(),
-  maxInflationRate: z.array(z.number()),
-  maxKickoutStakePerc: z.number(),
-  minGasPrice: z.string(),
-  minimumStakeDivisor: z.number(),
-  minimumStakeRatio: z.array(z.number()),
-  minimumValidatorsPerShard: z.number(),
-  numBlockProducerSeats: z.number(),
-  numBlockProducerSeatsPerShard: z.array(z.number()),
-  numBlocksPerYear: z.number(),
-  onlineMaxThreshold: z.array(z.number()),
-  onlineMinThreshold: z.array(z.number()),
-  protocolRewardRate: z.array(z.number()),
-  protocolTreasuryAccount: z.lazy(() => AccountIdSchema()),
-  protocolUpgradeStakeThreshold: z.array(z.number()),
-  protocolVersion: z.number(),
-  runtimeConfig: z.lazy(() => RuntimeConfigViewSchema()),
-  shardLayout: z.lazy(() => ShardLayoutSchema()),
-  shuffleShardAssignmentForChunkProducers: z.boolean(),
-  targetValidatorMandatesPerShard: z.number(),
-  transactionValidityPeriod: z.number()
-});
-var RpcTransactionResponseSchema = () => z.intersection(
-  z.union([
-    z.lazy(() => FinalExecutionOutcomeWithReceiptViewSchema()),
-    z.lazy(() => FinalExecutionOutcomeViewSchema())
-  ]),
-  z.object({
-    finalExecutionStatus: z.lazy(() => TxExecutionStatusSchema())
-  })
-);
-var RuntimeConfigViewSchema = () => z.object({
-  accountCreationConfig: z.lazy(() => AccountCreationConfigViewSchema()),
-  congestionControlConfig: z.lazy(() => CongestionControlConfigViewSchema()),
-  storageAmountPerByte: z.string(),
-  transactionCosts: z.lazy(() => RuntimeFeesConfigViewSchema()),
-  wasmConfig: z.lazy(() => VMConfigViewSchema()),
-  witnessConfig: z.lazy(() => WitnessConfigViewSchema())
-});
-var RuntimeFeesConfigViewSchema = () => z.object({
-  actionCreationConfig: z.lazy(() => ActionCreationConfigViewSchema()),
-  actionReceiptCreationConfig: z.lazy(() => FeeSchema()),
-  burntGasReward: z.array(z.number()),
-  dataReceiptCreationConfig: z.lazy(
-    () => DataReceiptCreationConfigViewSchema()
-  ),
-  pessimisticGasPriceInflationRatio: z.array(z.number()),
-  storageUsageConfig: z.lazy(() => StorageUsageConfigViewSchema())
-});
-var ShardIdSchema = () => z.number();
-var ShardLayoutSchema = () => z.union([
-  z.object({
-    V0: z.lazy(() => ShardLayoutV0Schema())
-  }),
-  z.object({
-    V1: z.lazy(() => ShardLayoutV1Schema())
-  }),
-  z.object({
-    V2: z.lazy(() => ShardLayoutV2Schema())
-  })
-]);
-var ShardLayoutV0Schema = () => z.object({
-  numShards: z.number(),
-  version: z.number()
-});
-var ShardLayoutV1Schema = () => z.object({
-  boundaryAccounts: z.array(z.lazy(() => AccountIdSchema())),
-  shardsSplitMap: z.optional(
-    z.union([
-      z.union([z.array(z.array(z.lazy(() => ShardIdSchema()))), z.null()]),
-      z.null()
-    ])
-  ),
-  toParentShardMap: z.optional(
-    z.union([
-      z.union([z.array(z.lazy(() => ShardIdSchema())), z.null()]),
-      z.null()
-    ])
-  ),
-  version: z.number()
-});
-var ShardLayoutV2Schema = () => z.object({
-  boundaryAccounts: z.array(z.lazy(() => AccountIdSchema())),
-  idToIndexMap: z.record(z.string(), z.number()),
-  indexToIdMap: z.record(
-    z.string(),
-    z.lazy(() => ShardIdSchema())
-  ),
-  shardIds: z.array(z.lazy(() => ShardIdSchema())),
-  shardsParentMap: z.optional(
-    z.union([
-      z.union([
-        z.record(
-          z.string(),
-          z.lazy(() => ShardIdSchema())
-        ),
-        z.null()
-      ]),
-      z.null()
-    ])
-  ),
-  shardsSplitMap: z.optional(
-    z.union([
-      z.union([
-        z.record(z.string(), z.array(z.lazy(() => ShardIdSchema()))),
-        z.null()
-      ]),
-      z.null()
-    ])
-  ),
-  version: z.number()
-});
-var SignatureSchema = () => z.string();
-var SignedTransactionViewSchema = () => z.object({
-  actions: z.array(z.lazy(() => ActionViewSchema())),
-  hash: z.lazy(() => CryptoHashSchema()),
-  nonce: z.number(),
-  priorityFee: z.optional(z.number()),
-  publicKey: z.lazy(() => PublicKeySchema()),
-  receiverId: z.lazy(() => AccountIdSchema()),
-  signature: z.lazy(() => SignatureSchema()),
-  signerId: z.lazy(() => AccountIdSchema())
-});
-var SlashedValidatorSchema = () => z.object({
-  accountId: z.lazy(() => AccountIdSchema()),
-  isDoubleSign: z.boolean()
-});
-var StakeActionSchema = () => z.object({
-  publicKey: z.lazy(() => PublicKeySchema()),
-  stake: z.string()
-});
-var StateItemSchema = () => z.object({
-  key: z.lazy(() => StoreKeySchema()),
-  value: z.lazy(() => StoreValueSchema())
-});
-var StorageErrorSchema = () => z.union([
-  z.enum(["StorageInternalError"]),
-  z.object({
-    MissingTrieValue: z.lazy(() => MissingTrieValueSchema())
-  }),
-  z.enum(["UnexpectedTrieValue"]),
-  z.object({
-    StorageInconsistentState: z.string()
-  }),
-  z.object({
-    FlatStorageBlockNotSupported: z.string()
-  }),
-  z.object({
-    MemTrieLoadingError: z.string()
-  })
-]);
-var StorageGetModeSchema = () => z.enum(["FlatStorage", "Trie"]);
-var StorageUsageConfigViewSchema = () => z.object({
-  numBytesAccount: z.number(),
-  numExtraBytesRecord: z.number()
-});
-var StoreKeySchema = () => z.string();
-var StoreValueSchema = () => z.string();
-var TransferActionSchema = () => z.object({
-  deposit: z.string()
-});
-var TxExecutionErrorSchema = () => z.union([
-  z.object({
-    ActionError: z.lazy(() => ActionErrorSchema())
-  }),
-  z.object({
-    InvalidTxError: z.lazy(() => InvalidTxErrorSchema())
-  })
-]);
-var TxExecutionStatusSchema = () => z.union([
-  z.enum(["NONE"]),
-  z.enum(["INCLUDED"]),
-  z.enum(["EXECUTED_OPTIMISTIC"]),
-  z.enum(["INCLUDED_FINAL"]),
-  z.enum(["EXECUTED"]),
-  z.enum(["FINAL"])
-]);
-var UseGlobalContractActionSchema = () => z.object({
-  contractIdentifier: z.lazy(() => GlobalContractIdentifierSchema())
-});
-var VMConfigViewSchema = () => z.object({
-  discardCustomSections: z.boolean(),
-  ethImplicitAccounts: z.boolean(),
-  extCosts: z.lazy(() => ExtCostsConfigViewSchema()),
-  fixContractLoadingCost: z.boolean(),
-  globalContractHostFns: z.boolean(),
-  growMemCost: z.number(),
-  implicitAccountCreation: z.boolean(),
-  limitConfig: z.lazy(() => LimitConfigSchema()),
-  reftypesBulkMemory: z.boolean(),
-  regularOpCost: z.number(),
-  saturatingFloatToInt: z.boolean(),
-  storageGetMode: z.lazy(() => StorageGetModeSchema()),
-  vmKind: z.lazy(() => VMKindSchema())
-});
-var VMKindSchema = () => z.union([
-  z.enum(["Wasmer0"]),
-  z.enum(["Wasmtime"]),
-  z.enum(["Wasmer2"]),
-  z.enum(["NearVm"]),
-  z.enum(["NearVm2"])
-]);
-var ValidatorStakeViewSchema = () => z.lazy(() => ValidatorStakeViewV1Schema());
-var ValidatorStakeViewV1Schema = () => z.object({
-  accountId: z.lazy(() => AccountIdSchema()),
-  publicKey: z.lazy(() => PublicKeySchema()),
-  stake: z.string()
-});
-var ViewStateResultSchema = () => z.object({
-  proof: z.optional(z.array(z.string())),
-  values: z.array(z.lazy(() => StateItemSchema()))
-});
-var WasmTrapSchema = () => z.union([
-  z.enum(["Unreachable"]),
-  z.enum(["IncorrectCallIndirectSignature"]),
-  z.enum(["MemoryOutOfBounds"]),
-  z.enum(["CallIndirectOOB"]),
-  z.enum(["IllegalArithmetic"]),
-  z.enum(["MisalignedAtomicAccess"]),
-  z.enum(["IndirectCallToNull"]),
-  z.enum(["StackOverflow"]),
-  z.enum(["GenericTrap"])
-]);
-var WitnessConfigViewSchema = () => z.object({
-  combinedTransactionsSizeLimit: z.number(),
-  mainStorageProofSizeSoftLimit: z.number(),
-  newTransactionsValidationStateSizeSoftLimit: z.number()
-});
-var PATH_TO_METHOD_MAP = {
-  "/EXPERIMENTAL_changes": "EXPERIMENTAL_changes",
-  "/EXPERIMENTAL_changes_in_block": "EXPERIMENTAL_changes_in_block",
-  "/EXPERIMENTAL_congestion_level": "EXPERIMENTAL_congestion_level",
-  "/EXPERIMENTAL_genesis_config": "EXPERIMENTAL_genesis_config",
-  "/EXPERIMENTAL_light_client_block_proof": "EXPERIMENTAL_light_client_block_proof",
-  "/EXPERIMENTAL_light_client_proof": "EXPERIMENTAL_light_client_proof",
-  "/EXPERIMENTAL_maintenance_windows": "EXPERIMENTAL_maintenance_windows",
-  "/EXPERIMENTAL_protocol_config": "EXPERIMENTAL_protocol_config",
-  "/EXPERIMENTAL_receipt": "EXPERIMENTAL_receipt",
-  "/EXPERIMENTAL_split_storage_info": "EXPERIMENTAL_split_storage_info",
-  "/EXPERIMENTAL_tx_status": "EXPERIMENTAL_tx_status",
-  "/EXPERIMENTAL_validators_ordered": "EXPERIMENTAL_validators_ordered",
-  "/block": "block",
-  "/block_effects": "block_effects",
-  "/broadcast_tx_async": "broadcast_tx_async",
-  "/broadcast_tx_commit": "broadcast_tx_commit",
-  "/changes": "changes",
-  "/chunk": "chunk",
-  "/client_config": "client_config",
-  "/gas_price": "gas_price",
-  "/genesis_config": "genesis_config",
-  "/health": "health",
-  "/light_client_proof": "light_client_proof",
-  "/maintenance_windows": "maintenance_windows",
-  "/network_info": "network_info",
-  "/next_light_client_block": "next_light_client_block",
-  "/query": "query",
-  "/send_tx": "send_tx",
-  "/status": "status",
-  "/tx": "tx",
-  "/validators": "validators"
-};
-var METHOD_TO_PATH_MAP = {};
-Object.entries(PATH_TO_METHOD_MAP).forEach(([path, method]) => {
-  METHOD_TO_PATH_MAP[method] = path;
-});
-var RPC_METHODS = Object.values(PATH_TO_METHOD_MAP);
+// src/client/createClient/account/getAccountState.ts
+import { AccountViewSchema, CryptoHashSchema } from "@near-js/jsonrpc-types";
 
 // src/_common/utils/snakeToCamelCase.ts
 var snakeToCamelCase = (obj) => {
@@ -1606,10 +226,10 @@ var fromNearOption = (nearOption) => {
 };
 
 // src/client/createClient/account/getAccountState.ts
-var RpcQueryAccountViewResponseSchema = z2.object({
+var RpcQueryAccountViewResponseSchema = z.object({
   ...AccountViewSchema().shape,
   blockHash: CryptoHashSchema(),
-  blockHeight: z2.number()
+  blockHeight: z.number()
 });
 var transformResult = (result, args) => {
   const camelCased = snakeToCamelCase(result);
@@ -1650,7 +270,8 @@ var createGetAccountState = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/account/getAccountKey.ts
-import * as z3 from "zod/mini";
+import * as z2 from "zod/mini";
+import { AccessKeyViewSchema, CryptoHashSchema as CryptoHashSchema2 } from "@near-js/jsonrpc-types";
 
 // src/client/createClient/account/helpers/transformKey.ts
 var transformKey = (key) => {
@@ -1679,10 +300,10 @@ var transformKey = (key) => {
 };
 
 // src/client/createClient/account/getAccountKey.ts
-var RpcQueryAccessKeyViewResponseSchema = z3.object({
+var RpcQueryAccessKeyViewResponseSchema = z2.object({
   ...AccessKeyViewSchema().shape,
-  blockHash: CryptoHashSchema(),
-  blockHeight: z3.number()
+  blockHash: CryptoHashSchema2(),
+  blockHeight: z2.number()
 });
 var transformResult2 = (result, args) => {
   const camelCased = snakeToCamelCase(result);
@@ -1713,11 +334,12 @@ var createGetAccountKey = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/account/getAccountKeys.ts
-import * as z4 from "zod/mini";
-var RpcQueryAccessKeyListResponseSchema = z4.object({
+import * as z3 from "zod/mini";
+import { AccessKeyListSchema, CryptoHashSchema as CryptoHashSchema3 } from "@near-js/jsonrpc-types";
+var RpcQueryAccessKeyListResponseSchema = z3.object({
   ...AccessKeyListSchema().shape,
-  blockHash: CryptoHashSchema(),
-  blockHeight: z4.number()
+  blockHash: CryptoHashSchema3(),
+  blockHeight: z3.number()
 });
 var transformResult3 = (result, args) => {
   const camelCased = snakeToCamelCase(result);
@@ -1744,12 +366,16 @@ var createGetAccountKeys = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/contract/getContractState.ts
-import * as z5 from "zod/mini";
+import * as z4 from "zod/mini";
 import { base64 } from "@scure/base";
-var RpcQueryViewStateResponseSchema = z5.object({
+import {
+  ViewStateResultSchema,
+  CryptoHashSchema as CryptoHashSchema4
+} from "@near-js/jsonrpc-types";
+var RpcQueryViewStateResponseSchema = z4.object({
   ...ViewStateResultSchema().shape,
-  blockHash: CryptoHashSchema(),
-  blockHeight: z5.number()
+  blockHash: CryptoHashSchema4(),
+  blockHeight: z4.number()
 });
 var transformResult4 = (result, args) => {
   const camelCased = snakeToCamelCase(result);
@@ -1782,12 +408,13 @@ var createGetContractState = ({ sendRequest }) => async (args) => {
 
 // src/client/createClient/contract/callContractReadFunction.ts
 import { base64 as base642 } from "@scure/base";
-import * as z6 from "zod/mini";
+import * as z5 from "zod/mini";
+import { CallResultSchema, CryptoHashSchema as CryptoHashSchema5 } from "@near-js/jsonrpc-types";
 var baseDeserializeResul = ({ rawResult }) => fromJsonBytes(rawResult);
-var RpcCallFunctionResponseSchema = z6.object({
+var RpcCallFunctionResponseSchema = z5.object({
   ...CallResultSchema().shape,
-  blockHash: CryptoHashSchema(),
-  blockHeight: z6.number()
+  blockHash: CryptoHashSchema5(),
+  blockHeight: z5.number()
 });
 var transformResult5 = (result, args) => {
   const camelCased = snakeToCamelCase(result);
@@ -1823,6 +450,7 @@ var createCallContractReadFunction = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/block/getBlock.ts
+import { RpcBlockResponseSchema } from "@near-js/jsonrpc-types";
 var transformResult6 = (result) => {
   const camelCased = snakeToCamelCase(result);
   return RpcBlockResponseSchema().parse(camelCased);
@@ -1838,20 +466,21 @@ var createGetBlock = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/protocol/getGasPrice.ts
-import * as z8 from "zod/mini";
+import * as z7 from "zod/mini";
+import { RpcGasPriceResponseSchema } from "@near-js/jsonrpc-types";
 
 // src/_common/schemas/zod/common.ts
-import * as z7 from "zod/mini";
+import * as z6 from "zod/mini";
 import { base58 } from "@scure/base";
-var Base58StringSchema = z7.string().check(
-  z7.regex(
+var Base58StringSchema = z6.string().check(
+  z6.regex(
     /^[1-9A-HJ-NP-Za-km-z]+$/,
     oneLine(`Base58 string contains invalid characters. Allowed characters:
     123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`)
   )
 );
-var CryptoHashSchema2 = Base58StringSchema.check(
-  z7.refine(
+var CryptoHashSchema6 = Base58StringSchema.check(
+  z6.refine(
     (val) => {
       try {
         const bytes = base58.decode(val);
@@ -1863,9 +492,9 @@ var CryptoHashSchema2 = Base58StringSchema.check(
     { error: "CryptoHash string must decode to 32 bytes" }
   )
 );
-var BlockHashSchema = CryptoHashSchema2;
-var BlockHeightSchema = z7.uint64();
-var BlockIdSchema = z7.union([BlockHeightSchema, BlockHashSchema]);
+var BlockHashSchema = CryptoHashSchema6;
+var BlockHeightSchema = z6.uint64();
+var BlockIdSchema = z6.union([BlockHeightSchema, BlockHashSchema]);
 
 // src/client/createClient/protocol/getGasPrice.ts
 var transformResult7 = (result) => {
@@ -1875,9 +504,9 @@ var transformResult7 = (result) => {
     gasPrice: yoctoNear(valid.gasPrice)
   };
 };
-var GetGasPriceArgsSchema = z8.optional(
-  z8.object({
-    blockId: z8.optional(BlockIdSchema)
+var GetGasPriceArgsSchema = z7.optional(
+  z7.object({
+    blockId: z7.optional(BlockIdSchema)
   })
 );
 var getBlockId = (atMomentOf) => {
@@ -1900,12 +529,17 @@ var createGetGasPrice = ({ sendRequest }) => async (args) => {
 };
 
 // src/client/createClient/protocol/getProtocolConfig.ts
-import * as z9 from "zod/mini";
-var TemporaryProtocolConfigShema = z9.object({
+import * as z8 from "zod/mini";
+import {
+  RpcProtocolConfigResponseSchema,
+  RuntimeConfigViewSchema,
+  VMConfigViewSchema
+} from "@near-js/jsonrpc-types";
+var TemporaryProtocolConfigShema = z8.object({
   ...RpcProtocolConfigResponseSchema().shape,
-  runtimeConfig: z9.object({
+  runtimeConfig: z8.object({
     ...RuntimeConfigViewSchema().shape,
-    wasmConfig: z9.omit(VMConfigViewSchema(), { reftypesBulkMemory: true })
+    wasmConfig: z8.omit(VMConfigViewSchema(), { reftypesBulkMemory: true })
   })
 });
 var transformResult8 = (result) => {
@@ -2396,6 +1030,7 @@ var serializeSignedTransaction = (signedTransaction) => serializeNativeSignedTra
 );
 
 // src/client/createClient/transaction/sendSignedTransaction.ts
+import { RpcTransactionResponseSchema } from "@near-js/jsonrpc-types";
 var transformResult9 = (result) => {
   const camelCased = snakeToCamelCase(result);
   return RpcTransactionResponseSchema().parse(camelCased);