near-api-ts 0.2.0

package/dist/index.js

@@ -0,0 +1,3169 @@
+// src/client/createClient/createSendRequest.ts
+var createSendRequest = (clientContext) => async ({ body }) => {
+  const rpc = clientContext.regularRpcQueue.next();
+  const response = await fetch(rpc.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...rpc.headers
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 0,
+      ...body
+    })
+  });
+  const { result, error } = await response.json();
+  if (error) throw new Error(error, { cause: error });
+  return result;
+};
+
+// src/client/createClient/account/getAccountState.ts
+import * as z2 from "zod/mini";
+
+// src/_common/transformers/toNative/blockReference.ts
+var toNativeBlockReference = (blockReference, defaultBlockReference) => {
+  if (blockReference === "LatestOptimisticBlock")
+    return { finality: "optimistic" };
+  if (blockReference === "LatestNearFinalBlock")
+    return { finality: "near-final" };
+  if (blockReference === "LatestFinalBlock") return { finality: "final" };
+  if (blockReference === "EarliestAvailableBlock")
+    return { sync_checkpoint: "earliest_available" };
+  if (blockReference === "GenesisBlock") return { sync_checkpoint: "genesis" };
+  if (blockReference && "blockHash" in blockReference)
+    return { block_id: blockReference.blockHash };
+  if (blockReference && "blockHeight" in blockReference)
+    return { block_id: blockReference.blockHeight };
+  if (defaultBlockReference)
+    return toNativeBlockReference(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/_common/utils/snakeToCamelCase.ts
+var snakeToCamelCase = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => snakeToCamelCase(item));
+  }
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    const camelKey = key.replace(
+      /(_\w)/g,
+      (match) => match.charAt(1).toUpperCase()
+    );
+    if (value !== null && typeof value === "object") {
+      acc[camelKey] = snakeToCamelCase(value);
+    } else {
+      acc[camelKey] = value;
+    }
+    return acc;
+  }, {});
+};
+
+// src/_common/utils/tokenConverter/helpers.ts
+var POW10_CACHE = {};
+var pow10 = (decimals) => {
+  const cached = POW10_CACHE[decimals];
+  if (cached !== void 0) return cached;
+  const value = 10n ** BigInt(decimals);
+  POW10_CACHE[decimals] = value;
+  return value;
+};
+var assertValidDecimals = (decimals) => {
+  if (!Number.isInteger(decimals) || decimals < 1 || decimals > 100) {
+    throw new Error("Decimals must be an integer in the range 1..100");
+  }
+};
+
+// src/_common/utils/tokenConverter/convertTokensToUnits.ts
+var assertValidTokens = (tokens, decimals) => {
+  const decimalPattern = new RegExp(`^\\d+(?:\\.\\d{1,${decimals}})?$`);
+  if (!decimalPattern.test(tokens)) {
+    throw new Error(
+      `Tokens must be a positive decimal with up to ${decimals} fractional digits`
+    );
+  }
+};
+var convertTokensToUnits = (tokens, decimals) => {
+  assertValidDecimals(decimals);
+  assertValidTokens(tokens, decimals);
+  const [integerPartRaw, fractionalPartRaw = ""] = tokens.split(".");
+  const scale = pow10(decimals);
+  const integerUnits = BigInt(integerPartRaw) * scale;
+  const fractionalUnits = fractionalPartRaw.length ? BigInt(fractionalPartRaw.padEnd(decimals, "0")) : 0n;
+  return integerUnits + fractionalUnits;
+};
+
+// src/_common/utils/tokenConverter/convertUnitsToTokens.ts
+var assertValidUnits = (units) => {
+  if (typeof units === "string" && !/^\d+$/.test(units)) {
+    throw new Error("Units must be a positive integer string (digits only)");
+  }
+};
+var convertUnitsToTokens = (units, decimals) => {
+  assertValidDecimals(decimals);
+  assertValidUnits(units);
+  const unitsBigInt = BigInt(units);
+  const scale = pow10(decimals);
+  const wholePart = unitsBigInt / scale;
+  const fractionalRemainder = unitsBigInt % scale;
+  if (fractionalRemainder === 0n) return wholePart.toString();
+  const fractionalDigits = fractionalRemainder.toString().padStart(decimals, "0").replace(/0+$/, "");
+  if (fractionalDigits.length === 0) return wholePart.toString();
+  return `${wholePart.toString()}.${fractionalDigits}`;
+};
+
+// src/_common/configs/constants.ts
+var BinaryCryptoKeyLengths = {
+  Ed25519: {
+    // SecretKey + PublicKey
+    PrivateKey: 64,
+    SecretKey: 32,
+    PublicKey: 32
+  },
+  Secp256k1: {
+    // SecretKey + PublicKey
+    PrivateKey: 96,
+    SecretKey: 32,
+    PublicKey: 64
+  }
+};
+var NearDecimals = 24;
+var RefetchBlockHashInterval = 6e5;
+var SignerTaskTtlMs = 6e4;
+
+// src/_common/utils/common.ts
+var oneLine = (msg) => msg.replace(/\s+/g, " ").trim();
+var isNodeJs = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var nodeInspectSymbol = isNodeJs ? Symbol.for("nodejs.util.inspect.custom") : void 0;
+var toJsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value));
+var fromJsonBytes = (bytes) => {
+  const u8 = Array.isArray(bytes) ? new Uint8Array(bytes) : bytes;
+  return JSON.parse(new TextDecoder().decode(u8));
+};
+
+// src/helpers/near.ts
+var cache = {
+  near: /* @__PURE__ */ new WeakMap(),
+  yoctoNear: /* @__PURE__ */ new WeakMap()
+};
+var nearTokenProto = {
+  // Lazy getter - calculate the 'near' value only after the first direct access;
+  // save the result in the cache
+  get near() {
+    const maybeValue = cache.near.get(this);
+    if (maybeValue) return maybeValue;
+    const value = convertUnitsToTokens(this.yoctoNear, NearDecimals);
+    cache.near.set(this, value);
+    return value;
+  },
+  get yoctoNear() {
+    const maybeValue = cache.yoctoNear.get(this);
+    if (maybeValue) return maybeValue;
+    const value = convertTokensToUnits(this.near, NearDecimals);
+    cache.yoctoNear.set(this, value);
+    return value;
+  },
+  // TODO add support for NearToken and avoid creating a new instance if x is NearToken
+  add(x) {
+    return yoctoNear(this.yoctoNear + fromNearOption(x).yoctoNear);
+  },
+  sub(x) {
+    return yoctoNear(this.yoctoNear - fromNearOption(x).yoctoNear);
+  },
+  mul(x) {
+    return yoctoNear(this.yoctoNear * fromNearOption(x).yoctoNear);
+  },
+  gt(x) {
+    return this.yoctoNear > fromNearOption(x).yoctoNear;
+  },
+  lt(x) {
+    return this.yoctoNear < fromNearOption(x).yoctoNear;
+  },
+  toString() {
+    return JSON.stringify({
+      near: this.near,
+      yoctoNear: this.yoctoNear.toString()
+    });
+  },
+  // In Node.js, this allows you to see the near/yoctoNear getter values,
+  // which are not normally visible unless you access them directly.
+  // This does not work in the browser — there you can only see a getter’s value
+  // by explicitly expanding/clicking on it.
+  ...nodeInspectSymbol && {
+    [nodeInspectSymbol](_depth, _opts) {
+      return { near: this.near, yoctoNear: this.yoctoNear };
+    }
+  }
+};
+var yoctoNear = (units) => {
+  const yoctoNear2 = BigInt(units);
+  const obj = Object.create(nearTokenProto);
+  Object.defineProperty(obj, "yoctoNear", {
+    value: yoctoNear2,
+    enumerable: true
+  });
+  return Object.freeze(obj);
+};
+var near = (tokens) => {
+  const obj = Object.create(nearTokenProto);
+  Object.defineProperty(obj, "near", {
+    value: tokens,
+    enumerable: true
+  });
+  return Object.freeze(obj);
+};
+var fromNearOption = (nearOption) => {
+  if ("yoctoNear" in nearOption) return yoctoNear(nearOption.yoctoNear);
+  if ("near" in nearOption) return near(nearOption.near);
+  throw new Error("Invalid nearOption format");
+};
+
+// src/client/createClient/account/getAccountState.ts
+var RpcQueryAccountViewResponseSchema = z2.object({
+  ...AccountViewSchema().shape,
+  blockHash: CryptoHashSchema(),
+  blockHeight: z2.number()
+});
+var transformResult = (result, args) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcQueryAccountViewResponseSchema.parse(camelCased);
+  const lockedBalance = yoctoNear(valid.locked);
+  const totalBalance = yoctoNear(valid.amount).add(lockedBalance);
+  const final = {
+    blockHash: valid.blockHash,
+    blockHeight: valid.blockHeight,
+    accountId: args.accountId,
+    accountState: {
+      balance: {
+        total: totalBalance,
+        locked: lockedBalance
+      },
+      usedStorageBytes: valid.storageUsage,
+      contractWasmHash: valid.codeHash
+    }
+  };
+  if (valid.globalContractAccountId)
+    final.accountState.globalContractAccountId = valid.globalContractAccountId;
+  if (valid.globalContractHash)
+    final.accountState.globalContractHash = valid.globalContractHash;
+  return final;
+};
+var createGetAccountState = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "query",
+      params: {
+        request_type: "view_account",
+        account_id: args.accountId,
+        ...toNativeBlockReference(args.atMomentOf)
+      }
+    }
+  });
+  return transformResult(result, args);
+};
+
+// src/client/createClient/account/getAccountKey.ts
+import * as z3 from "zod/mini";
+
+// src/client/createClient/account/helpers/transformKey.ts
+var transformKey = (key) => {
+  const publicKey = key.publicKey;
+  const nonce = key.accessKey.nonce;
+  if (key.accessKey.permission === "FullAccess")
+    return {
+      accessType: "FullAccess",
+      publicKey,
+      nonce
+    };
+  const { receiverId, methodNames, allowance } = key.accessKey.permission.FunctionCall;
+  const functionCallKey = {
+    accessType: "FunctionCall",
+    publicKey,
+    nonce,
+    contractAccountId: receiverId
+  };
+  if (typeof allowance === "string") {
+    functionCallKey.gasBudget = yoctoNear(allowance);
+  }
+  if (methodNames.length > 0) {
+    functionCallKey.allowedFunctions = methodNames;
+  }
+  return functionCallKey;
+};
+
+// src/client/createClient/account/getAccountKey.ts
+var RpcQueryAccessKeyViewResponseSchema = z3.object({
+  ...AccessKeyViewSchema().shape,
+  blockHash: CryptoHashSchema(),
+  blockHeight: z3.number()
+});
+var transformResult2 = (result, args) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcQueryAccessKeyViewResponseSchema.parse(camelCased);
+  return {
+    blockHash: valid.blockHash,
+    blockHeight: valid.blockHeight,
+    accountId: args.accountId,
+    accountKey: transformKey({
+      accessKey: valid,
+      publicKey: args.publicKey
+    })
+  };
+};
+var createGetAccountKey = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "query",
+      params: {
+        request_type: "view_access_key",
+        account_id: args.accountId,
+        public_key: args.publicKey,
+        ...toNativeBlockReference(args.atMomentOf)
+      }
+    }
+  });
+  return transformResult2(result, args);
+};
+
+// src/client/createClient/account/getAccountKeys.ts
+import * as z4 from "zod/mini";
+var RpcQueryAccessKeyListResponseSchema = z4.object({
+  ...AccessKeyListSchema().shape,
+  blockHash: CryptoHashSchema(),
+  blockHeight: z4.number()
+});
+var transformResult3 = (result, args) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcQueryAccessKeyListResponseSchema.parse(camelCased);
+  return {
+    blockHash: valid.blockHash,
+    blockHeight: valid.blockHeight,
+    accountId: args.accountId,
+    accountKeys: valid.keys.map(transformKey)
+  };
+};
+var createGetAccountKeys = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "query",
+      params: {
+        request_type: "view_access_key_list",
+        account_id: args.accountId,
+        ...toNativeBlockReference(args.atMomentOf)
+      }
+    }
+  });
+  return transformResult3(result, args);
+};
+
+// src/client/createClient/contract/getContractState.ts
+import * as z5 from "zod/mini";
+import { base64 } from "@scure/base";
+var RpcQueryViewStateResponseSchema = z5.object({
+  ...ViewStateResultSchema().shape,
+  blockHash: CryptoHashSchema(),
+  blockHeight: z5.number()
+});
+var transformResult4 = (result, args) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcQueryViewStateResponseSchema.parse(camelCased);
+  const final = {
+    blockHash: valid.blockHash,
+    blockHeight: valid.blockHeight,
+    contractAccountId: args.contractAccountId,
+    contractState: valid.values
+  };
+  if (valid.proof) final.proof = valid.proof;
+  return final;
+};
+var createGetContractState = ({ sendRequest }) => async (args) => {
+  const base64KeyPrefix = args.keyPrefix ? base64.encode(Uint8Array.from(args.keyPrefix)) : "";
+  const result = await sendRequest({
+    body: {
+      method: "query",
+      params: {
+        request_type: "view_state",
+        account_id: args.contractAccountId,
+        prefix_base64: base64KeyPrefix,
+        include_proof: args.includeProof,
+        ...toNativeBlockReference(args.atMomentOf)
+      }
+    }
+  });
+  return transformResult4(result, args);
+};
+
+// src/client/createClient/contract/callContractReadFunction.ts
+import { base64 as base642 } from "@scure/base";
+import * as z6 from "zod/mini";
+var baseDeserializeResul = ({ rawResult }) => fromJsonBytes(rawResult);
+var RpcCallFunctionResponseSchema = z6.object({
+  ...CallResultSchema().shape,
+  blockHash: CryptoHashSchema(),
+  blockHeight: z6.number()
+});
+var transformResult5 = (result, args) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcCallFunctionResponseSchema.parse(camelCased);
+  const transformer = args?.options?.deserializeResult ? args.options.deserializeResult : baseDeserializeResul;
+  return {
+    blockHash: valid.blockHash,
+    blockHeight: valid.blockHeight,
+    result: transformer({ rawResult: valid.result }),
+    logs: valid.logs
+  };
+};
+var serializeFunctionArgs = (args) => {
+  if (args?.options?.serializeArgs)
+    return args.options.serializeArgs({ functionArgs: args.functionArgs });
+  if (args?.functionArgs) return toJsonBytes(args?.functionArgs);
+  return new Uint8Array();
+};
+var createCallContractReadFunction = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "query",
+      params: {
+        request_type: "call_function",
+        account_id: args.contractAccountId,
+        method_name: args.functionName,
+        args_base64: base642.encode(serializeFunctionArgs(args)),
+        ...toNativeBlockReference(args.withStateAt)
+      }
+    }
+  });
+  return transformResult5(result, args);
+};
+
+// src/client/createClient/block/getBlock.ts
+var transformResult6 = (result) => {
+  const camelCased = snakeToCamelCase(result);
+  return RpcBlockResponseSchema().parse(camelCased);
+};
+var createGetBlock = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "block",
+      params: toNativeBlockReference(args?.blockReference)
+    }
+  });
+  return transformResult6(result);
+};
+
+// src/client/createClient/protocol/getGasPrice.ts
+import * as z8 from "zod/mini";
+
+// src/_common/schemas/zod/common.ts
+import * as z7 from "zod/mini";
+import { base58 } from "@scure/base";
+var Base58StringSchema = z7.string().check(
+  z7.regex(
+    /^[1-9A-HJ-NP-Za-km-z]+$/,
+    oneLine(`Base58 string contains invalid characters. Allowed characters:
+    123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`)
+  )
+);
+var CryptoHashSchema2 = Base58StringSchema.check(
+  z7.refine(
+    (val) => {
+      try {
+        const bytes = base58.decode(val);
+        return bytes.length === 32;
+      } catch {
+        return false;
+      }
+    },
+    { error: "CryptoHash string must decode to 32 bytes" }
+  )
+);
+var BlockHashSchema = CryptoHashSchema2;
+var BlockHeightSchema = z7.uint64();
+var BlockIdSchema = z7.union([BlockHeightSchema, BlockHashSchema]);
+
+// src/client/createClient/protocol/getGasPrice.ts
+var transformResult7 = (result) => {
+  const camelCased = snakeToCamelCase(result);
+  const valid = RpcGasPriceResponseSchema().parse(camelCased);
+  return {
+    gasPrice: yoctoNear(valid.gasPrice)
+  };
+};
+var GetGasPriceArgsSchema = z8.optional(
+  z8.object({
+    blockId: z8.optional(BlockIdSchema)
+  })
+);
+var getBlockId = (atMomentOf) => {
+  if (atMomentOf === "LatestOptimisticBlock") return null;
+  if (atMomentOf && "blockHash" in atMomentOf) return atMomentOf.blockHash;
+  if (atMomentOf && "blockHeight" in atMomentOf) return atMomentOf.blockHeight;
+  return null;
+};
+var createGetGasPrice = ({ sendRequest }) => async (args) => {
+  GetGasPriceArgsSchema.parse(args);
+  const result = await sendRequest({
+    body: {
+      method: "gas_price",
+      params: {
+        block_id: getBlockId(args?.atMomentOf)
+      }
+    }
+  });
+  return transformResult7(result);
+};
+
+// src/client/createClient/protocol/getProtocolConfig.ts
+import * as z9 from "zod/mini";
+var TemporaryProtocolConfigShema = z9.object({
+  ...RpcProtocolConfigResponseSchema().shape,
+  runtimeConfig: z9.object({
+    ...RuntimeConfigViewSchema().shape,
+    wasmConfig: z9.omit(VMConfigViewSchema(), { reftypesBulkMemory: true })
+  })
+});
+var transformResult8 = (result) => {
+  const camelCased = snakeToCamelCase(result);
+  return TemporaryProtocolConfigShema.parse(camelCased);
+};
+var createGetProtocolConfig = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "EXPERIMENTAL_protocol_config",
+      params: toNativeBlockReference(args?.atMomentOf)
+    }
+  });
+  return transformResult8(result);
+};
+
+// src/client/createClient/transaction/sendSignedTransaction.ts
+import { base64 as base644 } from "@scure/base";
+
+// src/_common/transformers/toBorshBytes/signedTransaction.ts
+import { serialize } from "borsh";
+
+// src/_common/schemas/borsh/publicKey.ts
+var Ed25519PublicKeyBorshSchema = {
+  struct: {
+    ed25519Key: {
+      struct: {
+        data: { array: { type: "u8", len: 32 } }
+      }
+    }
+  }
+};
+var Secp256k1PublicKeyBorshSchema = {
+  struct: {
+    secp256k1Key: {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    }
+  }
+};
+var publicKeyBorshSchema = {
+  enum: [Ed25519PublicKeyBorshSchema, Secp256k1PublicKeyBorshSchema]
+};
+
+// src/_common/schemas/borsh/actions/createAccount.ts
+var createAccountActionBorshSchema = {
+  struct: {
+    createAccount: {
+      struct: {}
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/transfer.ts
+var transferActionBorshSchema = {
+  struct: {
+    transfer: {
+      struct: {
+        deposit: "u128"
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/addKey.ts
+var fullAccessPermissionBorshSchema = {
+  struct: {
+    fullAccess: {
+      struct: {}
+    }
+  }
+};
+var functionCallPermissionBorshSchema = {
+  struct: {
+    functionCall: {
+      struct: {
+        allowance: { option: "u128" },
+        receiverId: "string",
+        methodNames: { array: { type: "string" } }
+      }
+    }
+  }
+};
+var accessKeyBorshSchema = {
+  struct: {
+    nonce: "u64",
+    permission: {
+      enum: [
+        functionCallPermissionBorshSchema,
+        fullAccessPermissionBorshSchema
+      ]
+    }
+  }
+};
+var addKeyActionBorshSchema = {
+  struct: {
+    addKey: {
+      struct: {
+        publicKey: publicKeyBorshSchema,
+        accessKey: accessKeyBorshSchema
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/deployContract.ts
+var deployContractActionBorshSchema = {
+  struct: {
+    deployContract: {
+      struct: {
+        code: { array: { type: "u8" } }
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/deployGlobalContract.ts
+var codeHashModeBorshSchema = {
+  struct: {
+    CodeHash: { struct: {} }
+  }
+};
+var accountIdModeBorshSchema = {
+  struct: {
+    AccountId: { struct: {} }
+  }
+};
+var deployGlobalContractActionBorshSchema = {
+  struct: {
+    deployGlobalContract: {
+      struct: {
+        code: { array: { type: "u8" } },
+        deployMode: {
+          enum: [codeHashModeBorshSchema, accountIdModeBorshSchema]
+        }
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/useGlobalContract.ts
+var codeHashIdentifierBorshSchema = {
+  struct: {
+    CodeHash: { array: { type: "u8", len: 32 } }
+  }
+};
+var accountIdIdentifierBorshSchema = {
+  struct: {
+    AccountId: "string"
+  }
+};
+var useGlobalContractActionBorshSchema = {
+  struct: {
+    useGlobalContract: {
+      struct: {
+        contractIdentifier: {
+          enum: [codeHashIdentifierBorshSchema, accountIdIdentifierBorshSchema]
+        }
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/functionCall.ts
+var functionCallActionBorshSchema = {
+  struct: {
+    functionCall: {
+      struct: {
+        methodName: "string",
+        args: { array: { type: "u8" } },
+        gas: "u64",
+        deposit: "u128"
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/stake.ts
+var stakeActionBorshSchema = {
+  struct: {
+    stake: {
+      struct: {
+        stake: "u128",
+        publicKey: publicKeyBorshSchema
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/deleteKey.ts
+var deleteKeyActionBorshSchema = {
+  struct: {
+    deleteKey: {
+      struct: {
+        publicKey: publicKeyBorshSchema
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/actions/deleteAccount.ts
+var deleteAccountActionBorshSchema = {
+  struct: {
+    deleteAccount: {
+      struct: {
+        beneficiaryId: "string"
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/delegateAction.ts
+var allowedActionBorshSchema = {
+  enum: [
+    createAccountActionBorshSchema,
+    deployContractActionBorshSchema,
+    functionCallActionBorshSchema,
+    transferActionBorshSchema,
+    stakeActionBorshSchema,
+    addKeyActionBorshSchema,
+    deleteKeyActionBorshSchema,
+    deleteAccountActionBorshSchema,
+    { struct: { signedDelegate: "string" } },
+    // TODO is it possible to rid this placeholder and keep enum order?
+    deployGlobalContractActionBorshSchema,
+    useGlobalContractActionBorshSchema
+  ]
+};
+var delegateActionBorshSchema = {
+  struct: {
+    senderId: "string",
+    publicKey: publicKeyBorshSchema,
+    actions: { array: { type: allowedActionBorshSchema } },
+    receiverId: "string",
+    nonce: "u64",
+    maxBlockHeight: "u64"
+  }
+};
+
+// src/_common/schemas/borsh/signature.ts
+var Ed25519SignatureBorshSchema = {
+  struct: {
+    ed25519Signature: {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    }
+  }
+};
+var Secp256k1SignatureBorshSchema = {
+  struct: {
+    secp256k1Signature: {
+      struct: {
+        data: { array: { type: "u8", len: 65 } }
+      }
+    }
+  }
+};
+var signatureBorshSchema = {
+  enum: [Ed25519SignatureBorshSchema, Secp256k1SignatureBorshSchema]
+};
+
+// src/_common/schemas/borsh/actions/signedDelegate.ts
+var signedDelegateActionBorshSchema = {
+  struct: {
+    signedDelegate: {
+      struct: {
+        delegateAction: delegateActionBorshSchema,
+        signature: signatureBorshSchema
+      }
+    }
+  }
+};
+
+// src/_common/schemas/borsh/transaction.ts
+var actionBorshSchema = {
+  enum: [
+    createAccountActionBorshSchema,
+    deployContractActionBorshSchema,
+    functionCallActionBorshSchema,
+    transferActionBorshSchema,
+    stakeActionBorshSchema,
+    addKeyActionBorshSchema,
+    deleteKeyActionBorshSchema,
+    deleteAccountActionBorshSchema,
+    signedDelegateActionBorshSchema,
+    deployGlobalContractActionBorshSchema,
+    useGlobalContractActionBorshSchema
+  ]
+};
+var transactionBorshSchema = {
+  struct: {
+    signerId: "string",
+    publicKey: publicKeyBorshSchema,
+    nonce: "u64",
+    receiverId: "string",
+    blockHash: { array: { type: "u8", len: 32 } },
+    actions: { array: { type: actionBorshSchema } }
+  }
+};
+
+// src/_common/schemas/borsh/signedTransaction.ts
+var signedTransactionBorshSchema = {
+  struct: {
+    transaction: transactionBorshSchema,
+    signature: signatureBorshSchema
+  }
+};
+
+// src/_common/transformers/curveString.ts
+import { base58 as base582 } from "@scure/base";
+var toEd25519CurveString = (u8Data) => `ed25519:${base582.encode(u8Data)}`;
+var toSecp256k1CurveString = (u8Data) => `secp256k1:${base582.encode(u8Data)}`;
+var fromCurveString = (value) => {
+  const [curve, base58String] = value.split(":");
+  return {
+    curve,
+    u8Data: base582.decode(base58String)
+  };
+};
+
+// src/_common/transformers/toNative/signature.ts
+var toNativeSignature = (signature) => {
+  const { curve, u8Data } = fromCurveString(signature);
+  if (curve === "ed25519") return { ed25519Signature: { data: u8Data } };
+  return { secp256k1Signature: { data: u8Data } };
+};
+
+// src/_common/transformers/toNative/transaction.ts
+import { base58 as base583 } from "@scure/base";
+
+// src/_common/transformers/toNative/publicKey.ts
+var toNativePublicKey = (publicKey) => {
+  const { curve, u8Data } = fromCurveString(publicKey);
+  if (curve === "ed25519") return { ed25519Key: { data: u8Data } };
+  return { secp256k1Key: { data: u8Data } };
+};
+
+// src/_common/transformers/toNative/actions/transfer.ts
+var toNativeTransferAction = (action) => ({
+  transfer: {
+    deposit: fromNearOption(action.params.amount).yoctoNear
+  }
+});
+
+// src/_common/transformers/toNative/actions/createAccount.ts
+var toNativeCreateAccountAction = () => ({
+  createAccount: {}
+});
+
+// src/_common/transformers/toNative/actions/addKey.ts
+var getPermission = (params) => {
+  if (params.accessType === "FullAccess") return { fullAccess: {} };
+  const { contractAccountId, gasBudget, allowedFunctions } = params;
+  return {
+    functionCall: {
+      receiverId: contractAccountId,
+      allowance: gasBudget && fromNearOption(gasBudget).yoctoNear,
+      methodNames: allowedFunctions ?? []
+    }
+  };
+};
+var toNativeAddKeyAction = (action) => ({
+  addKey: {
+    publicKey: toNativePublicKey(action.params.publicKey),
+    accessKey: {
+      nonce: 0n,
+      // Placeholder; It's not usable anymore: https://gov.near.org/t/issue-with-access-key-nonce/749
+      permission: getPermission(action.params)
+    }
+  }
+});
+
+// src/_common/transformers/toNative/actions/deployContract.ts
+import { base64 as base643 } from "@scure/base";
+var toNativeDeployContractAction = (action) => {
+  const code = action.params.wasmBytes ? action.params.wasmBytes : base643.decode(action.params.wasmBase64);
+  return {
+    deployContract: { code }
+  };
+};
+
+// src/helpers/gas.ts
+var TeraCoefficient = 10n ** 12n;
+var gas = (gas2) => {
+  return {
+    gas: BigInt(gas2),
+    teraGas: String(BigInt(gas2) / TeraCoefficient)
+    // We don't keep decimals here
+  };
+};
+var teraGas = (teraGas2) => {
+  return {
+    gas: BigInt(teraGas2) * TeraCoefficient,
+    teraGas: teraGas2
+  };
+};
+var fromGasOption = (gasOption) => {
+  if ("teraGas" in gasOption) return teraGas(gasOption.teraGas);
+  if ("gas" in gasOption) return gas(gasOption.gas);
+  throw new Error("Invalid gas option");
+};
+
+// src/_common/transformers/contract.ts
+var toContractFnArgsBytes = (args) => {
+  if (args.fnArgsBytes) return args.fnArgsBytes;
+  if (args.fnArgsJson) return toJsonBytes(args.fnArgsJson);
+  return new Uint8Array();
+};
+
+// src/_common/transformers/toNative/actions/functionCall.ts
+var toNativeFunctionCallAction = (action) => {
+  const { functionName, attachedDeposit, gasLimit } = action.params;
+  return {
+    functionCall: {
+      methodName: functionName,
+      args: toContractFnArgsBytes(action.params),
+      gas: fromGasOption(gasLimit).gas,
+      deposit: attachedDeposit ? fromNearOption(attachedDeposit).yoctoNear : 0n
+    }
+  };
+};
+
+// src/_common/transformers/toNative/actions/deleteKey.ts
+var toNativeDeleteKeyAction = (action) => ({
+  deleteKey: {
+    publicKey: toNativePublicKey(action.params.publicKey)
+  }
+});
+
+// src/_common/transformers/toNative/actions/deleteAccount.ts
+var toNativeDeleteAccountAction = (action) => ({
+  deleteAccount: {
+    beneficiaryId: action.params.beneficiaryAccountId
+  }
+});
+
+// src/_common/transformers/toNative/transaction.ts
+var toNativeAction = (action) => {
+  if (action.actionType === "Transfer") return toNativeTransferAction(action);
+  if (action.actionType === "CreateAccount")
+    return toNativeCreateAccountAction();
+  if (action.actionType === "AddKey") return toNativeAddKeyAction(action);
+  if (action.actionType === "DeployContract")
+    return toNativeDeployContractAction(action);
+  if (action.actionType === "FunctionCall")
+    return toNativeFunctionCallAction(action);
+  if (action.actionType === "DeleteKey") return toNativeDeleteKeyAction(action);
+  if (action.actionType === "DeleteAccount")
+    return toNativeDeleteAccountAction(action);
+  throw new Error("Invalid transaction action type");
+};
+var toNativeActions = (transaction) => {
+  if (transaction.action) return [toNativeAction(transaction.action)];
+  if (transaction.actions)
+    return transaction.actions.map((action) => toNativeAction(action));
+  return [];
+};
+var toNativeTransaction = (transaction) => ({
+  signerId: transaction.signerAccountId,
+  publicKey: toNativePublicKey(transaction.signerPublicKey),
+  actions: toNativeActions(transaction),
+  receiverId: transaction.receiverAccountId,
+  nonce: BigInt(transaction.nonce),
+  blockHash: base583.decode(transaction.blockHash)
+});
+var TransactionExecutionStatusMap = {
+  None: "NONE",
+  Included: "INCLUDED",
+  ExecutedOptimistic: "EXECUTED_OPTIMISTIC",
+  IncludedFinal: "INCLUDED_FINAL",
+  Executed: "EXECUTED",
+  Final: "FINAL"
+};
+var toNativeTransactionExecutionStatus = (status) => status ? TransactionExecutionStatusMap[status] : TransactionExecutionStatusMap.ExecutedOptimistic;
+
+// src/_common/transformers/toNative/signedTransaction.ts
+var toNativeSignedTransaction = (signedTransaction) => ({
+  transaction: toNativeTransaction(signedTransaction.transaction),
+  signature: toNativeSignature(signedTransaction.signature)
+});
+
+// src/_common/transformers/toBorshBytes/signedTransaction.ts
+var serializeNativeSignedTransaction = (nativeSignedTransaction) => serialize(signedTransactionBorshSchema, nativeSignedTransaction);
+var serializeSignedTransaction = (signedTransaction) => serializeNativeSignedTransaction(
+  toNativeSignedTransaction(signedTransaction)
+);
+
+// src/client/createClient/transaction/sendSignedTransaction.ts
+var transformResult9 = (result) => {
+  const camelCased = snakeToCamelCase(result);
+  return RpcTransactionResponseSchema().parse(camelCased);
+};
+var createSendSignedTransaction = ({ sendRequest }) => async (args) => {
+  const result = await sendRequest({
+    body: {
+      method: "send_tx",
+      params: {
+        signed_tx_base64: base644.encode(
+          serializeSignedTransaction(args.signedTransaction)
+        ),
+        wait_until: toNativeTransactionExecutionStatus(args?.waitUntil)
+      }
+    }
+  });
+  return transformResult9(result);
+};
+
+// src/_common/utils/createCircularQueue.ts
+var createCircularQueue = (arr) => {
+  const state = {
+    items: [...arr],
+    current: 0
+  };
+  const next = () => {
+    const value = state.items[state.current];
+    state.current = (state.current + 1) % state.items.length;
+    return value;
+  };
+  const remove = (value) => {
+    const idx = state.items.indexOf(value);
+    if (idx === -1) return false;
+    if (idx < state.current || idx === state.current && state.current === state.items.length - 1) {
+      state.current = (state.current - 1 + state.items.length) % state.items.length;
+    }
+    state.items.splice(idx, 1);
+    if (state.current >= state.items.length) state.current = 0;
+    return true;
+  };
+  const getAll = () => [...state.items];
+  return {
+    next,
+    remove,
+    getAll,
+    size: () => state.items.length
+  };
+};
+
+// src/client/createClient/createClient.ts
+var createClient = ({ network }) => {
+  const context = {
+    regularRpcQueue: createCircularQueue(network.rpcs.regular),
+    archivalRpcQueue: createCircularQueue(network.rpcs.archival)
+  };
+  context.sendRequest = createSendRequest(context);
+  return {
+    getAccountState: createGetAccountState(context),
+    getAccountKey: createGetAccountKey(context),
+    getAccountKeys: createGetAccountKeys(context),
+    getContractState: createGetContractState(context),
+    callContractReadFunction: createCallContractReadFunction(context),
+    getBlock: createGetBlock(context),
+    getGasPrice: createGetGasPrice(context),
+    getProtocolConfig: createGetProtocolConfig(context),
+    sendSignedTransaction: createSendSignedTransaction(context)
+  };
+};
+
+// src/client/presets/networks.ts
+var mainnet = {
+  rpcs: {
+    regular: [
+      { url: "https://free.rpc.fastnear.com" },
+      { url: "https://near.blockpi.network/v1/rpc/public" }
+    ],
+    archival: []
+  }
+};
+var testnet = {
+  rpcs: {
+    regular: [
+      { url: "https://rpc.testnet.near.org" },
+      { url: "https://test.rpc.fastnear.com" }
+    ],
+    archival: []
+  }
+};
+
+// src/helpers/crypto/getTransactionHash.ts
+import { sha256 } from "@noble/hashes/sha2";
+import { base58 as base584 } from "@scure/base";
+
+// src/_common/transformers/toBorshBytes/transaction.ts
+import { serialize as serialize2 } from "borsh";
+var serializeNativeTransaction = (nativeTransaction) => serialize2(transactionBorshSchema, nativeTransaction);
+var serializeTransaction = (transaction) => serializeNativeTransaction(toNativeTransaction(transaction));
+
+// src/helpers/crypto/getTransactionHash.ts
+var getTransactionHash = (transaction) => {
+  const transactionBorshBytes = serializeTransaction(transaction);
+  const u8TransactionHash = sha256(transactionBorshBytes);
+  return {
+    transactionHash: base584.encode(u8TransactionHash),
+    u8TransactionHash
+  };
+};
+
+// src/helpers/crypto/sign.ts
+import * as v2 from "valibot";
+import { ed25519 } from "@noble/curves/ed25519";
+import { secp256k1 } from "@noble/curves/secp256k1";
+
+// src/_common/schemas/valibot/privateKey.ts
+import * as v from "valibot";
+var { Ed25519, Secp256k1 } = BinaryCryptoKeyLengths;
+var BinarySecp256k1PrivateKeySchema = v.pipe(
+  v.instance(Uint8Array),
+  v.length(
+    Secp256k1.PrivateKey,
+    `Length of binary secp256k1 private key should be ${Secp256k1.PrivateKey}`
+  )
+);
+var BinaryEd25519PrivateKeySchema = v.pipe(
+  v.instance(Uint8Array),
+  v.length(
+    Ed25519.PrivateKey,
+    `Length of binary ed25519 private key should be ${Ed25519.PrivateKey}`
+  )
+);
+
+// src/helpers/crypto/sign.ts
+var { Ed25519: Ed255192, Secp256k1: Secp256k12 } = BinaryCryptoKeyLengths;
+var getBinaryEd25519SecretKey = (u8PrivateKey) => v2.parse(BinaryEd25519PrivateKeySchema, u8PrivateKey).slice(0, Ed255192.SecretKey);
+var signByEd25519Key = (message, u8PrivateKey) => {
+  const u8SecretKey = getBinaryEd25519SecretKey(u8PrivateKey);
+  const u8Signature = ed25519.sign(message, u8SecretKey);
+  return {
+    signature: toEd25519CurveString(u8Signature),
+    u8Signature
+  };
+};
+var getBinarySecp256k1SecretKey = (u8PrivateKey) => v2.parse(BinarySecp256k1PrivateKeySchema, u8PrivateKey).slice(0, Secp256k12.SecretKey);
+var signBySecp256k1Key = (message, u8PrivateKey) => {
+  const u8SecretKey = getBinarySecp256k1SecretKey(u8PrivateKey);
+  const signatureObj = secp256k1.sign(message, u8SecretKey);
+  const u8Signature = new Uint8Array([
+    ...signatureObj.toBytes(),
+    signatureObj.recovery
+  ]);
+  return {
+    signature: toSecp256k1CurveString(u8Signature),
+    u8Signature
+  };
+};
+var sign = ({ message, privateKey }) => {
+  const { curve, u8Data: u8PrivateKey } = fromCurveString(privateKey);
+  return curve === "ed25519" ? signByEd25519Key(message, u8PrivateKey) : signBySecp256k1Key(message, u8PrivateKey);
+};
+
+// src/keyServices/memoryKeyService/createSignTransaction.ts
+var createSignTransaction = (context) => async (transaction) => {
+  const privateKey = context.findPrivateKey(transaction.signerPublicKey);
+  const { transactionHash, u8TransactionHash } = getTransactionHash(transaction);
+  const { signature } = sign({ message: u8TransactionHash, privateKey });
+  return {
+    transaction,
+    transactionHash,
+    signature
+  };
+};
+
+// src/helpers/crypto/getPublicKey.ts
+import * as v3 from "valibot";
+var { Ed25519: Ed255193, Secp256k1: Secp256k13 } = BinaryCryptoKeyLengths;
+var getBinaryEd25519PublicKey = (u8Ed25519PrivateKey) => {
+  const validEd25519PrivateKey = v3.parse(
+    BinaryEd25519PrivateKeySchema,
+    u8Ed25519PrivateKey
+  );
+  return validEd25519PrivateKey.slice(Ed255193.SecretKey);
+};
+var getEd25519PublicKey = (u8PrivateKey) => {
+  const u8PublicKey = getBinaryEd25519PublicKey(u8PrivateKey);
+  return toEd25519CurveString(u8PublicKey);
+};
+var getBinarySecp256k1PublicKey = (u8Secp256k1PrivateKey) => {
+  const validU8PrivateKey = v3.parse(
+    BinarySecp256k1PrivateKeySchema,
+    u8Secp256k1PrivateKey
+  );
+  return validU8PrivateKey.slice(Secp256k13.SecretKey);
+};
+var getSecp256k1PublicKey = (u8Secp256k1PrivateKey) => {
+  const u8PublicKey = getBinarySecp256k1PublicKey(u8Secp256k1PrivateKey);
+  return toSecp256k1CurveString(u8PublicKey);
+};
+var getPublicKey = (privateKey) => {
+  const { curve, u8Data: u8PrivateKey } = fromCurveString(privateKey);
+  return curve === "ed25519" ? getEd25519PublicKey(u8PrivateKey) : getSecp256k1PublicKey(u8PrivateKey);
+};
+
+// src/keyServices/memoryKeyService/parseKeySources.ts
+var parseKeySource = (keySource) => {
+  if ("privateKey" in keySource) {
+    return {
+      publicKey: getPublicKey(keySource.privateKey),
+      privateKey: keySource.privateKey
+    };
+  }
+  if ("seedPhrase" in keySource) {
+    return {
+      publicKey: "ed25519:213",
+      privateKey: "ed25519:213"
+    };
+  }
+  throw new Error("Unknown keySource");
+};
+var parseKeySources = (params) => {
+  if (params.keySource) {
+    const { publicKey, privateKey } = parseKeySource(params.keySource);
+    return { [publicKey]: privateKey };
+  }
+  if (params.keySources)
+    return Object.fromEntries(
+      params.keySources.map((keySource) => {
+        const { publicKey, privateKey } = parseKeySource(keySource);
+        return [publicKey, privateKey];
+      })
+    );
+  throw new Error(
+    "Cannot create MemoryKeyService - no private keys were found"
+  );
+};
+
+// src/keyServices/memoryKeyService/createFindPrivateKey.ts
+var createFindPrivateKey = (keyPairs) => (publicKey) => {
+  const privateKey = keyPairs[publicKey];
+  if (keyPairs[publicKey]) return privateKey;
+  throw new Error(
+    `Cannot find a corresponding private key for '${publicKey}'`
+  );
+};
+
+// src/keyServices/memoryKeyService/createMemoryKeyService.ts
+var createMemoryKeyService = async (params) => {
+  const context = {
+    keyPairs: parseKeySources(params)
+  };
+  context.findPrivateKey = createFindPrivateKey(context.keyPairs);
+  return {
+    signTransaction: createSignTransaction(context),
+    getKeyPairs: () => context.keyPairs
+  };
+};
+
+// src/signers/memorySigner/keyPool/createFindKeyForTask.ts
+var findSigningKey = (keyPriority, keyList) => {
+  if (keyPriority.type === "FullAccess") {
+    return keyList.fullAccess.find((key) => !key.isLocked);
+  }
+  return keyList.functionCall.find((key) => {
+    const isUnlocked = key.isLocked === false;
+    const isContractIdMatch = key.contractAccountId === keyPriority.contractAccountId;
+    const isFnCallAllowed = key.allowedFunctions === void 0 || key.allowedFunctions.includes(keyPriority.calledFnName);
+    return isUnlocked && isContractIdMatch && isFnCallAllowed;
+  });
+};
+var createFindKeyForTask = (keyList) => (task) => {
+  for (const keyPriority of task.signingKeyPriority) {
+    const key = findSigningKey(keyPriority, keyList);
+    if (key) return key;
+  }
+};
+
+// src/signers/memorySigner/keyPool/createIsKeyForTaskExist.ts
+var isKeyExist = (keyPriority, keyList) => {
+  if (keyPriority.type === "FullAccess") return keyList.fullAccess.length > 0;
+  return keyList.functionCall.find((key) => {
+    const isContractIdMatch = key.contractAccountId === keyPriority.contractAccountId;
+    const isFnCallAllowed = key.allowedFunctions === void 0 || key.allowedFunctions.includes(keyPriority.calledFnName);
+    return isContractIdMatch && isFnCallAllowed;
+  });
+};
+var createIsKeyForTaskExist = (keyList) => (task) => task.signingKeyPriority.some(
+  (keyPriority) => isKeyExist(keyPriority, keyList)
+);
+
+// src/signers/memorySigner/keyPool/helpers/keyUtils.ts
+var createLock = (key) => () => {
+  key.isLocked = true;
+  console.log("Key locked", key.publicKey);
+};
+var createUnlock = (key) => () => {
+  key.isLocked = false;
+  console.log("Key unlocked", key.publicKey);
+};
+var createIncrementNonce = (key) => () => {
+  key.nonce = key.nonce + 1;
+};
+
+// src/signers/memorySigner/keyPool/getFullAccessKeyList.ts
+var transformKey2 = (fullAccessKey, keyPairs) => {
+  const { publicKey, nonce } = fullAccessKey;
+  const key = {
+    type: "FullAccess",
+    publicKey,
+    privateKey: keyPairs[publicKey],
+    isLocked: false,
+    nonce
+  };
+  key.lock = createLock(key);
+  key.unlock = createUnlock(key);
+  key.incrementNonce = createIncrementNonce(key);
+  return key;
+};
+var getFullAccessKeyList = (accountKeys, signerContext) => {
+  const keyPairs = signerContext.keyService.getKeyPairs();
+  return accountKeys.filter(
+    ({ publicKey, accessType }) => Object.hasOwn(keyPairs, publicKey) && accessType === "FullAccess"
+  ).map((key) => transformKey2(key, keyPairs));
+};
+
+// src/signers/memorySigner/keyPool/getFunctionCallKeyList.ts
+var transformKey3 = (functionCallKey, keyPairs) => {
+  const { publicKey, nonce, contractAccountId, allowedFunctions } = functionCallKey;
+  const key = {
+    type: "FunctionCall",
+    // TODO Rename to accessType
+    publicKey,
+    privateKey: keyPairs[publicKey],
+    isLocked: false,
+    nonce,
+    contractAccountId,
+    allowedFunctions
+  };
+  key.lock = createLock(key);
+  key.unlock = createUnlock(key);
+  key.incrementNonce = createIncrementNonce(key);
+  return key;
+};
+var getFunctionCallKeyList = (accountKeys, signerContext) => {
+  const keyPairs = signerContext.keyService.getKeyPairs();
+  return accountKeys.filter(
+    ({ publicKey, accessType }) => Object.hasOwn(keyPairs, publicKey) && accessType === "FunctionCall"
+  ).map((key) => transformKey3(key, keyPairs));
+};
+
+// src/signers/memorySigner/keyPool/createKeyPool.ts
+var getAllowedSigningKeys = (signerContext, accountKeys) => {
+  if (!signerContext.signingKeys) return accountKeys;
+  const set = new Set(signerContext.signingKeys);
+  return accountKeys.filter((key) => set.has(key.publicKey));
+};
+var createKeyPool = async (signerContext) => {
+  const { accountKeys } = await signerContext.client.getAccountKeys({
+    accountId: signerContext.signerAccountId
+  });
+  const filteredKeys = getAllowedSigningKeys(signerContext, accountKeys);
+  const keyList = {
+    fullAccess: getFullAccessKeyList(filteredKeys, signerContext),
+    functionCall: getFunctionCallKeyList(filteredKeys, signerContext)
+  };
+  if (keyList.fullAccess.length === 0 && keyList.functionCall.length === 0)
+    throw new Error("Cannot create a signer with no account keys");
+  return {
+    findKeyForTask: createFindKeyForTask(keyList),
+    isKeyForTaskExist: createIsKeyForTaskExist(keyList)
+  };
+};
+
+// src/signers/memorySigner/taskQueue/createFindTaskForKey.ts
+var checkIfKeyMatchRequirements = (keyPriority, key) => {
+  if (key.type !== keyPriority.type) return false;
+  if (key.type === "FullAccess") return true;
+  const isContractIdMatch = key.contractAccountId === keyPriority.contractAccountId;
+  const isFnCallAllowed = key.allowedFunctions === void 0 || key.allowedFunctions.includes(keyPriority.calledFnName);
+  return isContractIdMatch && isFnCallAllowed;
+};
+var createFindTaskForKey = (context) => (key) => context.queue.find(
+  (task) => task.signingKeyPriority.some(
+    (keyPriority) => checkIfKeyMatchRequirements(keyPriority, key)
+  )
+);
+
+// src/signers/memorySigner/taskQueue/addTask/helpers/getSigningKeyPriority.ts
+var getPriorityForFunctionCallTransaction = (action, receiverAccountId) => [
+  { type: "FullAccess" },
+  {
+    type: "FunctionCall",
+    contractAccountId: receiverAccountId,
+    calledFnName: action.params.functionName
+  }
+];
+var getSigningKeyPriority = ({
+  action,
+  actions,
+  receiverAccountId
+}) => {
+  if (action?.actionType === "FunctionCall")
+    return getPriorityForFunctionCallTransaction(action, receiverAccountId);
+  if (actions?.length === 1 && actions[0].actionType === "FunctionCall")
+    return getPriorityForFunctionCallTransaction(actions[0], receiverAccountId);
+  return [{ type: "FullAccess" }];
+};
+
+// src/signers/memorySigner/taskQueue/addTask/signTransaction.ts
+var createSignTransaction2 = (context) => async (transactionIntent) => {
+  const { matcher, resolver } = context.signerContext;
+  const task = {
+    type: "SignTransaction",
+    taskId: crypto.randomUUID(),
+    signingKeyPriority: getSigningKeyPriority(transactionIntent),
+    transactionIntent
+  };
+  matcher.canHandleTaskInFuture(task);
+  context.addTask(task);
+  queueMicrotask(() => {
+    matcher.handleAddTask(task);
+  });
+  return resolver.waitForTask(task.taskId);
+};
+
+// src/signers/memorySigner/taskQueue/addTask/executeTransaction.ts
+var createExecuteTransaction = (context) => async (args) => {
+  const { matcher, resolver } = context.signerContext;
+  const transactionIntent = {
+    receiverAccountId: args.receiverAccountId,
+    action: args.action,
+    actions: args.actions
+  };
+  const task = {
+    type: "ExecuteTransaction",
+    taskId: crypto.randomUUID(),
+    signingKeyPriority: getSigningKeyPriority(transactionIntent),
+    transactionIntent
+  };
+  matcher.canHandleTaskInFuture(task);
+  context.addTask(task);
+  queueMicrotask(() => {
+    matcher.handleAddTask(task);
+  });
+  return resolver.waitForTask(task.taskId);
+};
+
+// src/signers/memorySigner/taskQueue/addTask/signMultipleTransactions.ts
+var createSignMultipleTransactions = (context) => async (args) => {
+  const { transactionIntents } = args;
+  const { signTransaction: signTransaction2 } = context.signerContext.taskQueue;
+  const output = [];
+  let failed = false;
+  for (const intent of transactionIntents) {
+    if (failed) {
+      output.push({ status: "Canceled" });
+      continue;
+    }
+    try {
+      output.push({
+        status: "Success",
+        result: await signTransaction2(intent)
+      });
+    } catch (error) {
+      output.push({ status: "Error", error });
+      failed = true;
+    }
+  }
+  return output;
+};
+
+// src/signers/memorySigner/taskQueue/addTask/executeMultipleTransactions.ts
+var createExecuteMultipleTransactions = (context) => async (args) => {
+  const { transactionIntents } = args;
+  const { executeTransaction: executeTransaction2 } = context.signerContext.taskQueue;
+  const output = [];
+  let failed = false;
+  for (const intent of transactionIntents) {
+    if (failed) {
+      output.push({ status: "Canceled" });
+      continue;
+    }
+    try {
+      output.push({
+        status: "Success",
+        result: await executeTransaction2({ ...intent })
+      });
+    } catch (error) {
+      output.push({ status: "Error", error });
+      failed = true;
+    }
+  }
+  return output;
+};
+
+// src/signers/memorySigner/taskQueue/createTaskQueue.ts
+var createTaskQueue = (signerContext) => {
+  const context = {
+    queue: [],
+    cleaners: {},
+    signerContext
+  };
+  context.addTask = (task) => {
+    context.queue.push(task);
+    context.cleaners[task.taskId] = setTimeout(() => {
+      context.queue = context.queue.filter(
+        ({ taskId }) => taskId !== task.taskId
+      );
+      delete context.cleaners[task.taskId];
+      context.signerContext.resolver.completeTask(task.taskId, {
+        error: "Task execution was rejected after timeout"
+      });
+    }, context.signerContext.taskTtlMs);
+  };
+  const removeTask = (taskId) => {
+    context.queue = context.queue.filter((task) => task.taskId !== taskId);
+    clearTimeout(context.cleaners[taskId]);
+    delete context.cleaners[taskId];
+  };
+  return {
+    signTransaction: createSignTransaction2(context),
+    signMultipleTransactions: createSignMultipleTransactions(context),
+    executeTransaction: createExecuteTransaction(context),
+    executeeMultipleTransactions: createExecuteMultipleTransactions(context),
+    findTaskForKey: createFindTaskForKey(context),
+    removeTask
+  };
+};
+
+// src/signers/memorySigner/executors/helpers/getSignedTransaction.ts
+var getSignedTransaction = (signerContext, task, key, nextNonce) => {
+  const transaction = {
+    ...task.transactionIntent,
+    signerAccountId: signerContext.signerAccountId,
+    signerPublicKey: key.publicKey,
+    nonce: nextNonce,
+    blockHash: signerContext.state.getBlockHash()
+  };
+  const { transactionHash, u8TransactionHash } = getTransactionHash(transaction);
+  const { signature } = sign({
+    message: u8TransactionHash,
+    privateKey: key.privateKey
+  });
+  return {
+    transaction,
+    transactionHash,
+    signature
+  };
+};
+
+// src/signers/memorySigner/executors/signTransaction.ts
+var signTransaction = async (signerContext, task, key) => {
+  try {
+    const nextNonce = key.nonce + 1;
+    const signedTransaction = getSignedTransaction(
+      signerContext,
+      task,
+      key,
+      nextNonce
+    );
+    key.incrementNonce();
+    signerContext.resolver.completeTask(task.taskId, {
+      result: signedTransaction
+    });
+  } catch (e) {
+    signerContext.resolver.completeTask(task.taskId, { error: e });
+  }
+};
+
+// src/signers/memorySigner/executors/executeTransaction.ts
+var executeTransaction = async (signerContext, task, key) => {
+  try {
+    const nextNonce = key.nonce + 1;
+    const signedTransaction = getSignedTransaction(
+      signerContext,
+      task,
+      key,
+      nextNonce
+    );
+    const result = await signerContext.client.sendSignedTransaction({
+      signedTransaction
+    });
+    key.incrementNonce();
+    signerContext.resolver.completeTask(task.taskId, {
+      result
+    });
+  } catch (e) {
+    signerContext.resolver.completeTask(task.taskId, { error: e });
+  }
+};
+
+// src/signers/memorySigner/matcher/createMatcher.ts
+var execute = (task) => {
+  if (task.type === "SignTransaction") return signTransaction;
+  if (task.type === "ExecuteTransaction") return executeTransaction;
+  throw new Error("Unsupported task type");
+};
+var executeTask = async (signerContext, task, key) => {
+  key.lock();
+  signerContext.taskQueue.removeTask(task.taskId);
+  await execute(task)(signerContext, task, key);
+  key.unlock();
+  void signerContext.matcher.handleKeyUnlock(key);
+};
+var createMatcher = (signerContext) => {
+  const handleAddTask = async (task) => {
+    const key = signerContext.keyPool.findKeyForTask(task);
+    if (key) void executeTask(signerContext, task, key);
+  };
+  const handleKeyUnlock = async (key) => {
+    const task = signerContext.taskQueue.findTaskForKey(key);
+    if (task) void executeTask(signerContext, task, key);
+  };
+  const canHandleTaskInFuture = (task) => {
+    const canHandle = signerContext.keyPool.isKeyForTaskExist(task);
+    if (canHandle) return true;
+    throw new Error(`There is no key, which can sigh the task`);
+  };
+  return {
+    handleAddTask,
+    handleKeyUnlock,
+    canHandleTaskInFuture
+  };
+};
+
+// src/signers/memorySigner/resolver/createResolver.ts
+var createResolver = () => {
+  const activeTasks = {};
+  const waitForTask = (taskId) => new Promise((resolve, reject) => {
+    activeTasks[taskId] = ({ result, error }) => {
+      typeof error === "undefined" ? resolve(result) : reject(error);
+      delete activeTasks[taskId];
+    };
+  });
+  const completeTask = (taskId, data) => {
+    activeTasks[taskId](data);
+  };
+  return {
+    waitForTask,
+    completeTask
+  };
+};
+
+// src/signers/memorySigner/state/createState.ts
+var fetchBlockHash = async (signerContext) => {
+  const block = await signerContext.client.getBlock();
+  return block.header.hash;
+};
+var createState = async (signerContext) => {
+  const blockHash = await fetchBlockHash(signerContext);
+  const state = {
+    blockHash
+  };
+  const refetchBlockHashIntervalId = setInterval(async () => {
+    state.blockHash = await fetchBlockHash(signerContext);
+  }, RefetchBlockHashInterval);
+  const clearIntervals = () => {
+    clearInterval(refetchBlockHashIntervalId);
+  };
+  return {
+    getBlockHash: () => state.blockHash,
+    clearIntervals
+  };
+};
+
+// src/signers/memorySigner/createMemorySigner.ts
+var createMemorySigner = async (args) => {
+  const context = {
+    signerAccountId: args.signerAccountId,
+    client: args.client,
+    keyService: args.keyService,
+    signingKeys: args?.keyPool?.signingKeys,
+    taskTtlMs: args?.queue?.taskTtlMs ?? SignerTaskTtlMs
+  };
+  const [keyPool, state] = await Promise.all([
+    createKeyPool(context),
+    createState(context)
+  ]);
+  context.keyPool = keyPool;
+  context.state = state;
+  context.taskQueue = createTaskQueue(context);
+  context.matcher = createMatcher(context);
+  context.resolver = createResolver();
+  return {
+    executeTransaction: context.taskQueue.executeTransaction,
+    executeMultipleTransactions: context.taskQueue.executeeMultipleTransactions,
+    signTransaction: context.taskQueue.signTransaction,
+    signMultipleTransactions: context.taskQueue.signMultipleTransactions
+  };
+};
+
+// src/helpers/actionCreators/transfer.ts
+var transfer = (params) => ({
+  actionType: "Transfer",
+  params
+});
+
+// src/helpers/actionCreators/createAccount.ts
+var createAccount = () => ({
+  actionType: "CreateAccount"
+});
+
+// src/helpers/actionCreators/addFullAccessKey.ts
+var addFullAccessKey = ({
+  publicKey
+}) => ({
+  actionType: "AddKey",
+  params: {
+    accessType: "FullAccess",
+    publicKey
+  }
+});
+
+// src/helpers/actionCreators/addFunctionCallKey.ts
+var addFunctionCallKey = ({
+  publicKey,
+  contractAccountId,
+  gasBudget,
+  allowedFunctions
+}) => ({
+  actionType: "AddKey",
+  params: {
+    accessType: "FunctionCall",
+    publicKey,
+    contractAccountId,
+    gasBudget,
+    allowedFunctions
+  }
+});
+
+// src/helpers/actionCreators/functionCall.ts
+var functionCall = (params) => ({
+  actionType: "FunctionCall",
+  params
+});
+
+// src/helpers/actionCreators/deleteKey.ts
+var deleteKey = (params) => ({
+  actionType: "DeleteKey",
+  params
+});
+
+// src/helpers/actionCreators/deleteAccount.ts
+var deleteAccount = (params) => ({
+  actionType: "DeleteAccount",
+  params
+});
+
+// src/helpers/actionCreators/deployContract.ts
+var deployContract = (params) => ({
+  actionType: "DeployContract",
+  params
+});
+export {
+  addFullAccessKey,
+  addFunctionCallKey,
+  createAccount,
+  createClient,
+  createMemoryKeyService,
+  createMemorySigner,
+  deleteAccount,
+  deleteKey,
+  deployContract,
+  functionCall,
+  gas,
+  mainnet,
+  near,
+  teraGas,
+  testnet,
+  transfer,
+  yoctoNear
+};
+//# sourceMappingURL=index.js.map