near-api-ts 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -30,28 +30,60 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  addFullAccessKey: () => addFullAccessKey,
-  addFunctionCallKey: () => addFunctionCallKey,
+  addFullAccessKey: () => throwableAddFullAccessKey,
+  addFunctionCallKey: () => throwableAddFunctionCallKey,
   createAccount: () => createAccount,
-  createClient: () => createClient,
+  createClient: () => throwableCreateClient,
   createMainnetClient: () => createMainnetClient,
-  createMemoryKeyService: () => createMemoryKeyService,
-  createMemorySigner: () => createMemorySigner,
+  createMemoryKeyService: () => throwableCreateMemoryKeyService,
+  createMemorySigner: () => throwableCreateMemorySigner,
+  createMemorySignerFactory: () => createThrowableMemorySignerFactory,
+  createSafeMemorySignerFactory: () => createSafeMemorySignerFactory,
   createTestnetClient: () => createTestnetClient,
-  deleteAccount: () => deleteAccount,
-  deleteKey: () => deleteKey,
-  deployContract: () => deployContract,
-  functionCall: () => functionCall,
-  gas: () => gas,
-  near: () => near,
-  teraGas: () => teraGas,
-  transfer: () => transfer,
-  yoctoNear: () => yoctoNear
+  deleteAccount: () => throwableDeleteAccount,
+  deleteKey: () => throwableDeleteKey,
+  deployContract: () => throwableDeployContract,
+  functionCall: () => throwableFunctionCall,
+  gas: () => throwableGas,
+  isNatError: () => isNatError,
+  isNearGas: () => isNearGas,
+  isNearToken: () => isNearToken,
+  keyPair: () => throwableKeyPair,
+  near: () => throwableNear,
+  nearGas: () => throwableNearGas,
+  nearToken: () => throwableNearToken,
+  randomEd25519KeyPair: () => throwableRandomEd25519KeyPair,
+  randomSecp256k1KeyPair: () => throwableRandomSecp256k1KeyPair,
+  safeAddFullAccessKey: () => safeAddFullAccessKey,
+  safeAddFunctionCallKey: () => safeAddFunctionCallKey,
+  safeCreateClient: () => safeCreateClient,
+  safeCreateMemoryKeyService: () => safeCreateMemoryKeyService,
+  safeCreateMemorySigner: () => safeCreateMemorySigner,
+  safeDeleteAccount: () => safeDeleteAccount,
+  safeDeleteKey: () => safeDeleteKey,
+  safeDeployContract: () => safeDeployContract,
+  safeFunctionCall: () => safeFunctionCall,
+  safeGas: () => safeGas,
+  safeKeyPair: () => safeKeyPair,
+  safeNear: () => safeNear,
+  safeNearGas: () => safeNearGas,
+  safeNearToken: () => safeNearToken,
+  safeRandomEd25519KeyPair: () => safeRandomEd25519KeyPair,
+  safeRandomSecp256k1KeyPair: () => safeRandomSecp256k1KeyPair,
+  safeTeraGas: () => safeTeraGas,
+  safeTransfer: () => safeTransfer,
+  safeYoctoNear: () => safeYoctoNear,
+  teraGas: () => throwableTeraGas,
+  transfer: () => throwableTransfer,
+  yoctoNear: () => throwableYoctoNear
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client/methods/account/getAccountState.ts
-var z = __toESM(require("zod/mini"), 1);
+// src/client/createClient.ts
+var z33 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/account/getAccountInfo/getAccountInfo.ts
+var z8 = __toESM(require("zod/mini"), 1);
 
 // src/_common/transformers/toNative/blockReference.ts
 var toNativeBlockReference = (blockReference, defaultBlockReference) => {
@@ -72,10 +104,59 @@ var toNativeBlockReference = (blockReference, defaultBlockReference) => {
   return { finality: "near-final" };
 };
 
-// src/client/methods/account/getAccountState.ts
+// src/_common/utils/result.ts
+var result = {
+  ok: (value) => ({ ok: true, value }),
+  err: (error) => ({ ok: false, error })
+};
+
+// src/_common/natError.ts
+var NatErrorBrand = Symbol("NatError");
+var NatError = class extends Error {
+  [NatErrorBrand] = true;
+  kind;
+  context;
+  constructor(args) {
+    super(`<${args.kind}>`);
+    this.name = "NatError";
+    this.kind = args.kind;
+    this.context = args.context;
+  }
+};
+var createNatError = (args) => new NatError(args);
+var isNatError = (error, kind) => {
+  const isNatErr = typeof error === "object" && error !== null && NatErrorBrand in error;
+  if (kind === void 0) return isNatErr;
+  return isNatErr && error?.kind === kind;
+};
+var isNatErrorOf = (error, kinds) => {
+  const isNatErr = typeof error === "object" && error !== null && NatErrorBrand in error;
+  if (!isNatErr) return false;
+  return kinds.includes(error.kind);
+};
+
+// src/_common/utils/wrapInternalError.ts
+var returnError = (e, kind) => result.err(
+  createNatError({
+    kind,
+    context: { cause: e }
+  })
+);
+var wrapInternalError = (kind, fn) => (...args) => {
+  try {
+    const res = fn(...args);
+    if (res instanceof Promise) return res.catch((e) => returnError(e, kind));
+    return res;
+  } catch (e) {
+    return returnError(e, kind);
+  }
+};
+
+// src/client/methods/account/getAccountInfo/handleResult.ts
+var z2 = __toESM(require("zod/mini"), 1);
 var import_jsonrpc_types = require("@near-js/jsonrpc-types");
 
-// src/_common/utils/tokenConverter/helpers.ts
+// src/helpers/tokens/tokenConverter/helpers.ts
 var POW10_CACHE = {};
 var pow10 = (decimals) => {
   const cached = POW10_CACHE[decimals];
@@ -84,24 +165,9 @@ var pow10 = (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`
-    );
-  }
-};
+// src/helpers/tokens/tokenConverter/convertTokensToUnits.ts
 var convertTokensToUnits = (tokens, decimals) => {
-  assertValidDecimals(decimals);
-  assertValidTokens(tokens, decimals);
   const [integerPartRaw, fractionalPartRaw = ""] = tokens.split(".");
   const scale = pow10(decimals);
   const integerUnits = BigInt(integerPartRaw) * scale;
@@ -109,19 +175,11 @@ var convertTokensToUnits = (tokens, decimals) => {
   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)");
-  }
-};
+// src/helpers/tokens/tokenConverter/convertUnitsToTokens.ts
 var convertUnitsToTokens = (units, decimals) => {
-  assertValidDecimals(decimals);
-  assertValidUnits(units);
-  const unitsBigInt = BigInt(units);
   const scale = pow10(decimals);
-  const wholePart = unitsBigInt / scale;
-  const fractionalRemainder = unitsBigInt % scale;
+  const wholePart = units / scale;
+  const fractionalRemainder = units % scale;
   if (fractionalRemainder === 0n) return wholePart.toString();
   const fractionalDigits = fractionalRemainder.toString().padStart(decimals, "0").replace(/0+$/, "");
   if (fractionalDigits.length === 0) return wholePart.toString();
@@ -129,23 +187,23 @@ var convertUnitsToTokens = (units, decimals) => {
 };
 
 // src/_common/configs/constants.ts
-var BinaryCryptoKeyLengths = {
+var BinaryLengths = {
   Ed25519: {
-    // SecretKey + PublicKey
     PrivateKey: 64,
+    // SecretKey + PublicKey
     SecretKey: 32,
-    PublicKey: 32
+    PublicKey: 32,
+    Signature: 64
   },
   Secp256k1: {
-    // SecretKey + PublicKey
     PrivateKey: 96,
+    // SecretKey + PublicKey
     SecretKey: 32,
-    PublicKey: 64
+    PublicKey: 64,
+    Signature: 65
   }
 };
 var NearDecimals = 24;
-var RefetchBlockHashInterval = 6e5;
-var SignerTaskTtlMs = 6e4;
 
 // src/_common/utils/common.ts
 var oneLine = (msg) => msg.replace(/\s+/g, " ").trim();
@@ -159,12 +217,63 @@ var fromJsonBytes = (bytes) => {
 var combineAbortSignals = (signals) => AbortSignal.any(signals.filter((signal) => typeof signal !== "undefined"));
 var randomBetween = (min, max) => Math.random() * (max - min) + min;
 
-// src/helpers/near.ts
+// src/_common/schemas/zod/common/nearToken.ts
+var z = __toESM(require("zod/mini"), 1);
+var createTokensInputSchema = (decimals) => z.string().check(
+  z.refine(
+    (val) => {
+      const decimalPattern = new RegExp(`^\\d+(?:\\.\\d{1,${decimals}})?$`);
+      return decimalPattern.test(val);
+    },
+    {
+      message: `Must be a valid number with up to ${decimals} decimal places`
+    }
+  )
+);
+var NearInputSchema = createTokensInputSchema(24);
+var BigintStringSchema = z.pipe(
+  z.string().check(z.regex(/^\d+$/, "Must contain only digits")),
+  z.transform((v) => BigInt(v))
+);
+var YoctoNearInputSchema = z.union([z.bigint(), BigintStringSchema]);
+var NearTokenArgsSchema = z.union([
+  z.object({
+    near: NearInputSchema
+  }),
+  z.object({
+    yoctoNear: YoctoNearInputSchema
+  })
+]);
+
+// src/_common/utils/asThrowable.ts
+var asThrowable = (safeFn) => {
+  return (...args) => {
+    const result2 = safeFn(...args);
+    if (result2 instanceof Promise) {
+      return result2.then((res) => {
+        if (res.ok) return res.value;
+        throw res.error;
+      });
+    }
+    if (result2.ok) return result2.value;
+    throw result2.error;
+  };
+};
+
+// src/helpers/tokens/nearToken.ts
+var NearTokenBrand = Symbol("NearToken");
 var cache = {
-  near: /* @__PURE__ */ new WeakMap(),
-  yoctoNear: /* @__PURE__ */ new WeakMap()
+  yoctoNear: /* @__PURE__ */ new WeakMap(),
+  near: /* @__PURE__ */ new WeakMap()
+};
+var isNearToken = (value) => typeof value === "object" && value !== null && NearTokenBrand in value;
+var toYoctoNear = (x) => {
+  if (isNearToken(x)) return result.ok(x.yoctoNear);
+  const nearToken = safeNearToken(x);
+  return nearToken.ok ? result.ok(nearToken.value.yoctoNear) : nearToken;
 };
 var nearTokenProto = {
+  [NearTokenBrand]: true,
   // Lazy getter - calculate the 'near' value only after the first direct access;
   // save the result in the cache
   get near() {
@@ -181,21 +290,43 @@ var nearTokenProto = {
     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);
+  // TODO Need to reuse method code and reduce boilerplate code, and reduce useless
+  // transformations
+  safeAdd(value) {
+    return wrapInternalError("CreateNearToken.Internal", () => {
+      const yoctoNear = toYoctoNear(value);
+      return yoctoNear.ok ? safeNearToken({ yoctoNear: this.yoctoNear + yoctoNear.value }) : yoctoNear;
+    })();
+  },
+  add(value) {
+    return asThrowable(this.safeAdd.bind(this))(value);
+  },
+  safeSub(value) {
+    return wrapInternalError("CreateNearToken.Internal", () => {
+      const yoctoNear = toYoctoNear(value);
+      return yoctoNear.ok ? safeNearToken({ yoctoNear: this.yoctoNear - yoctoNear.value }) : yoctoNear;
+    })();
   },
-  sub(x) {
-    return yoctoNear(this.yoctoNear - fromNearOption(x).yoctoNear);
+  sub(value) {
+    return asThrowable(this.safeSub.bind(this))(value);
   },
-  mul(x) {
-    return yoctoNear(this.yoctoNear * fromNearOption(x).yoctoNear);
+  safeGt(value) {
+    return wrapInternalError("CreateNearToken.Internal", () => {
+      const yoctoNear = toYoctoNear(value);
+      return yoctoNear.ok ? result.ok(this.yoctoNear > yoctoNear.value) : yoctoNear;
+    })();
   },
-  gt(x) {
-    return this.yoctoNear > fromNearOption(x).yoctoNear;
+  gt(value) {
+    return asThrowable(this.safeGt.bind(this))(value);
   },
-  lt(x) {
-    return this.yoctoNear < fromNearOption(x).yoctoNear;
+  safeLt(value) {
+    return wrapInternalError("CreateNearToken.Internal", () => {
+      const yoctoNear = toYoctoNear(value);
+      return yoctoNear.ok ? result.ok(this.yoctoNear < yoctoNear.value) : yoctoNear;
+    })();
+  },
+  lt(value) {
+    return asThrowable(this.safeLt.bind(this))(value);
   },
   toString() {
     return JSON.stringify({
@@ -213,99 +344,446 @@ var nearTokenProto = {
     }
   }
 };
-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/_common/utils/addTo.ts
-var addTo = (target) => ({
-  field: (key, value, predicate = (v4) => v4 !== void 0) => {
-    if (predicate(value)) {
-      target[key] = value;
-    }
-    return addTo(target);
-  },
-  done: () => target
-});
+var safeYoctoNear = wrapInternalError(
+  "CreateNearTokenFromYoctoNear.Internal",
+  (yoctoNear) => {
+    const validYoctoNear = YoctoNearInputSchema.safeParse(yoctoNear);
+    if (!validYoctoNear.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearTokenFromYoctoNear.Args.InvalidSchema",
+          context: { zodError: validYoctoNear.error }
+        })
+      );
+    const nearToken = Object.create(nearTokenProto);
+    Object.defineProperty(nearToken, "yoctoNear", {
+      value: validYoctoNear.data,
+      enumerable: true
+    });
+    return result.ok(Object.freeze(nearToken));
+  }
+);
+var throwableYoctoNear = asThrowable(safeYoctoNear);
+var safeNear = wrapInternalError(
+  "CreateNearTokenFromNear.Internal",
+  (near) => {
+    const validNear = NearInputSchema.safeParse(near);
+    if (!validNear.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearTokenFromNear.Args.InvalidSchema",
+          context: { zodError: validNear.error }
+        })
+      );
+    const nearToken = Object.create(nearTokenProto);
+    Object.defineProperty(nearToken, "near", {
+      value: validNear.data,
+      enumerable: true
+    });
+    return result.ok(Object.freeze(nearToken));
+  }
+);
+var throwableNear = asThrowable(safeNear);
+var safeNearToken = wrapInternalError(
+  "CreateNearToken.Internal",
+  (args) => {
+    const validArgs = NearTokenArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearToken.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    return "yoctoNear" in args ? result.ok(throwableYoctoNear(args.yoctoNear)) : result.ok(throwableNear(args.near));
+  }
+);
+var throwableNearToken = asThrowable(safeNearToken);
 
-// src/client/methods/account/getAccountState.ts
-var RpcQueryAccountViewResponseSchema = z.object({
+// src/client/methods/account/getAccountInfo/handleResult.ts
+var RpcQueryViewAccountResultSchema = z2.object({
   ...(0, import_jsonrpc_types.AccountViewSchema)().shape,
-  blockHash: (0, import_jsonrpc_types.CryptoHashSchema)(),
-  blockHeight: z.number()
-});
-var transformResult = (result, args) => {
-  const valid = RpcQueryAccountViewResponseSchema.parse(result);
-  const lockedBalance = yoctoNear(valid.locked);
-  const totalBalance = yoctoNear(valid.amount).add(lockedBalance);
-  const final = {
-    blockHash: valid.blockHash,
-    blockHeight: valid.blockHeight,
+  blockHash: z2.string(),
+  blockHeight: z2.number()
+});
+var handleResult = (rpcResponse, args) => {
+  const rpcResult = RpcQueryViewAccountResultSchema.safeParse(
+    rpcResponse.result
+  );
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountInfo.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  const accountInfo = rpcResult.data;
+  const lockedBalance = throwableYoctoNear(accountInfo.locked);
+  const totalBalance = throwableYoctoNear(accountInfo.amount).add(
+    lockedBalance
+  );
+  const output = {
+    blockHash: accountInfo.blockHash,
+    blockHeight: accountInfo.blockHeight,
     accountId: args.accountId,
-    accountState: {
+    accountInfo: {
       balance: {
         total: totalBalance,
         locked: lockedBalance
       },
-      usedStorageBytes: valid.storageUsage
-    }
+      usedStorageBytes: accountInfo.storageUsage
+    },
+    rawRpcResult: accountInfo
   };
-  addTo(final.accountState).field(
-    "contractHash",
-    valid.codeHash,
-    // When near account doesn't have a deployed contract on it,
-    // it returns the placeholder instead of WASM hash
-    (v4) => v4 !== "11111111111111111111111111111111"
-  ).field(
-    "globalContractHash",
-    valid.globalContractHash,
-    (v4) => typeof v4 === "string"
-  ).field(
-    "globalContractAccountId",
-    valid.globalContractAccountId,
-    (v4) => typeof v4 === "string"
+  if (accountInfo.codeHash !== "11111111111111111111111111111111") {
+    output.accountInfo.contractHash = accountInfo.codeHash;
+  }
+  if (typeof accountInfo.globalContractHash === "string") {
+    output.accountInfo.globalContractHash = accountInfo.globalContractHash;
+  }
+  if (typeof accountInfo.globalContractAccountId === "string") {
+    output.accountInfo.globalContractAccountId = accountInfo.globalContractAccountId;
+  }
+  return result.ok(output);
+};
+
+// src/_common/schemas/zod/client.ts
+var z6 = __toESM(require("zod/mini"), 1);
+
+// src/client/transport/transportPolicy.ts
+var z3 = __toESM(require("zod/mini"), 1);
+var import_lodash_es = require("lodash-es");
+var Regular = z3.literal("Regular");
+var Archival = z3.literal("Archival");
+var RpcTypePreferencesSchema = z3.union([
+  z3.tuple([Regular]),
+  z3.tuple([Archival]),
+  z3.tuple([Regular, Archival]),
+  z3.tuple([Archival, Regular])
+]);
+var TransportPolicySchema = z3.object({
+  rpcTypePreferences: RpcTypePreferencesSchema,
+  timeouts: z3.object({
+    // Unlikely that a request could finish less in than 100ms -
+    // doesn't make sense to have such small timeout
+    requestMs: z3.number().check(z3.int(), z3.minimum(100)),
+    attemptMs: z3.number().check(z3.int(), z3.minimum(100))
+  }),
+  rpc: z3.object({
+    maxAttempts: z3.number().check(z3.int(), z3.minimum(1)),
+    retryBackoff: z3.object({
+      minDelayMs: z3.number().check(z3.int(), z3.nonnegative()),
+      maxDelayMs: z3.number().check(z3.int(), z3.nonnegative()),
+      multiplier: z3.number().check(z3.int(), z3.minimum(1))
+    })
+  }),
+  failover: z3.object({
+    maxRounds: z3.number().check(z3.int(), z3.minimum(1)),
+    nextRpcDelayMs: z3.number().check(z3.int(), z3.nonnegative()),
+    nextRoundDelayMs: z3.number().check(z3.int(), z3.nonnegative())
+  })
+});
+var PartialTransportPolicySchema = z3.optional(
+  z3.partial(TransportPolicySchema)
+);
+var defaultTransportPolicy = {
+  rpcTypePreferences: ["Regular", "Archival"],
+  timeouts: {
+    requestMs: 3e4,
+    attemptMs: 5e3
+  },
+  rpc: {
+    maxAttempts: 2,
+    retryBackoff: {
+      minDelayMs: 100,
+      maxDelayMs: 500,
+      multiplier: 3
+    }
+  },
+  failover: {
+    maxRounds: 2,
+    nextRpcDelayMs: 200,
+    nextRoundDelayMs: 200
+  }
+};
+var mergeTransportPolicy = (base, next = {}) => (0, import_lodash_es.mergeWith)(
+  {},
+  (0, import_lodash_es.cloneDeep)(base),
+  (0, import_lodash_es.cloneDeep)(next),
+  (_objValue, srcValue, key) => {
+    if (key === "rpcTypePreferences" && Array.isArray(srcValue)) {
+      return srcValue;
+    }
+  }
+);
+
+// src/_common/schemas/zod/common/common.ts
+var z5 = __toESM(require("zod/mini"), 1);
+
+// src/_common/schemas/zod/common/cryptoHash.ts
+var z4 = __toESM(require("zod/mini"), 1);
+var import_base = require("@scure/base");
+var Base58StringSchema = z4.string().check(
+  z4.regex(
+    /^[1-9A-HJ-NP-Za-km-z]+$/,
+    oneLine(`Base58 string contains invalid characters. Allowed characters:
+    123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`)
+  )
+);
+var CryptoHashSchema = z4.pipe(
+  Base58StringSchema,
+  z4.transform((cryptoHash) => {
+    const u8CryptoHash = import_base.base58.decode(cryptoHash);
+    return { cryptoHash, u8CryptoHash };
+  })
+).check(
+  z4.refine(({ u8CryptoHash }) => u8CryptoHash.length === 32, {
+    error: "Crypto hash length should be 32 bytes"
+  })
+);
+
+// src/_common/schemas/zod/common/common.ts
+var BlockHashSchema = CryptoHashSchema;
+var BlockHeightSchema = z5.number().check(z5.nonnegative());
+var BlockIdSchema = z5.union([BlockHeightSchema, BlockHashSchema]);
+var NonceSchema = z5.number().check(z5.int(), z5.nonnegative());
+var ContractFunctionNameSchema = z5.string().check(z5.minLength(1), z5.maxLength(256));
+var JsonSchema = z5.json();
+
+// src/_common/schemas/zod/client.ts
+var PoliciesSchema = z6.optional(
+  z6.object({
+    transport: PartialTransportPolicySchema
+  })
+);
+var BaseOptionsSchema = z6.optional(
+  z6.object({
+    signal: z6.optional(z6.instanceof(AbortSignal))
+  })
+);
+var BlockReferenceSchema = z6.union([
+  z6.literal("LatestOptimisticBlock"),
+  z6.literal("LatestNearFinalBlock"),
+  z6.literal("LatestFinalBlock"),
+  z6.literal("EarliestAvailableBlock"),
+  z6.literal("GenesisBlock"),
+  z6.object({
+    blockHash: BlockHashSchema,
+    blockHeight: z6.optional(z6.never())
+  }),
+  z6.object({
+    blockHash: z6.optional(z6.never()),
+    blockHeight: BlockHeightSchema
+  })
+]);
+
+// src/_common/schemas/zod/common/accountId.ts
+var z7 = __toESM(require("zod/mini"), 1);
+var AccountIdSchema = z7.string().check(
+  z7.minLength(2),
+  z7.maxLength(64),
+  z7.regex(/^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/, {
+    error: oneLine(`Account ID may contain only lowercase letters (a\u2013z), 
+    digits (0\u20139), and separators (., -, _).`)
+  })
+);
+
+// src/client/methods/account/getAccountInfo/handleError.ts
+var import_jsonrpc_types2 = require("@near-js/jsonrpc-types");
+var handleError = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types2.ErrorWrapperFor_RpcQueryErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountInfo.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NO_SYNCED_BLOCKS")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountInfo.Rpc.NotSynced`,
+          context: null
+        })
+      );
+    if (cause.name === "UNAVAILABLE_SHARD")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountInfo.Rpc.Shard.NotTracked`,
+          context: { shardId: cause.info.requestedShardId }
+        })
+      );
+    if (cause.name === "GARBAGE_COLLECTED_BLOCK")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountInfo.Rpc.Block.GarbageCollected`,
+          context: {
+            blockHash: cause.info.blockHash,
+            blockHeight: cause.info.blockHeight
+          }
+        })
+      );
+    if (cause.name === "UNKNOWN_BLOCK" && "blockId" in cause.info.blockReference)
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountInfo.Rpc.Block.NotFound`,
+          context: {
+            blockId: cause.info.blockReference.blockId
+          }
+        })
+      );
+  }
+  if (cause.name === "UNKNOWN_ACCOUNT")
+    return result.err(
+      createNatError({
+        kind: `Client.GetAccountInfo.Rpc.Account.NotFound`,
+        context: {
+          accountId: cause.info.requestedAccountId,
+          blockHash: cause.info.blockHash,
+          blockHeight: cause.info.blockHeight
+        }
+      })
+    );
+  return result.err(
+    createNatError({
+      kind: "Client.GetAccountInfo.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.GetAccountInfo.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
   );
-  return final;
 };
-var createGetAccountState = ({ sendRequest }) => async (args) => {
-  const result = await sendRequest({
+
+// src/client/methods/account/getAccountInfo/getAccountInfo.ts
+var GetAccountInfoArgsSchema = z8.object({
+  accountId: AccountIdSchema,
+  atMomentOf: z8.optional(BlockReferenceSchema),
+  policies: PoliciesSchema,
+  options: BaseOptionsSchema
+});
+var createSafeGetAccountInfo = (context) => wrapInternalError("Client.GetAccountInfo.Internal", async (args) => {
+  const validArgs = GetAccountInfoArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountInfo.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const { accountId, policies, options } = validArgs.data;
+  const rpcResponse = await context.sendRequest({
     method: "query",
     params: {
       request_type: "view_account",
-      account_id: args.accountId,
+      account_id: accountId,
       ...toNativeBlockReference(args.atMomentOf)
     },
-    transportPolicy: args.policies?.transport,
-    signal: args.options?.signal
+    transportPolicy: policies?.transport,
+    signal: options?.signal
   });
-  return transformResult(result, args);
+  if (!rpcResponse.ok)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountInfo.SendRequest.Failed",
+        context: { cause: rpcResponse.error }
+      })
+    );
+  return rpcResponse.value.error ? handleError(rpcResponse.value) : handleResult(rpcResponse.value, args);
+});
+
+// src/client/methods/account/getAccountAccessKey/getAccountAccessKey.ts
+var z12 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/account/getAccountAccessKey/handleError.ts
+var import_jsonrpc_types3 = require("@near-js/jsonrpc-types");
+var handleError2 = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types3.ErrorWrapperFor_RpcQueryErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKey.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NO_SYNCED_BLOCKS")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKey.Rpc.NotSynced`,
+          context: null
+        })
+      );
+    if (cause.name === "UNAVAILABLE_SHARD")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKey.Rpc.Shard.NotTracked`,
+          context: { shardId: cause.info.requestedShardId }
+        })
+      );
+    if (cause.name === "GARBAGE_COLLECTED_BLOCK")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKey.Rpc.Block.GarbageCollected`,
+          context: {
+            blockHash: cause.info.blockHash,
+            blockHeight: cause.info.blockHeight
+          }
+        })
+      );
+    if (cause.name === "UNKNOWN_BLOCK" && "blockId" in cause.info.blockReference)
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKey.Rpc.Block.NotFound`,
+          context: {
+            blockId: cause.info.blockReference.blockId
+          }
+        })
+      );
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.GetAccountAccessKey.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.GetAccountAccessKey.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
 };
 
-// src/client/methods/account/getAccountKey.ts
-var z2 = __toESM(require("zod/mini"), 1);
-var import_jsonrpc_types2 = require("@near-js/jsonrpc-types");
+// src/client/methods/account/getAccountAccessKey/handleResult.ts
+var z9 = __toESM(require("zod/mini"), 1);
+var import_jsonrpc_types4 = require("@near-js/jsonrpc-types");
 
-// src/client/methods/account/helpers/transformKey.ts
-var transformKey = (key) => {
+// src/client/methods/account/_common/transformAccessKey.ts
+var transformAccessKey = (key) => {
   const publicKey = key.publicKey;
   const nonce = key.accessKey.nonce;
   if (key.accessKey.permission === "FullAccess")
@@ -322,7 +800,7 @@ var transformKey = (key) => {
     contractAccountId: receiverId
   };
   if (typeof allowance === "string") {
-    functionCallKey.gasBudget = yoctoNear(allowance);
+    functionCallKey.gasBudget = throwableYoctoNear(allowance);
   }
   if (methodNames.length > 0) {
     functionCallKey.allowedFunctions = methodNames;
@@ -330,397 +808,289 @@ var transformKey = (key) => {
   return functionCallKey;
 };
 
-// src/client/rpcError.ts
-var Brand = Symbol.for("near-api-ts.RpcError");
-var parseRequestValidationError = (name) => {
-  if (name === "PARSE_ERROR")
-    return {
-      code: "ParseRequest",
-      message: `Invalid request format. Please check it and try again.`
-    };
-  if (name === "METHOD_NOT_FOUND")
-    return {
-      code: "MethodNotFound",
-      message: `Unsupported method. Please check it and try again.`
-    };
-  return {
-    code: "UnknownValidationError",
-    message: "Unknown request validation error."
-  };
-};
-var parseHandlerError = (cause) => {
-  const { name } = cause;
-  if (name === "TIMEOUT_ERROR")
-    return {
-      code: "RpcTransactionTimeout",
-      message: oneLine(`RPC does not know the result of this transaction, 
-        probably it is not executed yet. Please try again later.`)
-    };
-  if (name === "UNKNOWN_BLOCK")
-    return {
-      code: "UnknownBlock",
-      message: oneLine(`Block either has never been observed on 
-        the node or has been garbage collected. Please try again later or use 
-        another RPC node.`)
-    };
-  if (name === "GARBAGE_COLLECTED_BLOCK")
-    return {
-      code: "GarbageCollectedBlock",
-      message: oneLine(`Block is no longer available on this RPC node.
-        Please use an archival node to fetch historical data.`)
-    };
-  if (name === "NO_SYNCED_BLOCKS")
-    return {
-      code: "NoSyncedBlocks",
-      message: oneLine(`There are no fully synchronized blocks 
-        on the node yet. Please try again later.`)
-    };
-  return {
-    code: "HandlerError",
-    message: `Request execution error. Please check it and try again.`
-  };
-};
-var getErrorInfo = (__rawRpcError) => {
-  const { name: type, cause } = __rawRpcError;
-  if (type === "REQUEST_VALIDATION_ERROR")
-    return parseRequestValidationError(cause.name);
-  if (type === "HANDLER_ERROR") return parseHandlerError(cause);
-  if (type === "INTERNAL_ERROR")
-    return {
-      code: "InternalServerError",
-      message: `Internal server error. Please try again later or use another RPC node.`
-    };
-  return {
-    code: "UnknownRequestError",
-    message: "Unknown request error."
-  };
-};
-var RpcError = class extends Error {
-  [Brand] = true;
-  code;
-  request;
-  __rawRpcError;
-  errors;
-  timestamp;
-  constructor(args) {
-    const { code, message } = getErrorInfo(args.__rawRpcError);
-    super(
-      `[${code}]: ${message} 
-Type: ${args.__rawRpcError.name} 
-Cause: ${JSON.stringify(args.__rawRpcError.cause, null, 2)}`
-    );
-    this.name = "RpcError";
-    this.code = code;
-    this.request = args.request;
-    this.__rawRpcError = args.__rawRpcError;
-    this.timestamp = Date.now();
-  }
-  static is(e) {
-    return typeof e === "object" && e[Brand] === true;
-  }
-};
-var hasRpcErrorCode = (error, list) => RpcError.is(error) && list.includes(error.code);
-
-// src/client/transport/transportError.ts
-var NatError = class extends Error {
-  code;
-  name;
-  errors;
-  timestamp;
-  request;
-  constructor(args, name = "NatError") {
-    super(`[${args.code}] ${args.message}`, { cause: args.cause });
-    this.name = name;
-    this.code = args.code;
-    this.timestamp = Date.now();
-    this.request = args.request;
-  }
-  static is(e) {
-    return typeof e === "object" && e[Symbol.for(`near-api-ts.${this.name}`)] === true;
-  }
-};
-var TransportErrorBrand = Symbol.for("near-api-ts.TransportError");
-var TransportError = class extends NatError {
-  [TransportErrorBrand] = true;
-  constructor(args) {
-    super(args, "TransportError");
-  }
-};
-var hasTransportErrorCode = (error, list) => TransportError.is(error) && list.includes(error.code);
-
-// src/client/methods/account/getAccountKey.ts
-var BaseSchema = z2.object({
-  blockHash: (0, import_jsonrpc_types2.CryptoHashSchema)(),
-  blockHeight: z2.number()
+// src/client/methods/account/getAccountAccessKey/handleResult.ts
+var UnknownKeySchema = z9.object({
+  blockHash: z9.string(),
+  blockHeight: z9.number(),
+  error: z9.string(),
+  logs: z9.array(z9.string())
+  // will always an empty array
 });
-var RpcQueryAccessKeyViewResponseSchema = z2.union([
-  z2.object({
-    ...BaseSchema.shape,
-    ...(0, import_jsonrpc_types2.AccessKeyViewSchema)().shape
-  }),
-  z2.object({
-    ...BaseSchema.shape,
-    error: z2.string(),
-    logs: z2.array(z2.string())
-  })
+var RpcQueryViewAccessKeyOkResultSchema = z9.object({
+  blockHash: z9.string(),
+  blockHeight: z9.number(),
+  ...(0, import_jsonrpc_types4.AccessKeyViewSchema)().shape
+});
+var RpcQueryViewAccessKeyResultSchema = z9.union([
+  RpcQueryViewAccessKeyOkResultSchema,
+  UnknownKeySchema
 ]);
-var transformResult2 = (result, args) => {
-  const valid = RpcQueryAccessKeyViewResponseSchema.parse(result);
-  if ("error" in valid)
-    throw new NatError({
-      code: "AccountKeyNotFound",
-      message: `This account does not have such key.`,
-      cause: valid
-    });
-  return {
-    blockHash: valid.blockHash,
-    blockHeight: valid.blockHeight,
+var handleResult2 = (rpcResponse, args) => {
+  const rpcResult = RpcQueryViewAccessKeyResultSchema.safeParse(
+    rpcResponse.result
+  );
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKey.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  const { blockHash, blockHeight } = rpcResult.data;
+  if ("error" in rpcResult.data)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKey.Rpc.AccountAccessKey.NotFound",
+        context: {
+          accountId: args.accountId,
+          publicKey: args.publicKey,
+          blockHash,
+          blockHeight
+        }
+      })
+    );
+  const output = {
+    blockHash,
+    blockHeight,
     accountId: args.accountId,
-    accountKey: transformKey({
-      accessKey: valid,
+    accountAccessKey: transformAccessKey({
+      accessKey: rpcResult.data,
       publicKey: args.publicKey
-    })
+    }),
+    rawRpcResult: rpcResult.data
   };
-};
-var createGetAccountKey = ({ sendRequest }) => async (args) => {
-  const result = await sendRequest({
-    method: "query",
-    params: {
-      request_type: "view_access_key",
-      account_id: args.accountId,
-      public_key: args.publicKey,
-      ...toNativeBlockReference(args.atMomentOf)
-    },
-    transportPolicy: args.policies?.transport,
-    signal: args.options?.signal
-  });
-  return transformResult2(result, args);
+  return result.ok(output);
 };
 
-// src/client/methods/account/getAccountKeys.ts
-var z3 = __toESM(require("zod/mini"), 1);
-var import_jsonrpc_types3 = require("@near-js/jsonrpc-types");
-var RpcQueryAccessKeyListResponseSchema = z3.object({
-  ...(0, import_jsonrpc_types3.AccessKeyListSchema)().shape,
-  blockHash: (0, import_jsonrpc_types3.CryptoHashSchema)(),
-  blockHeight: z3.number()
-});
-var transformResult3 = (result, args) => {
-  const valid = RpcQueryAccessKeyListResponseSchema.parse(result);
-  return {
-    blockHash: valid.blockHash,
-    blockHeight: valid.blockHeight,
-    accountId: args.accountId,
-    accountKeys: valid.keys.map(transformKey)
-  };
-};
-var createGetAccountKeys = ({ sendRequest }) => async (args) => {
-  const result = await sendRequest({
-    method: "query",
-    params: {
-      request_type: "view_access_key_list",
-      account_id: args.accountId,
-      ...toNativeBlockReference(args.atMomentOf)
-    },
-    transportPolicy: args.policies?.transport,
-    signal: args.options?.signal
-  });
-  return transformResult3(result, args);
-};
+// src/_common/schemas/zod/common/publicKey.ts
+var z11 = __toESM(require("zod/mini"), 1);
 
-// src/client/methods/contract/getContractState.ts
-var z4 = __toESM(require("zod/mini"), 1);
-var import_base = require("@scure/base");
-var import_jsonrpc_types4 = require("@near-js/jsonrpc-types");
-var RpcQueryViewStateResponseSchema = z4.object({
-  ...(0, import_jsonrpc_types4.ViewStateResultSchema)().shape,
-  blockHash: (0, import_jsonrpc_types4.CryptoHashSchema)(),
-  blockHeight: z4.number()
-});
-var transformResult4 = (result, args) => {
-  const valid = RpcQueryViewStateResponseSchema.parse(result);
-  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 ? import_base.base64.encode(Uint8Array.from(args.keyPrefix)) : "";
-  const result = await sendRequest({
+// src/_common/schemas/zod/common/curveString.ts
+var z10 = __toESM(require("zod/mini"), 1);
+var import_base2 = require("@scure/base");
+var CurveStringSchema = z10.pipe(
+  z10.string().check(
+    z10.regex(
+      /^(ed25519|secp256k1):[1-9A-HJ-NP-Za-km-z]+$/,
+      oneLine(`Curve strings should use the 
+      ed25519:<base58String> or secp256k1:<base58String> format.`)
+    )
+  ),
+  z10.transform((curveString) => {
+    const [curve, base58String] = curveString.split(":");
+    return {
+      curveString,
+      curve,
+      u8Data: import_base2.base58.decode(base58String)
+    };
+  })
+);
+
+// src/_common/schemas/zod/common/publicKey.ts
+var { Ed25519, Secp256k1 } = BinaryLengths;
+var PublicKeySchema = z11.pipe(
+  CurveStringSchema,
+  z11.transform((val) => ({
+    publicKey: val.curveString,
+    u8PublicKey: val.u8Data,
+    curve: val.curve
+  }))
+).check(
+  z11.refine(
+    ({ curve, u8PublicKey }) => curve === "ed25519" ? u8PublicKey.length === Ed25519.PublicKey : u8PublicKey.length === Secp256k1.PublicKey,
+    { error: "Invalid public key length" }
+  )
+);
+
+// src/client/methods/account/getAccountAccessKey/getAccountAccessKey.ts
+var GetAccountAccessKeyArgsSchema = z12.object({
+  accountId: AccountIdSchema,
+  publicKey: PublicKeySchema,
+  atMomentOf: z12.optional(BlockReferenceSchema),
+  policies: PoliciesSchema,
+  options: BaseOptionsSchema
+});
+var createSafeGetAccountAccessKey = (context) => wrapInternalError("Client.GetAccountAccessKey.Internal", async (args) => {
+  const validArgs = GetAccountAccessKeyArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKey.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const rpcResponse = await context.sendRequest({
     method: "query",
     params: {
-      request_type: "view_state",
-      account_id: args.contractAccountId,
-      prefix_base64: base64KeyPrefix,
-      include_proof: args.includeProof,
+      request_type: "view_access_key",
+      account_id: args.accountId,
+      public_key: args.publicKey,
       ...toNativeBlockReference(args.atMomentOf)
     },
     transportPolicy: args.policies?.transport,
     signal: args.options?.signal
   });
-  return transformResult4(result, args);
-};
+  if (!rpcResponse.ok)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKey.SendRequest.Failed",
+        context: { cause: rpcResponse.error }
+      })
+    );
+  return rpcResponse.value.error ? handleError2(rpcResponse.value) : handleResult2(rpcResponse.value, args);
+});
 
-// src/client/methods/contract/callContractReadFunction.ts
-var import_base2 = require("@scure/base");
-var z5 = __toESM(require("zod/mini"), 1);
+// src/client/methods/account/getAccountAccessKeys/getAccountAccessKeys.ts
+var z14 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/account/getAccountAccessKeys/handleError.ts
 var import_jsonrpc_types5 = require("@near-js/jsonrpc-types");
-var baseDeserializeResul = ({ rawResult }) => fromJsonBytes(rawResult);
-var BaseSchema2 = z5.object({
-  logs: z5.array(z5.string()),
-  blockHash: (0, import_jsonrpc_types5.CryptoHashSchema)(),
-  blockHeight: z5.number()
-});
-var RpcCallFunctionResponseSchema = z5.union([
-  z5.object({ ...BaseSchema2.shape, result: z5.array(z5.number()) }),
-  z5.object({ ...BaseSchema2.shape, error: z5.string() })
-]);
-var transformResult5 = (result, args) => {
-  const valid = RpcCallFunctionResponseSchema.parse(result);
-  if ("error" in valid)
-    throw new NatError({
-      code: "ContractExecutionError",
-      message: `Contract read function call failed: ${valid.error}`,
-      cause: valid
-    });
-  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({
-    method: "query",
-    params: {
-      request_type: "call_function",
-      account_id: args.contractAccountId,
-      method_name: args.functionName,
-      args_base64: import_base2.base64.encode(serializeFunctionArgs(args)),
-      ...toNativeBlockReference(args.withStateAt)
-    },
-    transportPolicy: args.policies?.transport,
-    signal: args.options?.signal
-  });
-  return transformResult5(result, args);
+var handleError3 = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types5.ErrorWrapperFor_RpcQueryErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKeys.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NO_SYNCED_BLOCKS")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKeys.Rpc.NotSynced`,
+          context: null
+        })
+      );
+    if (cause.name === "UNAVAILABLE_SHARD")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKeys.Rpc.Shard.NotTracked`,
+          context: { shardId: cause.info.requestedShardId }
+        })
+      );
+    if (cause.name === "GARBAGE_COLLECTED_BLOCK")
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKeys.Rpc.Block.GarbageCollected`,
+          context: {
+            blockHash: cause.info.blockHash,
+            blockHeight: cause.info.blockHeight
+          }
+        })
+      );
+    if (cause.name === "UNKNOWN_BLOCK" && "blockId" in cause.info.blockReference)
+      return result.err(
+        createNatError({
+          kind: `Client.GetAccountAccessKeys.Rpc.Block.NotFound`,
+          context: {
+            blockId: cause.info.blockReference.blockId
+          }
+        })
+      );
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.GetAccountAccessKeys.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.GetAccountAccessKeys.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
 };
 
