near-api-ts 0.2.0 → 0.2.2

package/dist/index.cjs

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