-// src/client/methods/block/getBlock.ts
+// src/client/methods/account/getAccountAccessKeys/handleResult.ts
+var z13 = __toESM(require("zod/mini"), 1);
 var import_jsonrpc_types6 = require("@near-js/jsonrpc-types");
-var transformResult6 = (result) => {
-  return (0, import_jsonrpc_types6.RpcBlockResponseSchema)().parse(result);
-};
-var createGetBlock = ({ sendRequest }) => async (args) => {
-  const result = await sendRequest({
-    method: "block",
-    params: toNativeBlockReference(args?.blockReference),
-    transportPolicy: args?.policies?.transport,
-    signal: args?.options?.signal
-  });
-  return transformResult6(result);
-};
-
-// src/client/methods/protocol/getGasPrice.ts
-var z7 = __toESM(require("zod/mini"), 1);
-var import_jsonrpc_types7 = require("@near-js/jsonrpc-types");
-
-// src/_common/schemas/zod/common.ts
-var z6 = __toESM(require("zod/mini"), 1);
-var import_base3 = require("@scure/base");
-var Base58StringSchema = z6.string().check(
-  z6.regex(
-    /^[1-9A-HJ-NP-Za-km-z]+$/,
-    oneLine(`Base58 string contains invalid characters. Allowed characters:
-    123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`)
-  )
-);
-var CryptoHashSchema6 = Base58StringSchema.check(
-  z6.refine(
-    (val) => {
-      try {
-        const bytes = import_base3.base58.decode(val);
-        return bytes.length === 32;
-      } catch {
-        return false;
-      }
-    },
-    { error: "CryptoHash string must decode to 32 bytes" }
-  )
-);
-var BlockHashSchema = CryptoHashSchema6;
-var BlockHeightSchema = z6.uint64();
-var BlockIdSchema = z6.union([BlockHeightSchema, BlockHashSchema]);
-
-// src/client/methods/protocol/getGasPrice.ts
-var transformResult7 = (result) => {
-  const valid = (0, import_jsonrpc_types7.RpcGasPriceResponseSchema)().parse(result);
-  return {
-    gasPrice: yoctoNear(valid.gasPrice)
+var RpcQueryAccessKeyListResultSchema = z13.object({
+  ...(0, import_jsonrpc_types6.AccessKeyListSchema)().shape,
+  blockHash: z13.string(),
+  blockHeight: z13.number()
+});
+var handleResult3 = (rpcResponse, args) => {
+  const rpcResult = RpcQueryAccessKeyListResultSchema.safeParse(
+    rpcResponse.result
+  );
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKeys.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  const { blockHash, blockHeight } = rpcResult.data;
+  const output = {
+    blockHash,
+    blockHeight,
+    accountId: args.accountId,
+    accountAccessKeys: rpcResult.data.keys.map(transformAccessKey),
+    rawRpcResult: rpcResult.data
   };
+  return result.ok(output);
 };
-var GetGasPriceArgsSchema = z7.optional(
-  z7.object({
-    blockId: z7.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({
-    method: "gas_price",
+
+// src/client/methods/account/getAccountAccessKeys/getAccountAccessKeys.ts
+var GetAccountAccessKeysArgsSchema = z14.object({
+  accountId: AccountIdSchema,
+  atMomentOf: z14.optional(BlockReferenceSchema),
+  policies: PoliciesSchema,
+  options: BaseOptionsSchema
+});
+var createSafeGetAccountAccessKeys = (context) => wrapInternalError("Client.GetAccountAccessKeys.Internal", async (args) => {
+  const validArgs = GetAccountAccessKeysArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKeys.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const rpcResponse = await context.sendRequest({
+    method: "query",
     params: {
-      block_id: getBlockId(args?.atMomentOf)
+      request_type: "view_access_key_list",
+      account_id: args.accountId,
+      ...toNativeBlockReference(args.atMomentOf)
     },
-    transportPolicy: args?.policies?.transport,
-    signal: args?.options?.signal
+    transportPolicy: args.policies?.transport,
+    signal: args.options?.signal
   });
-  return transformResult7(result);
-};
-
-// src/client/methods/protocol/getProtocolConfig.ts
-var z8 = __toESM(require("zod/mini"), 1);
-var import_jsonrpc_types8 = require("@near-js/jsonrpc-types");
-var TemporaryProtocolConfigShema = z8.object({
-  ...(0, import_jsonrpc_types8.RpcProtocolConfigResponseSchema)().shape,
-  runtimeConfig: z8.object({
-    ...(0, import_jsonrpc_types8.RuntimeConfigViewSchema)().shape,
-    wasmConfig: z8.omit((0, import_jsonrpc_types8.VMConfigViewSchema)(), { reftypesBulkMemory: true })
-  })
+  if (!rpcResponse.ok)
+    return result.err(
+      createNatError({
+        kind: "Client.GetAccountAccessKeys.SendRequest.Failed",
+        context: { cause: rpcResponse.error }
+      })
+    );
+  return rpcResponse.value.error ? handleError3(rpcResponse.value) : handleResult3(rpcResponse.value, args);
 });
-var transformResult8 = (result) => {
-  return TemporaryProtocolConfigShema.parse(result);
-};
-var createGetProtocolConfig = ({ sendRequest }) => async (args) => {
-  const result = await sendRequest({
-    method: "EXPERIMENTAL_protocol_config",
-    params: toNativeBlockReference(args?.atMomentOf),
-    transportPolicy: args?.policies?.transport,
-    signal: args?.options?.signal
-  });
-  return transformResult8(result);
-};
 
-// src/client/methods/transaction/sendSignedTransaction.ts
-var import_base7 = require("@scure/base");
+// src/client/methods/transaction/sendSignedTransaction/sendSignedTransaction.ts
+var z26 = __toESM(require("zod/mini"), 1);
+var import_base3 = require("@scure/base");
 
-// src/_common/transformers/toBorshBytes/signedTransaction.ts
+// src/_common/transformers/toBorshBytes/transaction.ts
 var import_borsh = require("borsh");
 
 // src/_common/schemas/borsh/publicKey.ts
@@ -1002,8 +1372,6 @@ var transactionBorshSchema = {
     actions: { array: { type: actionBorshSchema } }
   }
 };
-
-// src/_common/schemas/borsh/signedTransaction.ts
 var signedTransactionBorshSchema = {
   struct: {
     transaction: transactionBorshSchema,
@@ -1011,39 +1379,16 @@ var signedTransactionBorshSchema = {
   }
 };
 
-// src/_common/transformers/curveString.ts
-var import_base4 = require("@scure/base");
-var toEd25519CurveString = (u8Data) => `ed25519:${import_base4.base58.encode(u8Data)}`;
-var toSecp256k1CurveString = (u8Data) => `secp256k1:${import_base4.base58.encode(u8Data)}`;
-var fromCurveString = (value) => {
-  const [curve, base58String] = value.split(":");
-  return {
-    curve,
-    u8Data: import_base4.base58.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
-var import_base6 = require("@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 } };
-};
+var toNativePublicKey = ({
+  u8PublicKey,
+  curve
+}) => curve === "ed25519" ? { ed25519Key: { data: u8PublicKey } } : { secp256k1Key: { data: u8PublicKey } };
 
 // src/_common/transformers/toNative/actions/transfer.ts
 var toNativeTransferAction = (action) => ({
   transfer: {
-    deposit: fromNearOption(action.params.amount).yoctoNear
+    deposit: throwableNearToken(action.amount).yoctoNear
   }
 });
 
@@ -1053,74 +1398,210 @@ var toNativeCreateAccountAction = () => ({
 });
 
 // src/_common/transformers/toNative/actions/addKey.ts
-var getPermission = (params) => {
-  if (params.accessType === "FullAccess") return { fullAccess: {} };
-  const { contractAccountId, gasBudget, allowedFunctions } = params;
+var getPermission = (action) => {
+  if (action.accessType === "FullAccess") return { fullAccess: {} };
+  const { contractAccountId, gasBudget, allowedFunctions } = action;
   return {
     functionCall: {
       receiverId: contractAccountId,
-      allowance: gasBudget && fromNearOption(gasBudget).yoctoNear,
+      allowance: gasBudget && throwableNearToken(gasBudget).yoctoNear,
       methodNames: allowedFunctions ?? []
     }
   };
 };
 var toNativeAddKeyAction = (action) => ({
   addKey: {
-    publicKey: toNativePublicKey(action.params.publicKey),
+    publicKey: toNativePublicKey(action.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)
+      permission: getPermission(action)
     }
   }
 });
 
 // src/_common/transformers/toNative/actions/deployContract.ts
-var import_base5 = require("@scure/base");
-var toNativeDeployContractAction = (action) => {
-  const code = action.params.wasmBytes ? action.params.wasmBytes : import_base5.base64.decode(action.params.wasmBase64);
-  return {
-    deployContract: { code }
-  };
-};
+var toNativeDeployContractAction = (action) => ({
+  deployContract: { code: action.wasmBytes }
+});
 
-// 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/schemas/zod/common/nearGas.ts
+var z15 = __toESM(require("zod/mini"), 1);
+var GasInputSchema = z15.union([
+  z15.bigint(),
+  z15.pipe(
+    z15.number().check(z15.int()),
+    z15.transform((v) => BigInt(v))
+  )
+]);
+var createTeraGasInputSchema = (decimals) => z15.string().check(
+  z15.refine(
+    (val) => {
+      const decimalPattern = new RegExp(`^\\d+(?:\\.\\d{1,${decimals}})?$`);
+      return decimalPattern.test(val);
+    },
+    {
+      message: `Must be a valid number with up to ${decimals} decimal places`
+    }
+  )
+);
+var TeraGasInputSchema = createTeraGasInputSchema(12);
+var NearGasArgsSchema = z15.union([
+  z15.object({
+    gas: GasInputSchema
+  }),
+  z15.object({
+    teraGas: TeraGasInputSchema
+  })
+]);
 
-// 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/helpers/nearGas.ts
+var NearGasBrand = Symbol("NearGas");
+var cache2 = {
+  gas: /* @__PURE__ */ new WeakMap(),
+  teraGas: /* @__PURE__ */ new WeakMap()
+};
+var isNearGas = (value) => typeof value === "object" && value !== null && NearGasBrand in value;
+var toGas = (x) => {
+  if (isNearGas(x)) return result.ok(x.gas);
+  const nearGas = safeNearGas(x);
+  return nearGas.ok ? result.ok(nearGas.value.gas) : nearGas;
+};
+var nearGasProto = {
+  [NearGasBrand]: true,
+  get teraGas() {
+    const maybeValue = cache2.teraGas.get(this);
+    if (maybeValue) return maybeValue;
+    const value = convertUnitsToTokens(this.gas, 12);
+    cache2.teraGas.set(this, value);
+    return value;
+  },
+  get gas() {
+    const maybeValue = cache2.gas.get(this);
+    if (maybeValue) return maybeValue;
+    const value = convertTokensToUnits(this.teraGas, 12);
+    cache2.gas.set(this, value);
+    return value;
+  },
+  // TODO Need to reuse method code and reduce boilerplate code, and reduce useless
+  // transformations
+  safeAdd(value) {
+    return wrapInternalError("CreateNearGas.Internal", () => {
+      const gas = toGas(value);
+      return gas.ok ? safeNearGas({ gas: this.gas + gas.value }) : gas;
+    })();
+  },
+  add(value) {
+    return asThrowable(this.safeAdd.bind(this))(value);
+  },
+  safeSub(value) {
+    return wrapInternalError("CreateNearGas.Internal", () => {
+      const gas = toGas(value);
+      return gas.ok ? safeNearGas({ gas: this.gas - gas.value }) : gas;
+    })();
+  },
+  sub(value) {
+    return asThrowable(this.safeSub.bind(this))(value);
+  },
+  safeGt(value) {
+    return wrapInternalError("CreateNearGas.Internal", () => {
+      const gas = toGas(value);
+      return gas.ok ? result.ok(this.gas > gas.value) : gas;
+    })();
+  },
+  gt(value) {
+    return asThrowable(this.safeGt.bind(this))(value);
+  },
+  safeLt(value) {
+    return wrapInternalError("CreateNearGas.Internal", () => {
+      const gas = toGas(value);
+      return gas.ok ? result.ok(this.gas < gas.value) : gas;
+    })();
+  },
+  lt(value) {
+    return asThrowable(this.safeLt.bind(this))(value);
+  },
+  toString() {
+    return JSON.stringify({
+      teraGas: this.teraGas,
+      gas: this.gas.toString()
+    });
+  },
+  // In Node.js, this allows you to see the teraGas/gas 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 { teraGas: this.teraGas, gas: this.gas };
+    }
+  }
 };
+var safeGas = wrapInternalError(
+  "CreateNearGasFromGas.Internal",
+  (gas) => {
+    const validGas = GasInputSchema.safeParse(gas);
+    if (!validGas.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearGasFromGas.Args.InvalidSchema",
+          context: { zodError: validGas.error }
+        })
+      );
+    const nearGas = Object.create(nearGasProto);
+    Object.defineProperty(nearGas, "gas", {
+      value: validGas.data,
+      enumerable: true
+    });
+    return result.ok(Object.freeze(nearGas));
+  }
+);
+var throwableGas = asThrowable(safeGas);
+var safeTeraGas = wrapInternalError(
+  "CreateNearGasFromTeraGas.Internal",
+  (teraGas) => {
+    const validTeraGas = TeraGasInputSchema.safeParse(teraGas);
+    if (!validTeraGas.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearGasFromTeraGas.Args.InvalidSchema",
+          context: { zodError: validTeraGas.error }
+        })
+      );
+    const nearGas = Object.create(nearGasProto);
+    Object.defineProperty(nearGas, "teraGas", {
+      value: validTeraGas.data,
+      enumerable: true
+    });
+    return result.ok(Object.freeze(nearGas));
+  }
+);
+var throwableTeraGas = asThrowable(safeTeraGas);
+var safeNearGas = wrapInternalError(
+  "CreateNearGas.Internal",
+  (args) => {
+    const validArgs = NearGasArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateNearGas.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    return "gas" in args ? result.ok(throwableGas(args.gas)) : result.ok(throwableTeraGas(args.teraGas));
+  }
+);
+var throwableNearGas = asThrowable(safeNearGas);
 
 // src/_common/transformers/toNative/actions/functionCall.ts
 var toNativeFunctionCallAction = (action) => {
-  const { functionName, attachedDeposit, gasLimit } = action.params;
+  const { functionName, attachedDeposit, gasLimit, functionArgs } = action;
   return {
     functionCall: {
       methodName: functionName,
-      args: toContractFnArgsBytes(action.params),
-      gas: fromGasOption(gasLimit).gas,
-      deposit: attachedDeposit ? fromNearOption(attachedDeposit).yoctoNear : 0n
+      args: functionArgs,
+      gas: throwableNearGas(gasLimit).gas,
+      deposit: attachedDeposit ? throwableNearToken(attachedDeposit).yoctoNear : 0n
     }
   };
 };
@@ -1128,31 +1609,32 @@ var toNativeFunctionCallAction = (action) => {
 // src/_common/transformers/toNative/actions/deleteKey.ts
 var toNativeDeleteKeyAction = (action) => ({
   deleteKey: {
-    publicKey: toNativePublicKey(action.params.publicKey)
+    publicKey: toNativePublicKey(action.publicKey)
   }
 });
 
 // src/_common/transformers/toNative/actions/deleteAccount.ts
 var toNativeDeleteAccountAction = (action) => ({
   deleteAccount: {
-    beneficiaryId: action.params.beneficiaryAccountId
+    beneficiaryId: action.beneficiaryAccountId
   }
 });
 
+// src/_common/transformers/toNative/signature.ts
+var toNativeSignature = ({
+  u8Signature,
+  curve
+}) => curve === "ed25519" ? { ed25519Signature: { data: u8Signature } } : { secp256k1Signature: { data: u8Signature } };
+
 // 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 === "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 === "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");
+  return toNativeDeleteAccountAction(action);
 };
 var toNativeActions = (transaction) => {
   if (transaction.action) return [toNativeAction(transaction.action)];
@@ -1166,86 +1648,527 @@ var toNativeTransaction = (transaction) => ({
   actions: toNativeActions(transaction),
   receiverId: transaction.receiverAccountId,
   nonce: BigInt(transaction.nonce),
-  blockHash: import_base6.base58.decode(transaction.blockHash)
+  blockHash: transaction.blockHash.u8CryptoHash
+});
+var toNativeSignedTransaction = (signedTransaction) => ({
+  transaction: toNativeTransaction(signedTransaction.transaction),
+  signature: toNativeSignature(signedTransaction.signature)
+});
+
+// src/_common/transformers/toBorshBytes/transaction.ts
+var toBorshTransaction = (transaction) => {
+  const nativeTransaction = toNativeTransaction(transaction);
+  return (0, import_borsh.serialize)(transactionBorshSchema, nativeTransaction);
+};
+var toBorshSignedTransaction = (signedTransaction) => {
+  const nativeSignedTransaction = toNativeSignedTransaction(signedTransaction);
+  return (0, import_borsh.serialize)(signedTransactionBorshSchema, nativeSignedTransaction);
+};
+
+// src/_common/schemas/zod/transaction/transaction.ts
+var z24 = __toESM(require("zod/mini"), 1);
+
+// src/_common/schemas/zod/transaction/actions/createAccount.ts
+var z16 = __toESM(require("zod/mini"), 1);
+var CreateAccountActionSchema = z16.object({
+  actionType: z16.literal("CreateAccount")
+});
+
+// src/_common/schemas/zod/transaction/actions/addKey.ts
+var z17 = __toESM(require("zod/mini"), 1);
+var AddFullAccessKeyActionSchema = z17.object({
+  actionType: z17.literal("AddKey"),
+  accessType: z17.literal("FullAccess"),
+  publicKey: PublicKeySchema
 });
-var TransactionExecutionStatusMap = {
-  None: "NONE",
-  Included: "INCLUDED",
-  ExecutedOptimistic: "EXECUTED_OPTIMISTIC",
-  IncludedFinal: "INCLUDED_FINAL",
-  Executed: "EXECUTED",
-  Final: "FINAL"
+var AddFunctionCallKeyActionSchema = z17.object({
+  actionType: z17.literal("AddKey"),
+  accessType: z17.literal("FunctionCall"),
+  publicKey: PublicKeySchema,
+  contractAccountId: AccountIdSchema,
+  gasBudget: z17.optional(NearTokenArgsSchema),
+  allowedFunctions: z17.optional(
+    z17.array(ContractFunctionNameSchema).check(z17.minLength(1))
+  )
+});
+var AddKeyActionSchema = z17.union([
+  AddFullAccessKeyActionSchema,
+  AddFunctionCallKeyActionSchema
+]);
+
+// src/_common/schemas/zod/transaction/actions/transfer.ts
+var z18 = __toESM(require("zod/mini"), 1);
+var TransferActionSchema = z18.object({
+  actionType: z18.literal("Transfer"),
+  amount: NearTokenArgsSchema
+});
+
+// src/_common/schemas/zod/transaction/actions/deployContract.ts
+var z19 = __toESM(require("zod/mini"), 1);
+var DeployContractActionSchema = z19.object({
+  actionType: z19.literal("DeployContract"),
+  wasmBytes: z19.instanceof(Uint8Array)
+});
+
+// src/_common/schemas/zod/transaction/actions/deleteKey.ts
+var z20 = __toESM(require("zod/mini"), 1);
+var DeleteKeyActionSchema = z20.object({
+  actionType: z20.literal("DeleteKey"),
+  publicKey: PublicKeySchema
+});
+
+// src/_common/schemas/zod/transaction/actions/deleteAccount.ts
+var z21 = __toESM(require("zod/mini"), 1);
+var DeleteAccountActionSchema = z21.object({
+  actionType: z21.literal("DeleteAccount"),
+  beneficiaryAccountId: AccountIdSchema
+});
+
+// src/_common/schemas/zod/transaction/actions/functionCall.ts
+var z22 = __toESM(require("zod/mini"), 1);
+var FunctionCallActionSchema = z22.object({
+  actionType: z22.literal("FunctionCall"),
+  functionName: ContractFunctionNameSchema,
+  functionArgs: z22.instanceof(Uint8Array),
+  gasLimit: NearGasArgsSchema,
+  attachedDeposit: z22.optional(NearTokenArgsSchema)
+});
+
+// src/_common/schemas/zod/common/signature.ts
+var z23 = __toESM(require("zod/mini"), 1);
+var { Ed25519: Ed255192, Secp256k1: Secp256k12 } = BinaryLengths;
+var SignatureSchema = z23.pipe(
+  CurveStringSchema,
+  z23.transform((val) => ({
+    signature: val.curveString,
+    u8Signature: val.u8Data,
+    curve: val.curve
+  }))
+).check(
+  z23.refine(
+    ({ curve, u8Signature }) => curve === "ed25519" ? u8Signature.length === Ed255192.Signature : u8Signature.length === Secp256k12.Signature,
+    { error: "Invalid signature length" }
+  )
+);
+
+// src/_common/schemas/zod/transaction/transaction.ts
+var ActionSchema = z24.union([
+  CreateAccountActionSchema,
+  TransferActionSchema,
+  AddKeyActionSchema,
+  DeployContractActionSchema,
+  FunctionCallActionSchema,
+  DeleteKeyActionSchema,
+  DeleteAccountActionSchema
+]);
+var TransactionBaseSchema = z24.object({
+  signerAccountId: AccountIdSchema,
+  signerPublicKey: PublicKeySchema,
+  receiverAccountId: AccountIdSchema,
+  nonce: NonceSchema,
+  blockHash: BlockHashSchema
+});
+var SingleActionTransactionSchema = z24.object({
+  ...TransactionBaseSchema.shape,
+  action: ActionSchema,
+  actions: z24.optional(z24.never())
+});
+var MultiActionsTransactionSchema = z24.object({
+  ...TransactionBaseSchema.shape,
+  action: z24.optional(z24.never()),
+  actions: z24.array(ActionSchema).check(z24.minLength(1))
+});
+var TransactionSchema = z24.union([
+  SingleActionTransactionSchema,
+  MultiActionsTransactionSchema
+]);
+var SingleActionTransactionIntentSchema = z24.object({
+  action: ActionSchema,
+  actions: z24.optional(z24.never()),
+  receiverAccountId: AccountIdSchema
+});
+var MultiActionsTransactionIntentSchema = z24.object({
+  action: z24.optional(z24.never()),
+  actions: z24.array(ActionSchema).check(z24.minLength(1)),
+  receiverAccountId: AccountIdSchema
+});
+var TransactionIntentSchema = z24.union([
+  SingleActionTransactionIntentSchema,
+  MultiActionsTransactionIntentSchema
+]);
+var SignedTransactionSchema = z24.object({
+  transaction: TransactionSchema,
+  transactionHash: CryptoHashSchema,
+  signature: SignatureSchema
+});
+
+// src/client/methods/transaction/sendSignedTransaction/handleError/handleError.ts
+var import_jsonrpc_types8 = require("@near-js/jsonrpc-types");
+
+// src/client/methods/transaction/sendSignedTransaction/handleError/handleInvalidTransaction.ts
+var z25 = __toESM(require("zod/mini"), 1);
+var import_jsonrpc_types7 = require("@near-js/jsonrpc-types");
+var InvalidTransactionErrorSchema = z25.object({
+  TxExecutionError: z25.object({
+    InvalidTxError: (0, import_jsonrpc_types7.InvalidTxErrorSchema)()
+  })
+});
+var handleInvalidTransaction = (rpcResponse) => {
+  const invalidTransactionError = InvalidTransactionErrorSchema.safeParse(
+    rpcResponse.error?.data
+  );
+  if (!invalidTransactionError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: invalidTransactionError.error }
+          })
+        }
+      })
+    );
+  const { InvalidTxError } = invalidTransactionError.data.TxExecutionError;
+  if (typeof InvalidTxError === "string") {
+    if (InvalidTxError === "Expired") {
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Expired",
+          context: null
+        })
+      );
+    }
+    if (InvalidTxError === "InvalidSignature") {
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Signature.Invalid",
+          context: null
+        })
+      );
+    }
+  }
+  if (typeof InvalidTxError === "object") {
+    if ("InvalidNonce" in InvalidTxError) {
+      const { akNonce, txNonce } = InvalidTxError.InvalidNonce;
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Nonce.Invalid",
+          context: {
+            accessKeyNonce: akNonce,
+            transactionNonce: txNonce
+          }
+        })
+      );
+    }
+    if ("SignerDoesNotExist" in InvalidTxError) {
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Signer.NotFound",
+          context: {
+            signerAccountId: InvalidTxError.SignerDoesNotExist.signerId
+          }
+        })
+      );
+    }
+    if ("NotEnoughBalance" in InvalidTxError) {
+      const { signerId, balance, cost } = InvalidTxError.NotEnoughBalance;
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Signer.Balance.TooLow",
+          context: {
+            balance: throwableYoctoNear(balance),
+            transactionCost: throwableYoctoNear(cost),
+            signerAccountId: signerId
+          }
+        })
+      );
+    }
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.SendSignedTransaction.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
+};
+
+// src/client/methods/transaction/sendSignedTransaction/handleError/handleError.ts
+var handleError4 = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types8.ErrorWrapperFor_RpcTransactionErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "TIMEOUT_ERROR")
+      return result.err(
+        createNatError({
+          kind: `Client.SendSignedTransaction.Rpc.Transaction.Timeout`,
+          context: null
+        })
+      );
+    if (cause.name === "INVALID_TRANSACTION")
+      return handleInvalidTransaction(rpcResponse);
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.SendSignedTransaction.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
 };
-var toNativeTransactionExecutionStatus = (status) => TransactionExecutionStatusMap[status];
 
-// src/_common/transformers/toNative/signedTransaction.ts
-var toNativeSignedTransaction = (signedTransaction) => ({
-  transaction: toNativeTransaction(signedTransaction.transaction),
-  signature: toNativeSignature(signedTransaction.signature)
-});
+// src/client/methods/transaction/sendSignedTransaction/handleResult/handleResult.ts
+var import_jsonrpc_types9 = require("@near-js/jsonrpc-types");
 
-// src/_common/transformers/toBorshBytes/signedTransaction.ts
-var serializeNativeSignedTransaction = (nativeSignedTransaction) => (0, import_borsh.serialize)(signedTransactionBorshSchema, nativeSignedTransaction);
-var serializeSignedTransaction = (signedTransaction) => serializeNativeSignedTransaction(
-  toNativeSignedTransaction(signedTransaction)
-);
+// src/client/methods/transaction/sendSignedTransaction/handleResult/handleActionError.ts
+var handleActionError = (actionError, rpcResponse, inputArgs) => {
+  const { transactionHash } = inputArgs.signedTransaction;
+  const { kind, index: actionIndex } = actionError;
+  if (typeof actionIndex !== "number")
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.Internal",
+        context: {
+          cause: createNatError({
+            kind: "Client.SendSignedTransaction.Rpc.Transaction.Action.InvalidIndex",
+            context: { rpcResponse }
+          })
+        }
+      })
+    );
+  if (typeof kind === "object") {
+    if ("AccountAlreadyExists" in kind) {
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Action.CreateAccount.AlreadyExist",
+          context: {
+            accountId: kind.AccountAlreadyExists.accountId,
+            actionIndex,
+            transactionHash
+          }
+        })
+      );
+    }
+    if ("AccountDoesNotExist" in kind) {
+      return result.err(
+        createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Transaction.Receiver.NotFound",
+          context: {
+            receiverAccountId: kind.AccountDoesNotExist.accountId,
+            actionIndex,
+            transactionHash
+          }
+        })
+      );
+    }
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.SendSignedTransaction.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.SendSignedTransaction.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
+};
 
-// src/client/methods/transaction/sendSignedTransaction.ts
-var import_jsonrpc_types9 = require("@near-js/jsonrpc-types");
-var transformResult9 = (result) => {
-  return (0, import_jsonrpc_types9.RpcTransactionResponseSchema)().parse(result);
+// src/client/methods/transaction/sendSignedTransaction/handleResult/handleResult.ts
+var handleResult4 = (rpcResponse, inputArgs) => {
+  const rpcResult = (0, import_jsonrpc_types9.RpcTransactionResponseSchema)().safeParse(
+    rpcResponse.result
+  );
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  if (typeof rpcResult.data.status === "object" && "Failure" in rpcResult.data.status && "ActionError" in rpcResult.data.status.Failure)
+    return handleActionError(
+      rpcResult.data.status.Failure.ActionError,
+      rpcResponse,
+      inputArgs
+    );
+  const output = {
+    rawRpcResult: rpcResult.data
+    // TODO Return result without errors
+  };
+  return result.ok(output);
 };
-var createSendSignedTransaction = ({ sendRequest }) => async (args) => {
-  const waitUntil = args?.policies?.waitUntil ?? "ExecutedOptimistic";
-  const result = await sendRequest({
+
+// src/client/methods/transaction/sendSignedTransaction/sendSignedTransaction.ts
+var SendSignedTransactionArgsShema = z26.object({
+  signedTransaction: SignedTransactionSchema,
+  policies: PoliciesSchema,
+  options: BaseOptionsSchema
+});
+var createSafeSendSignedTransaction = (context) => wrapInternalError("Client.SendSignedTransaction.Internal", async (args) => {
+  const validArgs = SendSignedTransactionArgsShema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const rpcResponse = await context.sendRequest({
     method: "send_tx",
     params: {
-      signed_tx_base64: import_base7.base64.encode(
-        serializeSignedTransaction(args.signedTransaction)
+      signed_tx_base64: import_base3.base64.encode(
+        toBorshSignedTransaction(validArgs.data.signedTransaction)
       ),
-      wait_until: toNativeTransactionExecutionStatus(waitUntil)
+      wait_until: "FINAL"
     },
     transportPolicy: args.policies?.transport,
     signal: args.options?.signal
   });
-  return transformResult9(result);
-};
+  if (!rpcResponse.ok)
+    return result.err(
+      createNatError({
+        kind: "Client.SendSignedTransaction.SendRequest.Failed",
+        context: { cause: rpcResponse.error }
+      })
+    );
+  return rpcResponse.value.error ? handleError4(rpcResponse.value) : handleResult4(rpcResponse.value, args);
+});
 
-// src/client/transport/transportPolicy.ts
-var import_lodash_es = require("lodash-es");
-var defaultTransportPolicy = {
-  rpcTypePreferences: ["Regular", "Archival"],
-  timeouts: {
-    requestMs: 3e4,
-    attemptMs: 1e4
-  },
-  retry: {
-    maxAttempts: 2,
-    backoff: {
-      minDelayMs: 100,
-      maxDelayMs: 200,
-      multiplier: 3
-    }
-  },
-  failover: {
-    maxRounds: 2,
-    nextRpcDelayMs: 100,
-    nextRoundDelayMs: 100
+// src/client/methods/block/getBlock/getBlock.ts
+var z27 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/block/getBlock/handleError.ts
+var import_jsonrpc_types10 = require("@near-js/jsonrpc-types");
+var handleError5 = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types10.ErrorWrapperFor_RpcBlockErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetBlock.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NOT_SYNCED_YET")
+      return result.err(
+        createNatError({
+          kind: `Client.GetBlock.Rpc.NotSynced`,
+          context: null
+        })
+      );
+    if (cause.name === "UNKNOWN_BLOCK")
+      return result.err(
+        createNatError({
+          kind: `Client.GetBlock.Rpc.Block.NotFound`,
+          context: null
+        })
+      );
   }
+  return result.err(
+    createNatError({
+      kind: "Client.GetBlock.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.GetBlock.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
 };
-var mergeTransportPolicy = (base, next = {}) => (0, import_lodash_es.mergeWith)(
-  {},
-  (0, import_lodash_es.cloneDeep)(base),
-  (0, import_lodash_es.cloneDeep)(next),
-  (_objValue, srcValue, key) => {
-    if (key === "rpcTypePreferences" && Array.isArray(srcValue)) {
-      return srcValue;
-    }
-  }
-);
 
-// src/client/transport/sendRequest/5-sendOnce/sendOnce.ts
-var z10 = __toESM(require("zod/mini"), 1);
+// src/client/methods/block/getBlock/handleResult.ts
+var import_jsonrpc_types11 = require("@near-js/jsonrpc-types");
+var handleResult5 = (rpcResponse) => {
+  const rpcResult = (0, import_jsonrpc_types11.RpcBlockResponseSchema)().safeParse(rpcResponse.result);
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetBlock.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  const output = {
+    rawRpcResult: rpcResult.data
+  };
+  return result.ok(output);
+};
+
+// src/client/methods/block/getBlock/getBlock.ts
+var GetBlockArgsSchema = z27.optional(
+  z27.object({
+    blockReference: z27.optional(BlockReferenceSchema),
+    policies: PoliciesSchema,
+    options: BaseOptionsSchema
+  })
+);
+var createSafeGetBlock = (context) => wrapInternalError("Client.GetBlock.Internal", async (args) => {
+  const validArgs = GetBlockArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "Client.GetBlock.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const rpcResponse = await context.sendRequest({
+    method: "block",
+    params: toNativeBlockReference(args?.blockReference),
+    transportPolicy: args?.policies?.transport,
+    signal: args?.options?.signal
+  });
+  if (!rpcResponse.ok)
+    return result.err(
+      createNatError({
+        kind: "Client.GetBlock.SendRequest.Failed",
+        context: { cause: rpcResponse.error }
+      })
+    );
+  return rpcResponse.value.error ? handleError5(rpcResponse.value) : handleResult5(rpcResponse.value);
+});
 
 // src/_common/utils/snakeToCamelCase.ts
 var snakeToCamelCase = (obj) => {
@@ -1271,24 +2194,69 @@ var snakeToCamelCase = (obj) => {
 };
 
 // src/_common/schemas/zod/rpc.ts
-var z9 = __toESM(require("zod/mini"), 1);
-var import_jsonrpc_types10 = require("@near-js/jsonrpc-types");
-var RpcResponseSchema = z9.object({
-  jsonrpc: z9.literal("2.0"),
-  id: z9.unknown(),
-  result: z9.optional(z9.unknown()),
-  error: z9.optional((0, import_jsonrpc_types10.RpcErrorSchema)())
+var z28 = __toESM(require("zod/mini"), 1);
+var BaseRpcResponseSchema = z28.object({
+  jsonrpc: z28.literal("2.0"),
+  id: z28.number()
 });
+var BaseRpcErrorSchema = z28.object({
+  code: z28.number(),
+  message: z28.string(),
+  data: z28.optional(z28.unknown())
+});
+var RpcErrorSchema = z28.discriminatedUnion("name", [
+  z28.object({
+    ...BaseRpcErrorSchema.shape,
+    name: z28.literal("REQUEST_VALIDATION_ERROR"),
+    cause: z28.discriminatedUnion("name", [
+      z28.object({
+        name: z28.literal("METHOD_NOT_FOUND"),
+        info: z28.object({ methodName: z28.string() })
+      }),
+      z28.object({
+        name: z28.literal("PARSE_ERROR"),
+        info: z28.object({ errorMessage: z28.string() })
+      })
+    ])
+  }),
+  z28.object({
+    ...BaseRpcErrorSchema.shape,
+    name: z28.literal("HANDLER_ERROR"),
+    cause: z28.object({
+      info: z28.unknown(),
+      name: z28.string()
+    })
+  }),
+  z28.object({
+    ...BaseRpcErrorSchema.shape,
+    name: z28.literal("INTERNAL_ERROR"),
+    cause: z28.object({
+      name: z28.literal("INTERNAL_ERROR"),
+      info: z28.object({ errorMessage: z28.string() })
+    })
+  })
+]);
+var RpcResponseSchema = z28.union([
+  z28.object({
+    ...BaseRpcResponseSchema.shape,
+    result: z28.unknown(),
+    error: z28.optional(z28.never())
+  }),
+  z28.object({
+    ...BaseRpcResponseSchema.shape,
+    result: z28.optional(z28.never()),
+    error: RpcErrorSchema
+  })
+]);
 
 // src/client/transport/sendRequest/5-sendOnce/fetchData/createAttemptTimeout.ts
 var createAttemptTimeout = (attemptTimeoutMs) => {
   const controller = new AbortController();
   const timeoutId = setTimeout(
     () => controller.abort(
-      new TransportError({
-        code: "AttemptTimeout",
-        message: oneLine(`The request attempt exceeded the configured timeout 
-          and was aborted.`)
+      createNatError({
+        kind: "Client.Transport.SendRequest.Request.Attempt.Timeout",
+        context: { allowedMs: attemptTimeoutMs }
       })
     ),
     attemptTimeoutMs
@@ -1315,21 +2283,24 @@ var fetchData = async (context, rpc, body) => {
         attemptTimeout.signal
       ])
     });
-    return { result: response };
+    return result.ok(response);
   } catch (e) {
-    if (hasTransportErrorCode(e, [
-      "ExternalAbort",
-      "RequestTimeout",
-      "AttemptTimeout"
+    if (isNatErrorOf(e, [
+      "Client.Transport.SendRequest.Request.Attempt.Timeout",
+      "Client.Transport.SendRequest.Request.Timeout",
+      "Client.Transport.SendRequest.Request.Aborted"
     ]))
-      return { error: e };
-    return {
-      error: new TransportError({
-        code: "Fetch",
-        message: `Fetch failed: unable to send the request to '${rpc.url}' (connection refused, DNS error or network issues).`,
-        cause: e
+      return result.err(e);
+    return result.err(
+      createNatError({
+        kind: "Client.Transport.SendRequest.Request.FetchFailed",
+        context: {
+          cause: e,
+          rpc,
+          requestBody: body
+        }
       })
-    };
+    );
   } finally {
     clearTimeout(attemptTimeout.timeoutId);
   }
@@ -1338,81 +2309,86 @@ var fetchData = async (context, rpc, body) => {
 // src/client/transport/sendRequest/5-sendOnce/parseJsonResponse.ts
 var parseJsonResponse = async (response, rpc) => {
   try {
-    return { result: await response.json() };
+    return result.ok(await response.json());
   } catch (e) {
-    return {
-      error: new TransportError({
-        code: "ParseResponseToJson",
-        message: `Failed to parse response as JSON from the RPC node: ${rpc.url}`,
-        cause: e
+    return result.err(
+      createNatError({
+        kind: "Client.Transport.SendRequest.Response.JsonParseFailed",
+        context: {
+          cause: e,
+          rpc,
+          response
+        }
       })
-    };
+    );
+  }
+};
+
+// src/client/transport/sendRequest/5-sendOnce/extractRpcErrors.ts
+var prefix = "Client.Transport.SendRequest.Rpc";
+var getErrorKind = ({
+  name,
+  cause
+}) => {
+  if (name === "REQUEST_VALIDATION_ERROR") {
+    if (cause.name === "METHOD_NOT_FOUND") return `${prefix}.MethodNotFound`;
+    if (cause.name === "PARSE_ERROR") return `${prefix}.ParseFailed`;
+  }
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NO_SYNCED_BLOCKS") return `${prefix}.NotSynced`;
+    if (cause.name === "NOT_SYNCED_YET") return `${prefix}.NotSynced`;
+    if (cause.name === "TIMEOUT_ERROR") return `${prefix}.Transaction.Timeout`;
+    if (cause.name === "GARBAGE_COLLECTED_BLOCK") return `${prefix}.Block.GarbageCollected`;
+    if (cause.name === "UNKNOWN_BLOCK") return `${prefix}.Block.NotFound`;
+    if (cause.name === "INTERNAL_ERROR") return `${prefix}.Internal`;
   }
+  if (name === "INTERNAL_ERROR") return `${prefix}.Internal`;
+};
+var extractRpcErrors = (generalRpcResponse, rpc) => {
+  if ("result" in generalRpcResponse) return result.ok(generalRpcResponse);
+  const kind = getErrorKind(generalRpcResponse.error);
+  if (!kind) return result.ok(generalRpcResponse);
+  return result.err(
+    createNatError({
+      kind,
+      context: {
+        rawRpcResponse: generalRpcResponse,
+        rpc
+      }
+    })
+  );
 };
 
 // src/client/transport/sendRequest/5-sendOnce/sendOnce.ts
-var sendOnce = async (context, rpc, roundIndex, attemptIndex) => {
+var sendOnce = async (context, rpc) => {
   const body = {
     jsonrpc: "2.0",
     id: 0,
     method: context.method,
     params: context.params
   };
-  const request = {
-    url: rpc.url,
-    rpcType: rpc.type,
-    method: "POST",
-    headers: rpc.headers,
-    body,
-    roundIndex,
-    attemptIndex
-  };
   const response = await fetchData(context, rpc, body);
-  if (response.error) {
-    response.error.request = request;
-    context.errors.push(response.error);
-    return response;
-  }
-  const json = await parseJsonResponse(response.result, rpc);
-  if (json.error) {
-    json.error.request = request;
-    context.errors.push(json.error);
-    return json;
-  }
-  const camelCased = snakeToCamelCase(json.result);
-  const validated = RpcResponseSchema.safeParse(camelCased);
-  if (validated.error) {
-    const validationError = new TransportError({
-      code: "InvalidResponseSchema",
-      message: `Invalid RPC response format: 
-${z10.prettifyError(validated.error)} 
-
-Response: ${JSON.stringify(camelCased, null, 2)} 
-
-Please try again or use another RPC node.`,
-      request,
-      cause: validated.error
-    });
-    context.errors.push(validationError);
-    return { error: validationError };
-  }
-  const { result, error } = validated.data;
-  if (error) {
-    const rpcError = new RpcError({
-      request,
-      __rawRpcError: error
-    });
-    context.errors.push(rpcError);
-    return { error: rpcError };
+  if (!response.ok) return response;
+  const json2 = await parseJsonResponse(response.value, rpc);
+  if (!json2.ok) return json2;
+  const camelCased = snakeToCamelCase(json2.value);
+  const generalRpcResponse = RpcResponseSchema.safeParse(camelCased);
+  if (!generalRpcResponse.success) {
+    return result.err(
+      createNatError({
+        kind: "Client.Transport.SendRequest.Response.InvalidSchema",
+        context: { zodError: generalRpcResponse.error }
+      })
+    );
   }
-  return { result };
+  return extractRpcErrors(generalRpcResponse.data, rpc);
 };
 
 // src/_common/utils/sleep.ts
 var safeSleep = (ms, signal) => new Promise((resolve) => {
-  const abort = () => resolve(signal?.reason);
+  const abort = () => resolve(result.err(signal?.reason));
   if (signal?.aborted) abort();
-  const timeoutId = setTimeout(() => resolve(), ms);
+  const timeoutId = setTimeout(() => resolve(result.ok(true)), ms);
   if (signal)
     signal.addEventListener(
       "abort",
@@ -1426,106 +2402,97 @@ var safeSleep = (ms, signal) => new Promise((resolve) => {
 
 // src/client/transport/sendRequest/4-sendWithRetry/sendWithRetry.ts
 var getBackoffDelay = (cap, base, sleep, multiplier) => Math.min(cap, Math.round(randomBetween(base, sleep * multiplier)));
-var shouldRetry = (result) => hasTransportErrorCode(result.error, ["Fetch", "AttemptTimeout"]) || hasRpcErrorCode(result.error, [
-  "RpcTransactionTimeout",
-  "NoSyncedBlocks",
-  "UnknownRequestError",
-  "InternalServerError"
+var shouldRetry = (sendOnceResult) => !sendOnceResult.ok && isNatErrorOf(sendOnceResult.error, [
+  "Client.Transport.SendRequest.Request.FetchFailed",
+  "Client.Transport.SendRequest.Request.Attempt.Timeout",
+  "Client.Transport.SendRequest.Rpc.Transaction.Timeout",
+  "Client.Transport.SendRequest.Rpc.NotSynced",
+  "Client.Transport.SendRequest.Rpc.Internal"
 ]);
-var sendWithRetry = async (context, rpc, roundIndex) => {
-  const { maxAttempts, backoff } = context.transportPolicy.retry;
-  let backoffDelay = backoff.minDelayMs;
+var sendWithRetry = async (context, rpc) => {
+  const { maxAttempts, retryBackoff } = context.transportPolicy.rpc;
+  let backoffDelay = retryBackoff.minDelayMs;
   const attempt = async (attemptIndex) => {
-    const result = await sendOnce(context, rpc, roundIndex, attemptIndex);
+    const sendOnceResult = await sendOnce(context, rpc);
     const isLastAttempt = attemptIndex >= maxAttempts - 1;
-    if (isLastAttempt || !shouldRetry(result)) return result;
+    if (isLastAttempt || !shouldRetry(sendOnceResult)) return sendOnceResult;
     backoffDelay = getBackoffDelay(
-      backoff.maxDelayMs,
-      backoff.minDelayMs,
+      retryBackoff.maxDelayMs,
+      retryBackoff.minDelayMs,
       backoffDelay,
-      backoff.multiplier
+      retryBackoff.multiplier
     );
-    const abortError = await safeSleep(
+    const sleepResult = await safeSleep(
       backoffDelay,
       combineAbortSignals([
         context.externalAbortSignal,
         context.requestTimeoutSignal
       ])
     );
-    if (abortError) {
-      context.errors.push(abortError);
-      return { error: abortError };
-    }
-    return attempt(attemptIndex + 1);
+    return sleepResult.ok ? attempt(attemptIndex + 1) : sleepResult;
   };
   return attempt(0);
 };
 
 // src/client/transport/sendRequest/3-tryOneRound/tryOneRound.ts
-var shouldTryAnotherRpc = (result) => hasTransportErrorCode(result.error, [
-  "Fetch",
-  "AttemptTimeout",
-  "ParseResponseToJson",
-  "InvalidResponseSchema"
-]) || hasRpcErrorCode(result.error, [
-  "ParseRequest",
-  "MethodNotFound",
-  "UnknownValidationError",
-  "RpcTransactionTimeout"
+var shouldTryAnotherRpc = (sendOnceResult) => !sendOnceResult.ok && isNatErrorOf(sendOnceResult.error, [
+  "Client.Transport.SendRequest.Request.FetchFailed",
+  "Client.Transport.SendRequest.Request.Attempt.Timeout",
+  "Client.Transport.SendRequest.Response.JsonParseFailed",
+  "Client.Transport.SendRequest.Response.InvalidSchema",
+  "Client.Transport.SendRequest.Rpc.MethodNotFound",
+  "Client.Transport.SendRequest.Rpc.ParseFailed",
+  "Client.Transport.SendRequest.Rpc.Transaction.Timeout",
+  "Client.Transport.SendRequest.Rpc.NotSynced",
+  "Client.Transport.SendRequest.Rpc.Internal"
 ]);
-var tryOneRound = async (context, rpcs, roundIndex) => {
+var tryOneRound = async (context, rpcs) => {
   const { nextRpcDelayMs } = context.transportPolicy.failover;
   const roundOnRpc = async (rpcIndex) => {
     const rpc = rpcs[rpcIndex];
-    const result = await sendWithRetry(context, rpc, roundIndex);
+    const sendWithRetryResult = await sendWithRetry(context, rpc);
     const isLastRpc = rpcIndex >= rpcs.length - 1;
-    if (isLastRpc || !shouldTryAnotherRpc(result)) return result;
-    const abortError = await safeSleep(
+    if (isLastRpc || !shouldTryAnotherRpc(sendWithRetryResult))
+      return sendWithRetryResult;
+    const sleepResult = await safeSleep(
       nextRpcDelayMs,
       combineAbortSignals([
         context.externalAbortSignal,
         context.requestTimeoutSignal
       ])
     );
-    if (abortError) {
-      context.errors.push(abortError);
-      return { error: abortError };
-    }
-    return roundOnRpc(rpcIndex + 1);
+    return sleepResult.ok ? roundOnRpc(rpcIndex + 1) : sleepResult;
   };
   return roundOnRpc(0);
 };
 
 // src/client/transport/sendRequest/2-tryMultipleRounds/tryMultipleRounds.ts
-var shouldTryAnotherRound = (result) => hasTransportErrorCode(result.error, [
-  "Fetch",
-  "AttemptTimeout",
-  "ParseResponseToJson",
-  "InvalidResponseSchema"
-]) || hasRpcErrorCode(result.error, [
-  "ParseRequest",
-  "MethodNotFound",
-  "UnknownValidationError",
-  "RpcTransactionTimeout"
+var shouldTryAnotherRound = (sendOnceResult) => !sendOnceResult.ok && isNatErrorOf(sendOnceResult.error, [
+  "Client.Transport.SendRequest.Request.FetchFailed",
+  "Client.Transport.SendRequest.Request.Attempt.Timeout",
+  "Client.Transport.SendRequest.Response.JsonParseFailed",
+  "Client.Transport.SendRequest.Response.InvalidSchema",
+  "Client.Transport.SendRequest.Rpc.MethodNotFound",
+  "Client.Transport.SendRequest.Rpc.ParseFailed",
+  "Client.Transport.SendRequest.Rpc.Transaction.Timeout",
+  "Client.Transport.SendRequest.Rpc.NotSynced",
+  "Client.Transport.SendRequest.Rpc.Internal"
 ]);
 var tryMultipleRounds = async (context, rpcs) => {
   const { maxRounds, nextRoundDelayMs } = context.transportPolicy.failover;
   const round = async (roundIndex) => {
-    const result = await tryOneRound(context, rpcs, roundIndex);
+    const tryOneRoundResult = await tryOneRound(context, rpcs);
     const isLastRound = roundIndex >= maxRounds - 1;
-    if (isLastRound || !shouldTryAnotherRound(result)) return result;
-    const abortError = await safeSleep(
+    if (isLastRound || !shouldTryAnotherRound(tryOneRoundResult))
+      return tryOneRoundResult;
+    const sleepResult = await safeSleep(
       nextRoundDelayMs,
       combineAbortSignals([
         context.externalAbortSignal,
         context.requestTimeoutSignal
       ])
     );
-    if (abortError) {
-      context.errors.push(abortError);
-      return { error: abortError };
-    }
-    return round(roundIndex + 1);
+    return sleepResult.ok ? round(roundIndex + 1) : sleepResult;
   };
   return round(0);
 };
@@ -1538,10 +2505,9 @@ var createExternalAbortSignal = (inputSignal) => {
     "abort",
     () => {
       controller.abort(
-        new TransportError({
-          code: "ExternalAbort",
-          message: `The request was aborted by user.`,
-          cause: inputSignal.reason
+        createNatError({
+          kind: "Client.Transport.SendRequest.Request.Aborted",
+          context: { reason: inputSignal.reason }
         })
       );
     },
@@ -1555,10 +2521,9 @@ var createRequestTimeout = (requestTimeoutMs) => {
   const controller = new AbortController();
   const timeoutId = setTimeout(
     () => controller.abort(
-      new TransportError({
-        code: "RequestTimeout",
-        message: oneLine(`The request exceeded the configured timeout 
-          and was aborted.`)
+      createNatError({
+        kind: "Client.Transport.SendRequest.Request.Timeout",
+        context: { allowedMs: requestTimeoutMs }
       })
     ),
     requestTimeoutMs
@@ -1570,36 +2535,40 @@ var createRequestTimeout = (requestTimeoutMs) => {
 };
 
 // src/client/transport/sendRequest/1-createSendRequest/_common/getAvailableRpcs.ts
-var getAvailableRpcs = (rpcEndpoints, rpcTypePriority) => {
-  const sortedList = rpcTypePriority.reduce((acc, type) => {
-    const normalizedType = type === "Regular" ? "regular" : "archival";
-    const value = rpcEndpoints[normalizedType] ?? [];
-    acc.push(...value);
-    return acc;
-  }, []);
-  if (sortedList.length === 0)
-    return {
-      error: new TransportError({
-        code: "NoAvailableRpc",
-        message: `Invalid request configuration: no RPC endpoints found for any of the preferred types (${rpcTypePriority.join(", ")}).`
-      })
-    };
-  return { result: sortedList };
+var getAvailableRpcs = (rpcEndpoints, rpcTypePreferences) => {
+  const sortedList = rpcTypePreferences.reduce(
+    (acc, type) => {
+      const normalizedType = type === "Regular" ? "regular" : "archival";
+      const value = rpcEndpoints[normalizedType] ?? [];
+      acc.push(...value);
+      return acc;
+    },
+    []
+  );
+  return sortedList.length > 0 ? result.ok(sortedList) : result.err(
+    createNatError({
+      kind: "Client.Transport.SendRequest.PreferredRpc.NotFound",
+      context: {
+        rpcEndpoints,
+        rpcTypePreferences
+      }
+    })
+  );
 };
 
 // src/client/transport/sendRequest/1-createSendRequest/handleMaybeUnknownBlock.ts
 var handleMaybeUnknownBlock = async ({
-  result: previousResult,
+  requestResult: previousResult,
   rpcEndpoints,
   context
 }) => {
-  if (!(hasRpcErrorCode(previousResult.error, [
-    "UnknownBlock",
-    "GarbageCollectedBlock"
-  ]) && previousResult.error?.request?.rpcType === "regular" && context.transportPolicy.rpcTypePreferences.includes("Archival")))
+  if (previousResult.ok || !(isNatErrorOf(previousResult.error, [
+    "Client.Transport.SendRequest.Rpc.Block.GarbageCollected",
+    "Client.Transport.SendRequest.Rpc.Block.NotFound"
+  ]) && previousResult.error.context.rpc.type === "regular" && context.transportPolicy.rpcTypePreferences.includes("Archival")))
     return previousResult;
   const rpcs = getAvailableRpcs(rpcEndpoints, ["Archival"]);
-  if (rpcs.error) return previousResult;
+  if (!rpcs.ok) return previousResult;
   return await tryOneRound(
     {
       ...context,
@@ -1607,8 +2576,7 @@ var handleMaybeUnknownBlock = async ({
         rpcTypePreferences: ["Archival"]
       })
     },
-    rpcs.result,
-    0
+    rpcs.value
   );
 };
 
@@ -1622,8 +2590,8 @@ var createSendRequest = (transportContext) => async (args) => {
     transportContext.rpcEndpoints,
     transportPolicy.rpcTypePreferences
   );
-  if (rpcs.error) throw rpcs.error;
-  const externalAbortSignal = createExternalAbortSignal(args.signal);
+  if (!rpcs.ok) return rpcs;
+  const maybeExternalAbortSignal = createExternalAbortSignal(args.signal);
   const requestTimeout = createRequestTimeout(
     transportPolicy.timeouts.requestMs
   );
@@ -1631,65 +2599,76 @@ var createSendRequest = (transportContext) => async (args) => {
     transportPolicy,
     method: args.method,
     params: args.params,
-    externalAbortSignal,
-    requestTimeoutSignal: requestTimeout.signal,
-    errors: []
+    externalAbortSignal: maybeExternalAbortSignal,
+    requestTimeoutSignal: requestTimeout.signal
   };
-  let result = await tryMultipleRounds(context, rpcs.result);
-  result = await handleMaybeUnknownBlock({
-    result,
+  let requestResult = await tryMultipleRounds(context, rpcs.value);
+  requestResult = await handleMaybeUnknownBlock({
+    requestResult,
     context,
     rpcEndpoints: transportContext.rpcEndpoints
   });
   clearTimeout(requestTimeout.timeoutId);
-  if (context.errors.length > 0)
-    console.error(
-      "Errors during request: ",
-      context.errors.map(
-        (err) => oneLine(`R${err?.request?.roundIndex + 1}; 
-            A${err?.request?.attemptIndex + 1}; 
-            ${err.code}; 
-            ${err?.request?.url};`)
-      )
-    );
-  if (hasTransportErrorCode(result.error, ["ExternalAbort"]))
-    throw result?.error?.cause;
-  if (result.error) {
-    result.error.errors = context.errors;
-    throw result.error;
-  }
-  return result.result;
+  if (requestResult.ok) return requestResult;
+  if (isNatErrorOf(requestResult.error, [
+    "Client.Transport.SendRequest.PreferredRpc.NotFound",
+    "Client.Transport.SendRequest.Request.FetchFailed",
+    "Client.Transport.SendRequest.Request.Attempt.Timeout",
+    "Client.Transport.SendRequest.Request.Timeout",
+    "Client.Transport.SendRequest.Request.Aborted",
+    "Client.Transport.SendRequest.Response.JsonParseFailed",
+    "Client.Transport.SendRequest.Response.InvalidSchema"
+  ]))
+    return result.err(requestResult.error);
+  return result.ok(requestResult.error.context.rawRpcResponse);
 };
 
 // src/client/transport/createTransport.ts
-var getRpcs = (list = [], type) => list.map((rpc) => ({
+var z30 = __toESM(require("zod/mini"), 1);
+
+// src/client/transport/rpcEndpoints.ts
+var z29 = __toESM(require("zod/mini"), 1);
+var RpcEndpointSchema = z29.object({
+  url: z29.url(),
+  headers: z29.optional(z29.record(z29.string(), z29.string()))
+});
+var RpcEndpointsArgsSchema = z29.union([
+  z29.object({
+    regular: z29.array(RpcEndpointSchema).check(z29.minLength(1)),
+    archival: z29.undefined()
+  }),
+  z29.object({
+    regular: z29.undefined(),
+    archival: z29.array(RpcEndpointSchema).check(z29.minLength(1))
+  }),
+  z29.object({
+    regular: z29.array(RpcEndpointSchema).check(z29.minLength(1)),
+    archival: z29.array(RpcEndpointSchema).check(z29.minLength(1))
+  })
+]);
+var getInnerRpcEndpoints = (list = [], type) => list.map((rpc) => ({
   type,
   url: rpc.url,
   headers: {
     ...rpc.headers,
     "Content-Type": "application/json"
-  },
-  inactiveUntil: null
+  }
 }));
-var validateRpcEndpoints = (rpcEndpoints, rpcTypePreferences) => {
-  const preferredType = rpcTypePreferences[0] === "Regular" ? "regular" : "archival";
-  const preferredList = rpcEndpoints[preferredType] ?? [];
-  if (rpcTypePreferences.length === 1 && preferredList.length === 0)
-    throw new TransportError({
-      code: "InvalidTransportConfiguration",
-      message: `Invalid transport configuration: no "${rpcTypePreferences[0]}" RPC endpoints found while it's the only preferred type.`
-    });
-};
+
+// src/client/transport/createTransport.ts
+var CreateTransportArgsSchema = z30.object({
+  rpcEndpoints: RpcEndpointsArgsSchema,
+  policy: PartialTransportPolicySchema
+});
 var createTransport = (args) => {
   const transportPolicy = mergeTransportPolicy(
     defaultTransportPolicy,
     args.policy
   );
-  validateRpcEndpoints(args.rpcEndpoints, transportPolicy.rpcTypePreferences);
   const context = {
     rpcEndpoints: {
-      regular: getRpcs(args.rpcEndpoints.regular, "regular"),
-      archival: getRpcs(args.rpcEndpoints.archival, "archival")
+      regular: getInnerRpcEndpoints(args.rpcEndpoints.regular, "regular"),
+      archival: getInnerRpcEndpoints(args.rpcEndpoints.archival, "archival")
     },
     transportPolicy
   };
@@ -1698,232 +2677,552 @@ var createTransport = (args) => {
   };
 };
 
-// src/client/createClient.ts
-var createClient = async (args) => {
-  const transport = createTransport(args.transport);
-  const context = {
-    sendRequest: transport.sendRequest
-  };
-  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/methods/contract/callContractReadFunction/callContractReadFunction.ts
+var import_base4 = require("@scure/base");
+var z32 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/contract/callContractReadFunction/handleError.ts
+var import_jsonrpc_types12 = require("@near-js/jsonrpc-types");
+var handleError6 = (rpcResponse) => {
+  const rpcError = (0, import_jsonrpc_types12.ErrorWrapperFor_RpcQueryErrorSchema)().safeParse(
+    rpcResponse.error
+  );
+  if (!rpcError.success)
+    return result.err(
+      createNatError({
+        kind: "Client.CallContractReadFunction.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Error.InvalidSchema",
+            context: { zodError: rpcError.error }
+          })
+        }
+      })
+    );
+  const { name, cause } = rpcError.data;
+  if (name === "HANDLER_ERROR") {
+    if (cause.name === "NO_SYNCED_BLOCKS")
+      return result.err(
+        createNatError({
+          kind: `Client.CallContractReadFunction.Rpc.NotSynced`,
+          context: null
+        })
+      );
+    if (cause.name === "UNAVAILABLE_SHARD")
+      return result.err(
+        createNatError({
+          kind: `Client.CallContractReadFunction.Rpc.Shard.NotTracked`,
+          context: { shardId: cause.info.requestedShardId }
+        })
+      );
+    if (cause.name === "GARBAGE_COLLECTED_BLOCK")
+      return result.err(
+        createNatError({
+          kind: `Client.CallContractReadFunction.Rpc.Block.GarbageCollected`,
+          context: {
+            blockHash: cause.info.blockHash,
+            blockHeight: cause.info.blockHeight
+          }
+        })
+      );
+    if (cause.name === "UNKNOWN_BLOCK" && "blockId" in cause.info.blockReference)
+      return result.err(
+        createNatError({
+          kind: `Client.CallContractReadFunction.Rpc.Block.NotFound`,
+          context: {
+            blockId: cause.info.blockReference.blockId
+          }
+        })
+      );
+  }
+  return result.err(
+    createNatError({
+      kind: "Client.CallContractReadFunction.Internal",
+      context: {
+        cause: createNatError({
+          kind: "Client.CallContractReadFunction.Rpc.Unclassified",
+          context: { rpcResponse }
+        })
+      }
+    })
+  );
+};
+
+// src/client/methods/contract/callContractReadFunction/handleResult/handleResult.ts
+var z31 = __toESM(require("zod/mini"), 1);
+
+// src/client/methods/contract/callContractReadFunction/handleResult/deserializeCallResult.ts
+var deserializeCallResult = (args, rawResult) => {
+  if (args.options?.deserializeResult) {
+    const deserializeResult = args.options.deserializeResult;
+    return wrapInternalError(
+      "Client.CallContractReadFunction.DeserializeResult.Internal",
+      () => result.ok(deserializeResult({ rawResult }))
+    )();
+  }
+  try {
+    const res = fromJsonBytes(rawResult);
+    return result.ok(res);
+  } catch (e) {
+    return result.ok(void 0);
+  }
+};
+
+// src/client/methods/contract/callContractReadFunction/handleResult/handleResult.ts
+var ContractExecutionErrorSchema = z31.object({
+  blockHash: z31.string(),
+  blockHeight: z31.number(),
+  error: z31.string(),
+  logs: z31.array(z31.string())
+  // will always an empty array
+});
+var RpcQueryCallReadFunctionOkResultSchema = z31.object({
+  blockHash: z31.string(),
+  blockHeight: z31.number(),
+  result: z31.array(z31.number()),
+  logs: z31.array(z31.string())
+});
+var RpcQueryCallReadFunctionResultSchema = z31.union([
+  RpcQueryCallReadFunctionOkResultSchema,
+  ContractExecutionErrorSchema
+]);
+var handleResult6 = (rpcResponse, args) => {
+  const rpcResult = RpcQueryCallReadFunctionResultSchema.safeParse(
+    rpcResponse.result
+  );
+  if (!rpcResult.success)
+    return result.err(
+      createNatError({
+        kind: "Client.CallContractReadFunction.SendRequest.Failed",
+        context: {
+          cause: createNatError({
+            kind: "Client.Transport.SendRequest.Response.Result.InvalidSchema",
+            context: { zodError: rpcResult.error }
+          })
+        }
+      })
+    );
+  const { blockHash, blockHeight, logs } = rpcResult.data;
+  if ("error" in rpcResult.data)
+    return result.err(
+      createNatError({
+        kind: "Client.CallContractReadFunction.Rpc.Execution.Failed",
+        context: {
+          contractAccountId: args.contractAccountId,
+          message: rpcResult.data.error,
+          blockHash,
+          blockHeight
+        }
+      })
+    );
+  const deserializedResult = deserializeCallResult(args, rpcResult.data.result);
+  if (!deserializedResult.ok) return deserializedResult;
+  const output = {
+    blockHash,
+    blockHeight,
+    logs,
+    result: deserializedResult.value,
+    rawResult: rpcResult.data.result
   };
+  return result.ok(output);
+};
+
+// src/client/methods/contract/callContractReadFunction/serializeFunctionArgs.ts
+var serializeFunctionArgs = (args) => {
+  if (args.options?.serializeArgs) {
+    const serializeArgs = args.options.serializeArgs;
+    return wrapInternalError(
+      "Client.CallContractReadFunction.SerializeArgs.Internal",
+      () => {
+        const output = serializeArgs({
+          functionArgs: args.functionArgs
+        });
+        if (!(output instanceof Uint8Array))
+          return result.err(
+            createNatError({
+              kind: "Client.CallContractReadFunction.SerializeArgs.InvalidOutput",
+              context: { output }
+            })
+          );
+        return result.ok(output);
+      }
+    )();
+  }
+  if (args.functionArgs) {
+    const jsonArgs = JsonSchema.safeParse(args.functionArgs);
+    if (!jsonArgs.success)
+      return result.err(
+        createNatError({
+          kind: "Client.CallContractReadFunction.Args.InvalidSchema",
+          context: { zodError: jsonArgs.error }
+        })
+      );
+    return result.ok(toJsonBytes(args.functionArgs));
+  }
+  return result.ok(new Uint8Array());
 };
 
+// src/client/methods/contract/callContractReadFunction/callContractReadFunction.ts
+var GetAccountAccessKeyArgsSchema2 = z32.object({
+  contractAccountId: AccountIdSchema,
+  functionName: ContractFunctionNameSchema,
+  functionArgs: z32.optional(z32.unknown()),
+  withStateAt: z32.optional(BlockReferenceSchema),
+  policies: PoliciesSchema,
+  options: z32.optional(
+    z32.object({
+      serializeArgs: z32.optional(z32.instanceof(Function)),
+      deserializeResult: z32.optional(z32.instanceof(Function)),
+      signal: z32.optional(z32.instanceof(AbortSignal))
+    })
+  )
+});
+var createSafeCallContractReadFunction = (context) => wrapInternalError(
+  "Client.CallContractReadFunction.Internal",
+  async (args) => {
+    const validArgs = GetAccountAccessKeyArgsSchema2.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "Client.CallContractReadFunction.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const functionArgs = serializeFunctionArgs(args);
+    if (!functionArgs.ok) return functionArgs;
+    const rpcResponse = await context.sendRequest({
+      method: "query",
+      params: {
+        request_type: "call_function",
+        account_id: args.contractAccountId,
+        method_name: args.functionName,
+        args_base64: import_base4.base64.encode(functionArgs.value),
+        ...toNativeBlockReference(args.withStateAt)
+      },
+      transportPolicy: args.policies?.transport,
+      signal: args.options?.signal
+    });
+    if (!rpcResponse.ok)
+      return result.err(
+        createNatError({
+          kind: "Client.CallContractReadFunction.SendRequest.Failed",
+          context: { cause: rpcResponse.error }
+        })
+      );
+    return rpcResponse.value.error ? handleError6(rpcResponse.value) : handleResult6(rpcResponse.value, args);
+  }
+);
+
+// src/client/createClient.ts
+var ClientBrand = Symbol("Client");
+var isClient = (value) => typeof value === "object" && value !== null && ClientBrand in value;
+var CreateClientArgsSchema = z33.object({
+  transport: CreateTransportArgsSchema
+});
+var safeCreateClient = wrapInternalError(
+  "CreateClient.Internal",
+  async (args) => {
+    const validArgs = CreateClientArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateClient.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const transport = createTransport(args.transport);
+    const context = {
+      sendRequest: transport.sendRequest
+    };
+    const safeGetAccountInfo = createSafeGetAccountInfo(context);
+    const safeGetAccountAccessKey = createSafeGetAccountAccessKey(context);
+    const safeGetAccountAccessKeys = createSafeGetAccountAccessKeys(context);
+    const safeCallContractReadFunction = createSafeCallContractReadFunction(context);
+    const safeGetBlock = createSafeGetBlock(context);
+    const safeSendSignedTransaction = createSafeSendSignedTransaction(context);
+    return result.ok({
+      [ClientBrand]: true,
+      // TODO hide from console.log
+      getAccountInfo: asThrowable(safeGetAccountInfo),
+      getAccountAccessKey: asThrowable(safeGetAccountAccessKey),
+      getAccountAccessKeys: asThrowable(safeGetAccountAccessKeys),
+      callContractReadFunction: asThrowable(
+        safeCallContractReadFunction
+      ),
+      // TODO Fix: asThrowable doesn't work fine with overloads
+      getBlock: asThrowable(safeGetBlock),
+      sendSignedTransaction: asThrowable(safeSendSignedTransaction),
+      safeGetAccountInfo,
+      safeGetAccountAccessKey,
+      safeGetAccountAccessKeys,
+      safeCallContractReadFunction,
+      safeGetBlock,
+      safeSendSignedTransaction
+    });
+  }
+);
+var throwableCreateClient = asThrowable(safeCreateClient);
+
 // src/client/presets/testnet.ts
-var createTestnetClient = () => createClient({
+var createTestnetClient = () => throwableCreateClient({
   transport: {
     rpcEndpoints: {
       regular: [
-        { url: "https://rpc.testnet.near.org" },
-        { url: "https://test.rpc.fastnear.com" }
+        { url: "https://test.rpc.fastnear.com" },
+        { url: "https://rpc.testnet.near.org" }
       ],
-      archival: []
+      archival: [{ url: "https://neart.lava.build:443" }]
     }
   }
 });
 
 // src/client/presets/mainnet.ts
-var createMainnetClient = () => createClient({
+var createMainnetClient = () => throwableCreateClient({
   transport: {
     rpcEndpoints: {
       regular: [
         { url: "https://free.rpc.fastnear.com" },
+        { url: "https://rpc.intea.rs" },
         { url: "https://near.blockpi.network/v1/rpc/public" }
       ],
-      archival: []
+      archival: [{ url: "https://near.lava.build:443" }]
     }
   }
 });
 
-// src/helpers/crypto/getTransactionHash.ts
-var import_sha2 = require("@noble/hashes/sha2");
-var import_base8 = require("@scure/base");
+// src/keyServices/memoryKeyService/createMemoryKeyService.ts
+var z37 = __toESM(require("zod/mini"), 1);
 
-// src/_common/transformers/toBorshBytes/transaction.ts
-var import_borsh3 = require("borsh");
-var serializeNativeTransaction = (nativeTransaction) => (0, import_borsh3.serialize)(transactionBorshSchema, nativeTransaction);
-var serializeTransaction = (transaction) => serializeNativeTransaction(toNativeTransaction(transaction));
+// src/keyServices/memoryKeyService/createSignTransaction.ts
+var z34 = __toESM(require("zod/mini"), 1);
 
-// src/helpers/crypto/getTransactionHash.ts
+// src/_common/utils/getTransactionHash.ts
+var import_sha2 = require("@noble/hashes/sha2");
+var import_base5 = require("@scure/base");
 var getTransactionHash = (transaction) => {
-  const transactionBorshBytes = serializeTransaction(transaction);
+  const transactionBorshBytes = toBorshTransaction(transaction);
   const u8TransactionHash = (0, import_sha2.sha256)(transactionBorshBytes);
   return {
-    transactionHash: import_base8.base58.encode(u8TransactionHash),
+    transactionHash: import_base5.base58.encode(u8TransactionHash),
     u8TransactionHash
   };
 };
 
-// src/helpers/crypto/sign.ts
-var v2 = __toESM(require("valibot"), 1);
+// src/keyServices/memoryKeyService/createSignTransaction.ts
+var SignTransactionArgsSchema = z34.object({
+  transaction: TransactionSchema
+});
+var createSafeSignTransaction = (context) => wrapInternalError(
+  "MemoryKeyService.SignTransaction.Internal",
+  async (args) => {
+    const validArgs = SignTransactionArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "MemoryKeyService.SignTransaction.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const { transaction: innerTransaction } = validArgs.data;
+    const keyPair = context.safeFindKeyPair({
+      publicKey: innerTransaction.signerPublicKey.publicKey
+    });
+    if (!keyPair.ok) {
+      if (keyPair.error.kind === "MemoryKeyService.FindKeyPair.NotFound")
+        return result.err(
+          createNatError({
+            kind: "MemoryKeyService.SignTransaction.SigningKeyPair.NotFound",
+            context: {
+              signerPublicKey: innerTransaction.signerPublicKey.publicKey
+            }
+          })
+        );
+      throw keyPair.error;
+    }
+    const { transactionHash, u8TransactionHash } = getTransactionHash(innerTransaction);
+    const { signature } = keyPair.value.sign(u8TransactionHash);
+    return result.ok({
+      transaction: args.transaction,
+      transactionHash,
+      signature
+    });
+  }
+);
+
+// src/helpers/keyPair/_common/signByEd25519Key.ts
 var import_ed25519 = require("@noble/curves/ed25519");
-var import_secp256k1 = require("@noble/curves/secp256k1");
 
-// src/_common/schemas/valibot/privateKey.ts
-var v = __toESM(require("valibot"), 1);
-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/_common/transformers/toCurveString.ts
+var import_base6 = require("@scure/base");
+var toEd25519CurveString = (u8Data) => `ed25519:${import_base6.base58.encode(u8Data)}`;
+var toSecp256k1CurveString = (u8Data) => `secp256k1:${import_base6.base58.encode(u8Data)}`;
 
-// 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);
+// src/helpers/keyPair/_common/signByEd25519Key.ts
+var signByEd25519Key = (u8PrivateKey, message) => {
+  const u8SecretKey = u8PrivateKey.slice(0, BinaryLengths.Ed25519.SecretKey);
   const u8Signature = import_ed25519.ed25519.sign(message, u8SecretKey);
-  return {
+  return result.ok({
     signature: toEd25519CurveString(u8Signature),
+    curve: "ed25519",
     u8Signature
-  };
+  });
 };
-var getBinarySecp256k1SecretKey = (u8PrivateKey) => v2.parse(BinarySecp256k1PrivateKeySchema, u8PrivateKey).slice(0, Secp256k12.SecretKey);
-var signBySecp256k1Key = (message, u8PrivateKey) => {
-  const u8SecretKey = getBinarySecp256k1SecretKey(u8PrivateKey);
+
+// src/helpers/keyPair/_common/signBySecp256k1Key.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var signBySecp256k1Key = (u8PrivateKey, message) => {
+  const u8SecretKey = u8PrivateKey.slice(0, BinaryLengths.Secp256k1.SecretKey);
   const signatureObj = import_secp256k1.secp256k1.sign(message, u8SecretKey);
   const u8Signature = new Uint8Array([
     ...signatureObj.toBytes(),
     signatureObj.recovery
   ]);
-  return {
+  return result.ok({
     signature: toSecp256k1CurveString(u8Signature),
+    curve: "secp256k1",
     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
-var v3 = __toESM(require("valibot"), 1);
-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/_common/schemas/zod/common/privateKey.ts
+var z35 = __toESM(require("zod/mini"), 1);
+var { Ed25519: Ed255193, Secp256k1: Secp256k13 } = BinaryLengths;
+var PrivateKeySchema = z35.pipe(
+  CurveStringSchema,
+  z35.transform((val) => ({
+    privateKey: val.curveString,
+    u8PrivateKey: val.u8Data,
+    curve: val.curve
+  }))
+).check(
+  z35.refine(
+    ({ curve, u8PrivateKey }) => curve === "ed25519" ? u8PrivateKey.length === Ed255193.PrivateKey : u8PrivateKey.length === Secp256k13.PrivateKey,
+    { error: "Invalid private key length" }
+  )
+);
 
-// 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"
-    };
+// src/helpers/keyPair/keyPair.ts
+var { Ed25519: Ed255194, Secp256k1: Secp256k14 } = BinaryLengths;
+var getPublicKey = ({ curve, u8PrivateKey }) => curve === "ed25519" ? toEd25519CurveString(u8PrivateKey.slice(Ed255194.SecretKey)) : toSecp256k1CurveString(u8PrivateKey.slice(Secp256k14.SecretKey));
+var createSafeSign = ({ curve, u8PrivateKey }) => wrapInternalError(
+  "KeyPair.Sign.Internal",
+  (message) => curve === "ed25519" ? signByEd25519Key(u8PrivateKey, message) : signBySecp256k1Key(u8PrivateKey, message)
+);
+var safeKeyPair = wrapInternalError(
+  "CreateKeyPair.Internal",
+  (privateKey) => {
+    const validPrivateKey = PrivateKeySchema.safeParse(privateKey);
+    if (!validPrivateKey.success)
+      return result.err(
+        createNatError({
+          kind: "CreateKeyPair.Args.InvalidSchema",
+          context: { zodError: validPrivateKey.error }
+        })
+      );
+    const safeSign = createSafeSign(validPrivateKey.data);
+    return result.ok({
+      publicKey: getPublicKey(validPrivateKey.data),
+      // TODO use Lazy getter, like NearToken
+      privateKey,
+      sign: asThrowable(safeSign),
+      safeSign
+    });
   }
-  throw new Error("Unknown keySource");
-};
-var parseKeySources = (params) => {
-  if (params.keySource) {
-    const { publicKey, privateKey } = parseKeySource(params.keySource);
-    return { [publicKey]: privateKey };
+);
+var throwableKeyPair = asThrowable(safeKeyPair);
+
+// src/keyServices/memoryKeyService/getKeyPairs.ts
+var getKeyPairs = (args) => {
+  if ("keySource" in args) {
+    const keyPair = throwableKeyPair(args.keySource.privateKey.privateKey);
+    return { [keyPair.publicKey]: keyPair };
   }
-  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"
+  return Object.fromEntries(
+    args.keySources.map((keySource) => {
+      const keyPair = throwableKeyPair(keySource.privateKey.privateKey);
+      return [keyPair.publicKey, keyPair];
+    })
   );
 };
 
-// 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/createFindKeyPair.ts
+var z36 = __toESM(require("zod/mini"), 1);
+var FindKeyPairArgsSchema = z36.object({
+  publicKey: PublicKeySchema
+});
+var createSafeFindKeyPair = (context) => wrapInternalError("MemoryKeyService.FindKeyPair.Internal", (args) => {
+  const validArgs = FindKeyPairArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "MemoryKeyService.FindKeyPair.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const { publicKey } = validArgs.data.publicKey;
+  const keyPair = context.keyPairs[publicKey];
+  return context.keyPairs[publicKey] ? result.ok(keyPair) : result.err(
+    createNatError({
+      kind: "MemoryKeyService.FindKeyPair.NotFound",
+      context: { publicKey }
+    })
   );
-};
+});
 
 // src/keyServices/memoryKeyService/createMemoryKeyService.ts
-var createMemoryKeyService = async (params) => {
+var MemoryKeyServiceBrand = Symbol("MemoryKeyService");
+var isMemoryKeyService = (value) => typeof value === "object" && value !== null && MemoryKeyServiceBrand in value;
+var KeySourceSchema = z37.object({
+  privateKey: PrivateKeySchema
+});
+var CreateMemoryKeyServiceArgsSchema = z37.union([
+  z37.object({
+    keySource: KeySourceSchema
+  }),
+  z37.object({
+    keySources: z37.array(KeySourceSchema).check(z37.minLength(1))
+  })
+]);
+var safeCreateMemoryKeyService = wrapInternalError("CreateMemoryKeyService.Internal", async (args) => {
+  const validArgs = CreateMemoryKeyServiceArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "CreateMemoryKeyService.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
   const context = {
-    keyPairs: parseKeySources(params)
-  };
-  context.findPrivateKey = createFindPrivateKey(context.keyPairs);
-  return {
-    signTransaction: createSignTransaction(context),
-    getKeyPairs: () => context.keyPairs
+    keyPairs: getKeyPairs(validArgs.data)
   };
-};
+  const safeFindKeyPair = createSafeFindKeyPair(context);
+  const safeSignTransaction = createSafeSignTransaction(context);
+  context.safeFindKeyPair = safeFindKeyPair;
+  return result.ok({
+    [MemoryKeyServiceBrand]: true,
+    signTransaction: asThrowable(safeSignTransaction),
+    safeSignTransaction,
+    findKeyPair: asThrowable(safeFindKeyPair),
+    safeFindKeyPair
+  });
+});
+var throwableCreateMemoryKeyService = asThrowable(safeCreateMemoryKeyService);
+
+// src/signers/memorySigner/createMemorySigner.ts
+var z40 = __toESM(require("zod/mini"), 1);
 
 // src/signers/memorySigner/keyPool/createFindKeyForTask.ts
 var findSigningKey = (keyPriority, keyList) => {
-  if (keyPriority.type === "FullAccess") {
+  if (keyPriority.accessType === "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;
+    return !key.isLocked && isContractIdMatch && isFnCallAllowed;
   });
 };
 var createFindKeyForTask = (keyList) => (task) => {
-  for (const keyPriority of task.signingKeyPriority) {
+  for (const keyPriority of task.accessTypePriority) {
     const key = findSigningKey(keyPriority, keyList);
     if (key) return key;
   }
@@ -1931,38 +3230,34 @@ var createFindKeyForTask = (keyList) => (task) => {
 
 // src/signers/memorySigner/keyPool/createIsKeyForTaskExist.ts
 var isKeyExist = (keyPriority, keyList) => {
-  if (keyPriority.type === "FullAccess") return keyList.fullAccess.length > 0;
+  if (keyPriority.accessType === "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(
+var createIsKeyForTaskExist = (keyList) => (task) => task.accessTypePriority.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 createSetNonce = (key) => (newNonce) => {
   key.nonce = newNonce;
-  console.log(`Set new nonce '${newNonce}' for the key '${key.publicKey}'`);
 };
 
 // src/signers/memorySigner/keyPool/getFullAccessKeyList.ts
-var transformKey2 = (fullAccessKey, keyPairs) => {
+var transformKey = (fullAccessKey) => {
   const { publicKey, nonce } = fullAccessKey;
   const key = {
-    type: "FullAccess",
+    accessType: "FullAccess",
     publicKey,
-    privateKey: keyPairs[publicKey],
     isLocked: false,
     nonce
   };
@@ -1971,21 +3266,16 @@ var transformKey2 = (fullAccessKey, keyPairs) => {
   key.setNonce = createSetNonce(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));
-};
+var getFullAccessKeyList = (accountKeys, signerContext) => accountKeys.filter(
+  ({ publicKey, accessType }) => signerContext.keyService.safeFindKeyPair({ publicKey }).ok && accessType === "FullAccess"
+).map((key) => transformKey(key));
 
 // src/signers/memorySigner/keyPool/getFunctionCallKeyList.ts
-var transformKey3 = (functionCallKey, keyPairs) => {
+var transformKey2 = (functionCallKey) => {
   const { publicKey, nonce, contractAccountId, allowedFunctions } = functionCallKey;
   const key = {
-    type: "FunctionCall",
-    // TODO Rename to accessType
+    accessType: "FunctionCall",
     publicKey,
-    privateKey: keyPairs[publicKey],
     isLocked: false,
     nonce,
     contractAccountId,
@@ -1996,12 +3286,9 @@ var transformKey3 = (functionCallKey, keyPairs) => {
   key.setNonce = createSetNonce(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));
-};
+var getFunctionCallKeyList = (accountKeys, signerContext) => accountKeys.filter(
+  ({ publicKey, accessType }) => signerContext.keyService.safeFindKeyPair({ publicKey }).ok && accessType === "FunctionCall"
+).map((key) => transformKey2(key));
 
 // src/signers/memorySigner/keyPool/createKeyPool.ts
 var getAllowedSigningKeys = (signerContext, accountKeys) => {
@@ -2010,46 +3297,71 @@ var getAllowedSigningKeys = (signerContext, accountKeys) => {
   return accountKeys.filter((key) => set.has(key.publicKey));
 };
 var createKeyPool = async (signerContext) => {
-  const { accountKeys } = await signerContext.client.getAccountKeys({
-    accountId: signerContext.signerAccountId
+  const accountKeys = await signerContext.client.safeGetAccountAccessKeys({
+    accountId: signerContext.signerAccountId,
+    atMomentOf: "LatestFinalBlock"
   });
-  const filteredKeys = getAllowedSigningKeys(signerContext, accountKeys);
-  const keyList = {
+  if (!accountKeys.ok)
+    return result.err(
+      createNatError({
+        kind: "CreateMemorySigner.CreateKeyPool.Failed",
+        context: { cause: accountKeys.error }
+      })
+    );
+  const { accountAccessKeys } = accountKeys.value;
+  if (accountAccessKeys.length === 0)
+    return result.err(
+      createNatError({
+        kind: "CreateMemorySigner.Signer.AccessKeys.NotFound",
+        context: {
+          signerAccountId: signerContext.signerAccountId
+        }
+      })
+    );
+  const filteredKeys = getAllowedSigningKeys(signerContext, accountAccessKeys);
+  if (filteredKeys.length === 0)
+    return result.err(
+      createNatError({
+        kind: "CreateMemorySigner.KeyPool.Empty",
+        context: null
+      })
+    );
+  const context = {
     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)
-  };
+  return result.ok({
+    findKeyForTask: createFindKeyForTask(context),
+    isKeyForTaskExist: createIsKeyForTaskExist(context)
+  });
 };
 
 // src/signers/memorySigner/taskQueue/createFindTaskForKey.ts
 var checkIfKeyMatchRequirements = (keyPriority, key) => {
-  if (key.type !== keyPriority.type) return false;
-  if (key.type === "FullAccess") return true;
+  if (key.accessType !== keyPriority.accessType) return false;
+  if (key.accessType === "FullAccess") return true;
   const isContractIdMatch = key.contractAccountId === keyPriority.contractAccountId;
-  const isFnCallAllowed = key.allowedFunctions === void 0 || key.allowedFunctions.includes(keyPriority.calledFnName);
+  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(
+  (task) => task.accessTypePriority.some(
     (keyPriority) => checkIfKeyMatchRequirements(keyPriority, key)
   )
 );
 
-// src/signers/memorySigner/taskQueue/addTask/helpers/getSigningKeyPriority.ts
+// src/signers/memorySigner/taskQueue/addTask/helpers/getAccessTypePriority.ts
 var getPriorityForFunctionCallTransaction = (action, receiverAccountId) => [
-  { type: "FullAccess" },
+  { accessType: "FullAccess" },
   {
-    type: "FunctionCall",
+    accessType: "FunctionCall",
     contractAccountId: receiverAccountId,
-    calledFnName: action.params.functionName
+    calledFnName: action.functionName
   }
 ];
-var getSigningKeyPriority = ({
+var getAccessTypePriority = ({
   action,
   actions,
   receiverAccountId
@@ -2058,94 +3370,39 @@ var getSigningKeyPriority = ({
     return getPriorityForFunctionCallTransaction(action, receiverAccountId);
   if (actions?.length === 1 && actions[0].actionType === "FunctionCall")
     return getPriorityForFunctionCallTransaction(actions[0], receiverAccountId);
-  return [{ type: "FullAccess" }];
+  return [{ accessType: "FullAccess" }];
 };
 
-// src/signers/memorySigner/taskQueue/addTask/signTransaction.ts
-var createSignTransaction2 = (context) => async (transactionIntent) => {
+// src/signers/memorySigner/taskQueue/addTask/createAddSignTransactionTask.ts
+var createAddSignTransactionTask = (context) => async (transactionIntent) => {
   const { matcher, resolver } = context.signerContext;
   const task = {
-    type: "SignTransaction",
+    taskType: "SignTransaction",
     taskId: crypto.randomUUID(),
-    signingKeyPriority: getSigningKeyPriority(transactionIntent),
+    accessTypePriority: getAccessTypePriority(transactionIntent),
     transactionIntent
   };
-  matcher.canHandleTaskInFuture(task);
+  const canHandle = matcher.canHandleTaskInFuture(task);
+  if (!canHandle.ok) return canHandle;
   context.addTask(task);
-  queueMicrotask(() => {
-    matcher.handleAddTask(task);
-  });
-  return resolver.waitForTask(task.taskId);
+  queueMicrotask(() => matcher.handleAddTask(task));
+  return await resolver.waitForTask(task.taskId);
 };
 
-// src/signers/memorySigner/taskQueue/addTask/executeTransaction.ts
-var createExecuteTransaction = (context) => async (args) => {
+// src/signers/memorySigner/taskQueue/addTask/createAddExecuteTransactionTask.ts
+var createAddExecuteTransactionTask = (context) => async (transactionIntent) => {
   const { matcher, resolver } = context.signerContext;
-  const transactionIntent = {
-    receiverAccountId: args.receiverAccountId,
-    action: args.action,
-    actions: args.actions
-  };
   const task = {
-    type: "ExecuteTransaction",
+    taskType: "ExecuteTransaction",
     taskId: crypto.randomUUID(),
-    signingKeyPriority: getSigningKeyPriority(transactionIntent),
+    accessTypePriority: getAccessTypePriority(transactionIntent),
     transactionIntent
   };
-  matcher.canHandleTaskInFuture(task);
+  const canHandle = matcher.canHandleTaskInFuture(task);
+  if (!canHandle.ok) return canHandle;
   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;
+  queueMicrotask(() => matcher.handleAddTask(task));
+  return await resolver.waitForTask(task.taskId);
 };
 
 // src/signers/memorySigner/taskQueue/createTaskQueue.ts
@@ -2153,7 +3410,11 @@ var createTaskQueue = (signerContext) => {
   const context = {
     queue: [],
     cleaners: {},
-    signerContext
+    signerContext,
+    addTask: (_) => {
+    },
+    removeTask: (_) => {
+    }
   };
   context.addTask = (task) => {
     context.queue.push(task);
@@ -2162,10 +3423,18 @@ var createTaskQueue = (signerContext) => {
         ({ 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);
+      context.signerContext.resolver.completeTask(
+        task.taskId,
+        result.err(
+          createNatError({
+            kind: "MemorySigner.TaskQueue.Task.MaxTimeInQueueReached",
+            context: {
+              maxWaitInQueueMs: context.signerContext.maxWaitInQueueMs
+            }
+          })
+        )
+      );
+    }, context.signerContext.maxWaitInQueueMs);
   };
   const removeTask = (taskId) => {
     context.queue = context.queue.filter((task) => task.taskId !== taskId);
@@ -2173,113 +3442,82 @@ var createTaskQueue = (signerContext) => {
     delete context.cleaners[taskId];
   };
   return {
-    signTransaction: createSignTransaction2(context),
-    signMultipleTransactions: createSignMultipleTransactions(context),
-    executeTransaction: createExecuteTransaction(context),
-    executeeMultipleTransactions: createExecuteMultipleTransactions(context),
+    addSignTransactionTask: createAddSignTransactionTask(context),
+    addExecuteTransactionTask: createAddExecuteTransactionTask(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.setNonce(nextNonce);
-    signerContext.resolver.completeTask(task.taskId, {
-      result: signedTransaction
-    });
-  } catch (e) {
-    signerContext.resolver.completeTask(task.taskId, { error: e });
-  }
+  const execute2 = wrapInternalError(
+    "MemorySigner.SignTransaction.Internal",
+    async () => {
+      const nextNonce = key.nonce + 1;
+      const transaction = {
+        ...task.transactionIntent,
+        signerAccountId: signerContext.signerAccountId,
+        signerPublicKey: key.publicKey,
+        nonce: nextNonce,
+        blockHash: signerContext.state.getBlockHash()
+      };
+      const signedTransaction = await signerContext.keyService.signTransaction({
+        transaction
+      });
+      key.setNonce(nextNonce);
+      return result.ok(signedTransaction);
+    }
+  );
+  const transactionResult = await execute2();
+  signerContext.resolver.completeTask(task.taskId, transactionResult);
 };
 
 // src/signers/memorySigner/executors/executeTransaction.ts
-var z11 = __toESM(require("zod/mini"), 1);
-var NonceErrorSchema = z11.object({
-  __rawRpcError: z11.object({
-    data: z11.object({
-      TxExecutionError: z11.object({
-        InvalidTxError: z11.object({
-          InvalidNonce: z11.object({
-            akNonce: z11.number(),
-            txNonce: z11.number()
-          })
-        })
-      })
-    })
-  })
-});
-var maybeNonceError = (e) => {
-  const validated = NonceErrorSchema.safeParse(e);
-  if (hasRpcErrorCode(e, ["HandlerError"]) && validated.success)
-    return {
-      result: {
-        akNonce: validated.data.__rawRpcError.data.TxExecutionError.InvalidTxError.InvalidNonce.akNonce
-      }
-    };
-  return { error: void 0 };
-};
 var executeTransaction = async (signerContext, task, key) => {
   const maxAttempts = 3;
-  const attempt = async (attemptIndex, newNonce) => {
-    try {
-      const signedTransaction = getSignedTransaction(
-        signerContext,
-        task,
-        key,
-        newNonce
-      );
-      const result2 = await signerContext.client.sendSignedTransaction({
+  const attempt = wrapInternalError(
+    "MemorySigner.ExecuteTransaction.Internal",
+    async (attemptIndex, newNonce) => {
+      const transaction = {
+        ...task.transactionIntent,
+        signerAccountId: signerContext.signerAccountId,
+        signerPublicKey: key.publicKey,
+        nonce: newNonce,
+        blockHash: signerContext.state.getBlockHash()
+      };
+      const signedTransaction = await signerContext.keyService.signTransaction({
+        transaction
+      });
+      const txResult = await signerContext.client.safeSendSignedTransaction({
         signedTransaction
       });
-      key.setNonce(newNonce);
-      return { result: result2 };
-    } catch (e) {
-      if (attemptIndex >= maxAttempts - 1) return { error: e };
-      const nonceError = maybeNonceError(e);
-      if (nonceError.result)
-        return await attempt(attemptIndex + 1, nonceError.result.akNonce + 1);
-      return { error: e };
+      if (txResult.ok) {
+        key.setNonce(newNonce);
+        return txResult;
+      }
+      if (attemptIndex <= maxAttempts && txResult.error.kind === "Client.SendSignedTransaction.Rpc.Transaction.Nonce.Invalid") {
+        return await attempt(
+          attemptIndex + 1,
+          txResult.error.context.accessKeyNonce + 1
+        );
+      }
+      return result.err(
+        createNatError({
+          kind: "MemorySigner.Executors.ExecuteTransaction.Client.SendSignedTransaction",
+          context: { cause: txResult.error }
+        })
+      );
     }
-  };
-  const result = await attempt(0, key.nonce + 1);
-  signerContext.resolver.completeTask(task.taskId, result);
+  );
+  const executeTransactionResult = await attempt(1, key.nonce + 1);
+  signerContext.resolver.completeTask(task.taskId, executeTransactionResult);
 };
 
 // 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");
+  if (task.taskType === "SignTransaction") return signTransaction;
+  return executeTransaction;
 };
 var executeTask = async (signerContext, task, key) => {
   key.lock();
@@ -2299,8 +3537,12 @@ var createMatcher = (signerContext) => {
   };
   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 canHandle ? result.ok(true) : result.err(
+      createNatError({
+        kind: "MemorySigner.Matcher.KeyForTaskNotFound",
+        context: { accessTypePriority: task.accessTypePriority }
+      })
+    );
   };
   return {
     handleAddTask,
@@ -2312,14 +3554,14 @@ var createMatcher = (signerContext) => {
 // 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);
+  const waitForTask = (taskId) => new Promise((resolve) => {
+    activeTasks[taskId] = (taskResult) => {
+      resolve(taskResult);
       delete activeTasks[taskId];
     };
   });
-  const completeTask = (taskId, data) => {
-    activeTasks[taskId](data);
+  const completeTask = (taskId, taskResult) => {
+    activeTasks[taskId](taskResult);
   };
   return {
     waitForTask,
@@ -2328,115 +3570,497 @@ var createResolver = () => {
 };
 
 // src/signers/memorySigner/state/createState.ts
-var fetchBlockHash = async (signerContext) => {
-  const block = await signerContext.client.getBlock();
-  return block.header.hash;
+var getBlockHash = async (signerContext) => {
+  const block = await signerContext.client.safeGetBlock();
+  return block.ok ? result.ok(block.value.rawRpcResult.header.hash) : block;
 };
 var createState = async (signerContext) => {
-  const blockHash = await fetchBlockHash(signerContext);
+  const blockHash = await getBlockHash(signerContext);
+  if (!blockHash.ok)
+    return result.err(
+      createNatError({
+        kind: "CreateMemorySigner.CreateState.Failed",
+        context: { cause: blockHash.error }
+      })
+    );
   const state = {
-    blockHash
+    blockHash: blockHash.value
   };
   const refetchBlockHashIntervalId = setInterval(async () => {
-    state.blockHash = await fetchBlockHash(signerContext);
-  }, RefetchBlockHashInterval);
+    const blockHash2 = await getBlockHash(signerContext);
+    if (!blockHash2.ok) return;
+    state.blockHash = blockHash2.value;
+  }, 9e5);
   const clearIntervals = () => {
     clearInterval(refetchBlockHashIntervalId);
   };
-  return {
+  return result.ok({
     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/signers/memorySigner/createSignTransaction.ts
+var z38 = __toESM(require("zod/mini"), 1);
+
+// src/_common/utils/repackError.ts
+var repackError = ({
+  error,
+  originPrefix,
+  targetPrefix
+}) => {
+  const newKind = `${targetPrefix}.${error.kind.slice(originPrefix.length + 1)}`;
+  return result.err(
+    createNatError({
+      kind: newKind,
+      // TODO fix any!
+      context: error.context
+    })
+  );
 };
 
-// src/helpers/actionCreators/transfer.ts
-var transfer = (params) => ({
-  actionType: "Transfer",
-  params
+// src/signers/memorySigner/createSignTransaction.ts
+var SignTransactionArgsSchema2 = z38.object({
+  intent: TransactionIntentSchema
+});
+var createSafeSignTransaction2 = (context) => wrapInternalError("MemorySigner.SignTransaction.Internal", async (args) => {
+  const validArgs = SignTransactionArgsSchema2.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "MemorySigner.SignTransaction.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const signedTransaction = await context.taskQueue.addSignTransactionTask(
+    args.intent
+  );
+  if (signedTransaction.ok) return signedTransaction;
+  if (signedTransaction.error.kind === "MemorySigner.Matcher.KeyForTaskNotFound") {
+    return repackError({
+      error: signedTransaction.error,
+      originPrefix: "MemorySigner.Matcher",
+      targetPrefix: "MemorySigner.SignTransaction"
+    });
+  }
+  if (signedTransaction.error.kind === "MemorySigner.TaskQueue.Task.MaxTimeInQueueReached")
+    return repackError({
+      error: signedTransaction.error,
+      originPrefix: "MemorySigner.TaskQueue.Task",
+      targetPrefix: "MemorySigner.SignTransaction"
+    });
+  return result.err(signedTransaction.error);
 });
 
+// src/signers/memorySigner/createExecuteTransaction.ts
+var z39 = __toESM(require("zod/mini"), 1);
+var SignTransactionArgsSchema3 = z39.object({
+  intent: TransactionIntentSchema
+});
+var createSafeExecuteTransaction = (context) => wrapInternalError(
+  "MemorySigner.ExecuteTransaction.Internal",
+  async (args) => {
+    const validArgs = SignTransactionArgsSchema3.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "MemorySigner.ExecuteTransaction.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const taskResult = await context.taskQueue.addExecuteTransactionTask(
+      args.intent
+    );
+    if (taskResult.ok) return taskResult;
+    if (taskResult.error.kind === "MemorySigner.Matcher.KeyForTaskNotFound")
+      return repackError({
+        error: taskResult.error,
+        originPrefix: "MemorySigner.Matcher",
+        targetPrefix: "MemorySigner.ExecuteTransaction"
+      });
+    if (taskResult.error.kind === "MemorySigner.TaskQueue.Task.MaxTimeInQueueReached")
+      return repackError({
+        error: taskResult.error,
+        originPrefix: "MemorySigner.TaskQueue.Task",
+        targetPrefix: "MemorySigner.ExecuteTransaction"
+      });
+    if (taskResult.error.kind === "MemorySigner.Executors.ExecuteTransaction.Client.SendSignedTransaction") {
+      if (isNatErrorOf(taskResult.error.context.cause, [
+        "Client.SendSignedTransaction.SendRequest.Failed",
+        "Client.SendSignedTransaction.Rpc.Transaction.Timeout",
+        "Client.SendSignedTransaction.Rpc.Transaction.Receiver.NotFound",
+        "Client.SendSignedTransaction.Rpc.Transaction.Signer.Balance.TooLow",
+        "Client.SendSignedTransaction.Rpc.Transaction.Action.CreateAccount.AlreadyExist"
+      ])) {
+        return repackError({
+          error: taskResult.error.context.cause,
+          originPrefix: "Client.SendSignedTransaction",
+          targetPrefix: "MemorySigner.ExecuteTransaction"
+        });
+      }
+      throw taskResult.error.context.cause;
+    }
+    return result.err(taskResult.error);
+  }
+);
+
+// src/signers/memorySigner/createMemorySigner.ts
+var CreateMemorySignerArgsSchema = z40.object({
+  signerAccountId: AccountIdSchema,
+  client: z40.custom((value) => isClient(value)),
+  keyService: z40.custom((value) => isMemoryKeyService(value)),
+  keyPool: z40.optional(
+    z40.object({
+      signingKeys: z40.optional(z40.array(PublicKeySchema).check(z40.minLength(1)))
+    })
+  ),
+  taskQueue: z40.optional(
+    z40.object({
+      maxWaitInQueueMs: z40.optional(z40.number().check(z40.nonnegative()))
+    })
+  )
+});
+var safeCreateMemorySigner = wrapInternalError(
+  "CreateMemorySigner.Internal",
+  async (args) => {
+    const validArgs = CreateMemorySignerArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateMemorySigner.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const { signerAccountId, client, keyService } = validArgs.data;
+    const context = {
+      signerAccountId,
+      client,
+      keyService,
+      signingKeys: args.keyPool?.signingKeys,
+      maxWaitInQueueMs: args.taskQueue?.maxWaitInQueueMs ?? 6e4
+      // 1 min
+    };
+    const [keyPool, state] = await Promise.all([
+      createKeyPool(context),
+      createState(context)
+    ]);
+    if (!keyPool.ok) {
+      if (keyPool.error.kind === "CreateMemorySigner.CreateKeyPool.Failed")
+        return result.err(
+          createNatError({
+            kind: "CreateMemorySigner.Internal",
+            context: { cause: keyPool.error }
+          })
+        );
+      return result.err(keyPool.error);
+    }
+    if (!state.ok)
+      return result.err(
+        createNatError({
+          kind: "CreateMemorySigner.Internal",
+          context: { cause: state.error }
+        })
+      );
+    context.keyPool = keyPool.value;
+    context.state = state.value;
+    context.taskQueue = createTaskQueue(context);
+    context.matcher = createMatcher(context);
+    context.resolver = createResolver();
+    const safeSignTransaction = createSafeSignTransaction2(context);
+    const safeExecuteTransaction = createSafeExecuteTransaction(context);
+    const stop = () => {
+      context.state.clearIntervals();
+    };
+    return result.ok({
+      signerAccountId,
+      signTransaction: asThrowable(safeSignTransaction),
+      executeTransaction: asThrowable(safeExecuteTransaction),
+      safeSignTransaction,
+      safeExecuteTransaction,
+      stop
+    });
+  }
+);
+var throwableCreateMemorySigner = asThrowable(
+  safeCreateMemorySigner
+);
+var createSafeMemorySignerFactory = (args) => (signerAccountId) => safeCreateMemorySigner({ ...args, signerAccountId });
+var createThrowableMemorySignerFactory = (args) => (signerAccountId) => throwableCreateMemorySigner({ ...args, signerAccountId });
+
 // src/helpers/actionCreators/createAccount.ts
 var createAccount = () => ({
   actionType: "CreateAccount"
 });
 
+// src/helpers/actionCreators/transfer.ts
+var z41 = __toESM(require("zod/mini"), 1);
+var CreateTransferActionArgsSchema = z41.object({
+  amount: NearTokenArgsSchema
+});
+var safeTransfer = wrapInternalError(
+  "CreateAction.Transfer.Internal",
+  (args) => {
+    const validArgs = CreateTransferActionArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateAction.Transfer.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    return result.ok({
+      actionType: "Transfer",
+      amount: args.amount
+    });
+  }
+);
+var throwableTransfer = asThrowable(safeTransfer);
+
 // src/helpers/actionCreators/addFullAccessKey.ts
-var addFullAccessKey = ({
-  publicKey
-}) => ({
-  actionType: "AddKey",
-  params: {
+var z42 = __toESM(require("zod/mini"), 1);
+var CreateAddFullAccessKeyActionArgsSchema = z42.object({
+  publicKey: PublicKeySchema
+});
+var safeAddFullAccessKey = wrapInternalError("CreateAction.AddFullAccessKey.Internal", (args) => {
+  const validArgs = CreateAddFullAccessKeyActionArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "CreateAction.AddFullAccessKey.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  return result.ok({
+    actionType: "AddKey",
     accessType: "FullAccess",
-    publicKey
-  }
+    publicKey: args.publicKey
+  });
 });
+var throwableAddFullAccessKey = asThrowable(safeAddFullAccessKey);
 
 // src/helpers/actionCreators/addFunctionCallKey.ts
-var addFunctionCallKey = ({
-  publicKey,
-  contractAccountId,
-  gasBudget,
-  allowedFunctions
-}) => ({
-  actionType: "AddKey",
-  params: {
+var z43 = __toESM(require("zod/mini"), 1);
+var CreateAddFunctionCallKeyActionArgsSchema = z43.object({
+  publicKey: PublicKeySchema,
+  contractAccountId: AccountIdSchema,
+  gasBudget: z43.optional(NearTokenArgsSchema),
+  allowedFunctions: z43.optional(
+    z43.array(ContractFunctionNameSchema).check(z43.minLength(1))
+  )
+});
+var safeAddFunctionCallKey = wrapInternalError("CreateAction.AddFunctionCallKey.Internal", (args) => {
+  const validArgs = CreateAddFunctionCallKeyActionArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "CreateAction.AddFunctionCallKey.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  return result.ok({
+    actionType: "AddKey",
     accessType: "FunctionCall",
-    publicKey,
-    contractAccountId,
-    gasBudget,
-    allowedFunctions
-  }
+    publicKey: args.publicKey,
+    contractAccountId: args.contractAccountId,
+    gasBudget: args.gasBudget,
+    allowedFunctions: args.allowedFunctions
+  });
 });
+var throwableAddFunctionCallKey = asThrowable(safeAddFunctionCallKey);
 
 // src/helpers/actionCreators/functionCall.ts
-var functionCall = (params) => ({
-  actionType: "FunctionCall",
-  params
+var z44 = __toESM(require("zod/mini"), 1);
+var serializeFunctionArgs2 = (args) => {
+  if (args.options?.serializeArgs) {
+    const serializeArgs = args.options.serializeArgs;
+    return wrapInternalError(
+      "CreateAction.FunctionCall.SerializeArgs.Internal",
+      () => {
+        const output = serializeArgs({
+          functionArgs: args.functionArgs
+        });
+        if (!(output instanceof Uint8Array))
+          return result.err(
+            createNatError({
+              kind: "CreateAction.FunctionCall.SerializeArgs.InvalidOutput",
+              context: { output }
+            })
+          );
+        return result.ok(output);
+      }
+    )();
+  }
+  if (args?.functionArgs) {
+    const jsonArgs = JsonSchema.safeParse(args.functionArgs);
+    if (!jsonArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateAction.FunctionCall.Args.InvalidSchema",
+          context: { zodError: jsonArgs.error }
+        })
+      );
+    return result.ok(toJsonBytes(args.functionArgs));
+  }
+  return result.ok(new Uint8Array());
+};
+var CreateFunctionCallActionArgsSchema = z44.object({
+  functionName: ContractFunctionNameSchema,
+  functionArgs: z44.optional(z44.unknown()),
+  gasLimit: NearGasArgsSchema,
+  attachedDeposit: z44.optional(NearTokenArgsSchema),
+  options: z44.optional(
+    z44.object({
+      serializeArgs: z44.optional(z44.instanceof(Function))
+    })
+  )
+});
+var safeFunctionCall = wrapInternalError(
+  "CreateAction.FunctionCall.Internal",
+  (args) => {
+    const validArgs = CreateFunctionCallActionArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateAction.FunctionCall.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    const functionArgs = serializeFunctionArgs2(args);
+    if (!functionArgs.ok) return functionArgs;
+    return result.ok({
+      actionType: "FunctionCall",
+      functionName: args.functionName,
+      gasLimit: args.gasLimit,
+      functionArgs: functionArgs.value,
+      attachedDeposit: args.attachedDeposit
+    });
+  }
+);
+var throwableFunctionCall = asThrowable(
+  safeFunctionCall
+);
+
+// src/helpers/actionCreators/deployContract.ts
+var z45 = __toESM(require("zod/mini"), 1);
+var import_base7 = require("@scure/base");
+var CreateDeployContractActionArgsSchema = z45.union([
+  z45.object({
+    wasmBase64: z45.base64(),
+    wasmBytes: z45.optional(z45.never())
+  }),
+  z45.object({
+    wasmBase64: z45.optional(z45.never()),
+    wasmBytes: z45.instanceof(Uint8Array)
+  })
+]);
+var safeDeployContract = wrapInternalError("CreateAction.DeployContract.Internal", (args) => {
+  const validArgs = CreateDeployContractActionArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "CreateAction.DeployContract.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  const u8Wasm = validArgs.data.wasmBytes ? validArgs.data.wasmBytes : import_base7.base64.decode(validArgs.data.wasmBase64);
+  return result.ok({
+    actionType: "DeployContract",
+    wasmBytes: u8Wasm
+  });
 });
+var throwableDeployContract = asThrowable(safeDeployContract);
 
 // src/helpers/actionCreators/deleteKey.ts
-var deleteKey = (params) => ({
-  actionType: "DeleteKey",
-  params
+var z46 = __toESM(require("zod/mini"), 1);
+var CreateDeleteKeyActionArgsSchema = z46.object({
+  publicKey: PublicKeySchema
 });
+var safeDeleteKey = wrapInternalError(
+  "CreateAction.DeleteKey.Internal",
+  (args) => {
+    const validArgs = CreateDeleteKeyActionArgsSchema.safeParse(args);
+    if (!validArgs.success)
+      return result.err(
+        createNatError({
+          kind: "CreateAction.DeleteKey.Args.InvalidSchema",
+          context: { zodError: validArgs.error }
+        })
+      );
+    return result.ok({
+      actionType: "DeleteKey",
+      publicKey: args.publicKey
+    });
+  }
+);
+var throwableDeleteKey = asThrowable(safeDeleteKey);
 
 // src/helpers/actionCreators/deleteAccount.ts
-var deleteAccount = (params) => ({
-  actionType: "DeleteAccount",
-  params
+var z47 = __toESM(require("zod/mini"), 1);
+var CreateDeleteAccountActionArgsSchema = z47.object({
+  beneficiaryAccountId: AccountIdSchema
+});
+var safeDeleteAccount = wrapInternalError("CreateAction.DeleteAccount.Internal", (args) => {
+  const validArgs = CreateDeleteAccountActionArgsSchema.safeParse(args);
+  if (!validArgs.success)
+    return result.err(
+      createNatError({
+        kind: "CreateAction.DeleteAccount.Args.InvalidSchema",
+        context: { zodError: validArgs.error }
+      })
+    );
+  return result.ok({
+    actionType: "DeleteAccount",
+    beneficiaryAccountId: args.beneficiaryAccountId
+  });
 });
+var throwableDeleteAccount = asThrowable(safeDeleteAccount);
 
-// src/helpers/actionCreators/deployContract.ts
-var deployContract = (params) => ({
-  actionType: "DeployContract",
-  params
+// src/helpers/keyPair/randomEd25519KeyPair.ts
+var import_ed255192 = require("@noble/curves/ed25519");
+var createSafeSignByEd25519Key = (u8PrivateKey) => wrapInternalError(
+  "Ed25519KeyPair.Sign.Internal",
+  (message) => signByEd25519Key(u8PrivateKey, message)
+);
+var safeRandomEd25519KeyPair = wrapInternalError("CreateRandomEd25519KeyPair.Internal", () => {
+  const { secretKey: u8SecretKey, publicKey: u8PublicKey } = import_ed255192.ed25519.keygen();
+  const u8PrivateKey = new Uint8Array([...u8SecretKey, ...u8PublicKey]);
+  const publicKey = toEd25519CurveString(u8PublicKey);
+  const privateKey = toEd25519CurveString(u8PrivateKey);
+  const safeSign = createSafeSignByEd25519Key(u8PrivateKey);
+  return result.ok({
+    publicKey,
+    privateKey,
+    sign: asThrowable(safeSign),
+    safeSign
+  });
+});
+var throwableRandomEd25519KeyPair = asThrowable(safeRandomEd25519KeyPair);
+
+// src/helpers/keyPair/randomSecp256k1KeyPair.ts
+var import_secp256k12 = require("@noble/curves/secp256k1");
+var createSafeSignBySecp256k1Key = (u8PrivateKey) => wrapInternalError(
+  "Secp256k1KeyPair.Sign.Internal",
+  (message) => signBySecp256k1Key(u8PrivateKey, message)
+);
+var safeRandomSecp256k1KeyPair = wrapInternalError("CreateRandomSecp256k1KeyPair.Internal", () => {
+  const u8SecretKey = import_secp256k12.secp256k1.utils.randomSecretKey();
+  const u8PublicKey = import_secp256k12.secp256k1.getPublicKey(u8SecretKey, false);
+  const u8PublicKeyWithoutHeader = u8PublicKey.slice(1);
+  const u8PrivateKey = new Uint8Array([
+    ...u8SecretKey,
+    ...u8PublicKeyWithoutHeader
+  ]);
+  const publicKey = toSecp256k1CurveString(u8PublicKeyWithoutHeader);
+  const privateKey = toSecp256k1CurveString(u8PrivateKey);
+  const safeSign = createSafeSignBySecp256k1Key(u8PrivateKey);
+  return result.ok({
+    publicKey,
+    privateKey,
+    sign: asThrowable(safeSign),
+    safeSign
+  });
 });
+var throwableRandomSecp256k1KeyPair = asThrowable(safeRandomSecp256k1KeyPair);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addFullAccessKey,
@@ -2446,13 +4070,42 @@ var deployContract = (params) => ({
   createMainnetClient,
   createMemoryKeyService,
   createMemorySigner,
+  createMemorySignerFactory,
+  createSafeMemorySignerFactory,
   createTestnetClient,
   deleteAccount,
   deleteKey,
   deployContract,
   functionCall,
   gas,
+  isNatError,
+  isNearGas,
+  isNearToken,
+  keyPair,
   near,
+  nearGas,
+  nearToken,
+  randomEd25519KeyPair,
+  randomSecp256k1KeyPair,
+  safeAddFullAccessKey,
+  safeAddFunctionCallKey,
+  safeCreateClient,
+  safeCreateMemoryKeyService,
+  safeCreateMemorySigner,
+  safeDeleteAccount,
+  safeDeleteKey,
+  safeDeployContract,
+  safeFunctionCall,
+  safeGas,
+  safeKeyPair,
+  safeNear,
+  safeNearGas,
+  safeNearToken,
+  safeRandomEd25519KeyPair,
+  safeRandomSecp256k1KeyPair,
+  safeTeraGas,
+  safeTransfer,
+  safeYoctoNear,
   teraGas,
   transfer,
   yoctoNear