near-api-ts 0.7.1 → 0.8.0

package/dist/browser/index.d.ts

@@ -1,6 +1,6 @@
-import { PublicKey as PublicKey$1, ShardId, RpcBlockResponse, RpcTransactionResponse } from '@near-js/jsonrpc-types';
 import { PartialDeep } from 'type-fest';
 import * as z from 'zod/mini';
+import { ShardId, RpcBlockResponse, RpcTransactionResponse } from '@near-js/jsonrpc-types';
 import { $ZodError } from 'zod/v4/core';
 
 declare const NatErrorBrand: unique symbol;
@@ -269,7 +269,10 @@ type KeyIf<K extends PropertyKey, V> = [V] extends [undefined] ? {
 
 interface CreateFunctionCallActionPublicErrorRegistry {
     'CreateAction.FunctionCall.Args.InvalidSchema': InvalidSchemaErrorContext;
-    'CreateAction.FunctionCall.SerializeArgs.Internal': InternalErrorContext;
+    'CreateAction.FunctionCall.SerializeArgs.Failed': {
+        cause: unknown;
+        functionArgs: unknown;
+    };
     'CreateAction.FunctionCall.SerializeArgs.InvalidOutput': {
         output: unknown;
     };
@@ -287,19 +290,19 @@ type FunctionCallAction = {
     gasLimit: NearGasArgs;
     attachedDeposit?: NearTokenArgs;
 };
-type BaseSerializeArgs$1<A> = (args: {
+type BaseSerializeArgs<A> = (args: {
     functionArgs: A;
 }) => Uint8Array;
 type FunctionArgsOf$1<SA> = SA extends (args: {
     functionArgs: infer T;
 }) => Uint8Array ? T : undefined;
 type FunctionArgs$1<A> = KeyIf<'functionArgs', A>;
-type CreateFunctionCallActionError = NatError<'CreateAction.FunctionCall.Args.InvalidSchema'> | NatError<'CreateAction.FunctionCall.SerializeArgs.InvalidOutput'> | NatError<'CreateAction.FunctionCall.SerializeArgs.Internal'> | NatError<'CreateAction.FunctionCall.Internal'>;
+type CreateFunctionCallActionError = NatError<'CreateAction.FunctionCall.Args.InvalidSchema'> | NatError<'CreateAction.FunctionCall.SerializeArgs.InvalidOutput'> | NatError<'CreateAction.FunctionCall.SerializeArgs.Failed'> | NatError<'CreateAction.FunctionCall.Internal'>;
 type SafeCreateFunctionCallAction = {
     <A extends MaybeJsonLikeValue = undefined>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
         options?: never;
     }): Result<FunctionCallAction, CreateFunctionCallActionError>;
-    <SA extends BaseSerializeArgs$1<A>, A = FunctionArgsOf$1<SA>>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
+    <SA extends BaseSerializeArgs<A>, A = FunctionArgsOf$1<SA>>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
         options: {
             serializeArgs: SA;
         };
@@ -309,7 +312,7 @@ type CreateFunctionCallAction = {
     <A extends MaybeJsonLikeValue = undefined>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
         options?: never;
     }): FunctionCallAction;
-    <SA extends BaseSerializeArgs$1<A>, A = FunctionArgsOf$1<SA>>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
+    <SA extends BaseSerializeArgs<A>, A = FunctionArgsOf$1<SA>>(args: BaseFunctionCallActionArgs & FunctionArgs$1<A> & {
         options: {
             serializeArgs: SA;
         };
@@ -322,12 +325,12 @@ interface CreateStakeActionPublicErrorRegistry {
 }
 type CreateStakeActionArgs = {
     amount: NearTokenArgs;
-    validatorPublicKey: PublicKey$1;
+    validatorPublicKey: PublicKey;
 };
 type StakeAction = {
     actionType: 'Stake';
     amount: NearTokenArgs;
-    validatorPublicKey: PublicKey$1;
+    validatorPublicKey: PublicKey;
 };
 type CreateStakeActionError = NatError<'CreateAction.Stake.Args.InvalidSchema'> | NatError<'CreateAction.Stake.Internal'>;
 type SafeCreateStakeAction = (args: CreateStakeActionArgs) => Result<StakeAction, CreateStakeActionError>;
@@ -772,7 +775,10 @@ type GetBlock = (args?: GetBlockArgs) => Promise<GetBlockOutcome>;
 
 interface CallContractReadFunctionPublicErrorRegistry {
     'Client.CallContractReadFunction.Args.InvalidSchema': InvalidSchemaErrorContext;
-    'Client.CallContractReadFunction.SerializeArgs.Internal': InternalErrorContext;
+    'Client.CallContractReadFunction.SerializeArgs.Failed': {
+        cause: unknown;
+        functionArgs: unknown;
+    };
     'Client.CallContractReadFunction.SerializeArgs.InvalidOutput': {
         output: unknown;
     };
@@ -790,18 +796,27 @@ interface CallContractReadFunctionPublicErrorRegistry {
         blockHash: BlockHash;
         blockHeight: BlockHeight;
     };
-    'Client.CallContractReadFunction.DeserializeResult.Internal': InternalErrorContext;
+    'Client.CallContractReadFunction.ResultDeserialization.JsonParseFailed': {
+        cause: unknown;
+        rawResult: RawCallResult;
+    };
+    'Client.CallContractReadFunction.DeserializeResult.Failed': {
+        cause: unknown;
+        rawResult: RawCallResult;
+    };
     'Client.CallContractReadFunction.Internal': InternalErrorContext;
 }
 type RawCallResult = number[];
 type RawCallLogs = string[];
-type BaseDeserializeResult = ({ rawResult, }: {
+type DeserializeResultFnArgs = {
     rawResult: RawCallResult;
-}) => unknown;
-type MaybeBaseDeserializeResult = BaseDeserializeResult | undefined;
-type BaseSerializeArgs<A> = (args: {
+};
+type BaseDeserializeResultFn = (args: DeserializeResultFnArgs) => unknown;
+type MaybeBaseDeserializeResultFn = BaseDeserializeResultFn | undefined;
+type BaseSerializeArgsFn<A> = (args: {
     functionArgs: A;
 }) => Uint8Array;
+type MaybeBaseSerializeArgsFn<A> = BaseSerializeArgsFn<A> | undefined;
 type BaseFnCallArgs = {
     contractAccountId: AccountId;
     functionName: ContractFunctionName;
@@ -813,13 +828,16 @@ type BaseFnCallArgs = {
 type BaseOptions = {
     signal?: AbortSignal;
 };
-type Options<A, SR extends BaseSerializeArgs<A> | undefined, DR extends MaybeBaseDeserializeResult> = [SR, DR] extends [undefined, undefined] ? {
+type Options<A, SR extends MaybeBaseSerializeArgsFn<A>, DR extends MaybeBaseDeserializeResultFn> = [
+    SR,
+    DR
+] extends [undefined, undefined] ? {
     options?: BaseOptions;
 } : {
     options: BaseOptions & KeyIf<'serializeArgs', SR> & KeyIf<'deserializeResult', DR>;
 };
 type FunctionArgs<A> = KeyIf<'functionArgs', A>;
-type Output<R> = {
+type CallContractReadFunctionOutput<R> = {
     blockHash: BlockHash;
     blockHeight: BlockHeight;
     result: R;
@@ -829,22 +847,20 @@ type Output<R> = {
 type FunctionArgsOf<SA> = SA extends (args: {
     functionArgs: infer T;
 }) => Uint8Array ? T : undefined;
-type CallContractReadFunctionError = NatError<'Client.CallContractReadFunction.Args.InvalidSchema'> | NatError<'Client.CallContractReadFunction.SerializeArgs.InvalidOutput'> | NatError<'Client.CallContractReadFunction.SerializeArgs.Internal'> | NatError<'Client.CallContractReadFunction.PreferredRpc.NotFound'> | NatError<'Client.CallContractReadFunction.Timeout'> | NatError<'Client.CallContractReadFunction.Aborted'> | NatError<'Client.CallContractReadFunction.Exhausted'> | NatError<'Client.CallContractReadFunction.Rpc.NotSynced'> | NatError<'Client.CallContractReadFunction.Rpc.Shard.NotTracked'> | NatError<'Client.CallContractReadFunction.Rpc.Block.GarbageCollected'> | NatError<'Client.CallContractReadFunction.Rpc.Block.NotFound'> | NatError<'Client.CallContractReadFunction.Rpc.Execution.Failed'> | NatError<'Client.CallContractReadFunction.DeserializeResult.Internal'> | NatError<'Client.CallContractReadFunction.Internal'>;
-type SafeCallOutput<DR extends MaybeBaseDeserializeResult> = [DR] extends [
-    BaseDeserializeResult
-] ? Promise<Result<Output<ReturnType<DR>>, CallContractReadFunctionError>> : Promise<Result<Output<unknown>, CallContractReadFunctionError>>;
+type CallContractReadFunctionError = NatError<'Client.CallContractReadFunction.Args.InvalidSchema'> | NatError<'Client.CallContractReadFunction.SerializeArgs.InvalidOutput'> | NatError<'Client.CallContractReadFunction.SerializeArgs.Failed'> | NatError<'Client.CallContractReadFunction.PreferredRpc.NotFound'> | NatError<'Client.CallContractReadFunction.Timeout'> | NatError<'Client.CallContractReadFunction.Aborted'> | NatError<'Client.CallContractReadFunction.Exhausted'> | NatError<'Client.CallContractReadFunction.Rpc.NotSynced'> | NatError<'Client.CallContractReadFunction.Rpc.Shard.NotTracked'> | NatError<'Client.CallContractReadFunction.Rpc.Block.GarbageCollected'> | NatError<'Client.CallContractReadFunction.Rpc.Block.NotFound'> | NatError<'Client.CallContractReadFunction.Rpc.Execution.Failed'> | NatError<'Client.CallContractReadFunction.ResultDeserialization.JsonParseFailed'> | NatError<'Client.CallContractReadFunction.DeserializeResult.Failed'> | NatError<'Client.CallContractReadFunction.Internal'>;
+type SafeCallOutput<DR extends MaybeBaseDeserializeResultFn> = [DR] extends [
+    BaseDeserializeResultFn
+] ? Promise<Result<CallContractReadFunctionOutput<ReturnType<DR>>, CallContractReadFunctionError>> : Promise<Result<CallContractReadFunctionOutput<unknown>, CallContractReadFunctionError>>;
 type SafeCallContractReadFunction = {
     <A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, undefined>): SafeCallOutput<undefined>;
-    <DR extends BaseDeserializeResult, A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): SafeCallOutput<DR>;
-    <SA extends BaseSerializeArgs<A>, DR extends MaybeBaseDeserializeResult = undefined, A = FunctionArgsOf<SA>>(args: BaseFnCallArgs & FunctionArgs<A> & Options<A, SA, DR>): SafeCallOutput<DR>;
+    <DR extends BaseDeserializeResultFn, A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): SafeCallOutput<DR>;
+    <SA extends BaseSerializeArgsFn<A>, DR extends MaybeBaseDeserializeResultFn = undefined, A = FunctionArgsOf<SA>>(args: BaseFnCallArgs & FunctionArgs<A> & Options<A, SA, DR>): SafeCallOutput<DR>;
 };
-type CallOutput<DR extends MaybeBaseDeserializeResult> = [DR] extends [
-    BaseDeserializeResult
-] ? Promise<Output<ReturnType<DR>>> : Promise<Output<unknown>>;
+type CallOutput<DR extends MaybeBaseDeserializeResultFn> = [DR] extends [BaseDeserializeResultFn] ? Promise<CallContractReadFunctionOutput<ReturnType<DR>>> : Promise<CallContractReadFunctionOutput<unknown>>;
 type CallContractReadFunction = {
     <A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, undefined>): CallOutput<undefined>;
-    <DR extends BaseDeserializeResult, A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): CallOutput<DR>;
-    <SA extends BaseSerializeArgs<A>, DR extends MaybeBaseDeserializeResult = undefined, A = FunctionArgsOf<SA>>(args: BaseFnCallArgs & FunctionArgs<A> & Options<A, SA, DR>): CallOutput<DR>;
+    <DR extends BaseDeserializeResultFn, A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): CallOutput<DR>;
+    <SA extends BaseSerializeArgsFn<A>, DR extends MaybeBaseDeserializeResultFn = undefined, A = FunctionArgsOf<SA>>(args: BaseFnCallArgs & FunctionArgs<A> & Options<A, SA, DR>): CallOutput<DR>;
 };
 
 type TransactionErrorContext = {
@@ -1359,7 +1375,10 @@ type CreateRandomSecp256k1KeyPair = () => Secp256k1KeyPair;
 declare const safeRandomSecp256k1KeyPair: SafeCreateRandomSecp256k1KeyPair;
 declare const throwableRandomSecp256k1KeyPair: CreateRandomSecp256k1KeyPair;
 
+declare const toJsonBytes: (value: unknown) => Uint8Array;
+declare const fromJsonBytes: (bytes: Uint8Array | number[]) => unknown;
+
 declare const safeCreateIdbKeyService: any;
 declare const throwableCreateIdbKeyService: any;
 
-export { type AccountId, type CallContractReadFunction, type CallContractReadFunctionError, type Client, type FunctionCallAction, type GetAccountInfo, type GetAccountInfoError, type GetAccountInfoOutput, type MemoryKeyService, type MemorySigner, type MemorySignerFactory, type PrivateKey, type PublicKey, type SafeCallContractReadFunction, type SafeGetAccountInfo, type SafeMemorySignerFactory, type Signature, type TransactionIntent, type TransferAction, throwableAddFullAccessKey as addFullAccessKey, throwableAddFunctionCallKey as addFunctionCallKey, createAccount, throwableCreateClient as createClient, throwableCreateIdbKeyService as createIdbKeyService, createMainnetClient, throwableCreateMemoryKeyService as createMemoryKeyService, throwableCreateMemorySigner as createMemorySigner, createThrowableMemorySignerFactory as createMemorySignerFactory, createSafeMemorySignerFactory, createTestnetClient, throwableDeleteAccount as deleteAccount, throwableDeleteKey as deleteKey, throwableDeployContract as deployContract, throwableFunctionCall as functionCall, throwableGas as gas, isNatError, isNearGas, isNearToken, throwableKeyPair as keyPair, throwableNear as near, throwableNearGas as nearGas, throwableNearToken as nearToken, throwableRandomEd25519KeyPair as randomEd25519KeyPair, throwableRandomSecp256k1KeyPair as randomSecp256k1KeyPair, safeAddFullAccessKey, safeAddFunctionCallKey, safeCreateClient, safeCreateIdbKeyService, safeCreateMemoryKeyService, safeCreateMemorySigner, safeDeleteAccount, safeDeleteKey, safeDeployContract, safeFunctionCall, safeGas, safeKeyPair, safeNear, safeNearGas, safeNearToken, safeRandomEd25519KeyPair, safeRandomSecp256k1KeyPair, safeStake, safeTeraGas, safeTransfer, safeYoctoNear, throwableStake as stake, throwableTeraGas as teraGas, throwableTransfer as transfer, throwableYoctoNear as yoctoNear };
+export { type AccountId, type Action, type BaseDeserializeResultFn, type BaseSerializeArgsFn, type BlockReference, type CallContractReadFunction, type CallContractReadFunctionError, type CallContractReadFunctionOutput, type Client, type ContractFunctionName, type DeserializeResultFnArgs, type FunctionCallAction, type GetAccountInfo, type GetAccountInfoError, type GetAccountInfoOutput, type JsonLikeValue, type MaybeBaseDeserializeResultFn, type MaybeBaseSerializeArgsFn, type MaybeJsonLikeValue, type MemoryKeyService, type MemorySigner, type MemorySignerFactory, type PartialTransportPolicy, type PrivateKey, type PublicKey, type SafeCallContractReadFunction, type SafeGetAccountInfo, type SafeMemorySignerFactory, type Signature, type SignedTransaction, type Transaction, type TransactionIntent, type TransferAction, throwableAddFullAccessKey as addFullAccessKey, throwableAddFunctionCallKey as addFunctionCallKey, createAccount, throwableCreateClient as createClient, throwableCreateIdbKeyService as createIdbKeyService, createMainnetClient, throwableCreateMemoryKeyService as createMemoryKeyService, throwableCreateMemorySigner as createMemorySigner, createThrowableMemorySignerFactory as createMemorySignerFactory, createSafeMemorySignerFactory, createTestnetClient, throwableDeleteAccount as deleteAccount, throwableDeleteKey as deleteKey, throwableDeployContract as deployContract, fromJsonBytes, throwableFunctionCall as functionCall, throwableGas as gas, isNatError, isNearGas, isNearToken, throwableKeyPair as keyPair, throwableNear as near, throwableNearGas as nearGas, throwableNearToken as nearToken, throwableRandomEd25519KeyPair as randomEd25519KeyPair, throwableRandomSecp256k1KeyPair as randomSecp256k1KeyPair, safeAddFullAccessKey, safeAddFunctionCallKey, safeCreateClient, safeCreateIdbKeyService, safeCreateMemoryKeyService, safeCreateMemorySigner, safeDeleteAccount, safeDeleteKey, safeDeployContract, safeFunctionCall, safeGas, safeKeyPair, safeNear, safeNearGas, safeNearToken, safeRandomEd25519KeyPair, safeRandomSecp256k1KeyPair, safeStake, safeTeraGas, safeTransfer, safeYoctoNear, throwableStake as stake, throwableTeraGas as teraGas, toJsonBytes, throwableTransfer as transfer, throwableYoctoNear as yoctoNear };

package/dist/browser/index.js

@@ -1362,17 +1362,26 @@ import * as z18 from "zod/mini";
 // universal/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 {
+      result.ok(args.options.deserializeResult({ rawResult }));
+    } catch (e) {
+      return result.err(
+        createNatError({
+          kind: "Client.CallContractReadFunction.DeserializeResult.Failed",
+          context: { cause: e, rawResult }
+        })
+      );
+    }
   }
   try {
-    const res = fromJsonBytes(rawResult);
-    return result.ok(res);
+    return result.ok(fromJsonBytes(rawResult));
   } catch (e) {
-    return result.ok(void 0);
+    return result.err(
+      createNatError({
+        kind: "Client.CallContractReadFunction.ResultDeserialization.JsonParseFailed",
+        context: { cause: e, rawResult }
+      })
+    );
   }
 };
 
@@ -1438,23 +1447,26 @@ var handleResult5 = (rpcResponse, args) => {
 // universal/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);
-      }
-    )();
+    try {
+      const output = args.options.serializeArgs({
+        functionArgs: args.functionArgs
+      });
+      if (!(output instanceof Uint8Array))
+        return result.err(
+          createNatError({
+            kind: "Client.CallContractReadFunction.SerializeArgs.InvalidOutput",
+            context: { output }
+          })
+        );
+      return result.ok(output);
+    } catch (e) {
+      return result.err(
+        createNatError({
+          kind: "Client.CallContractReadFunction.SerializeArgs.Failed",
+          context: { cause: e, functionArgs: args.functionArgs }
+        })
+      );
+    }
   }
   if (args.functionArgs) {
     const jsonArgs = JsonSchema.safeParse(args.functionArgs);
@@ -1668,28 +1680,32 @@ var TransactionBaseSchema = z30.object({
   nonce: NonceSchema,
   blockHash: BlockHashSchema
 });
-var SingleActionTransactionSchema = z30.object({
-  ...TransactionBaseSchema.shape,
+var TransactionSingleActionSchema = z30.object({
   action: ActionSchema,
   actions: z30.optional(z30.never())
 });
-var MultiActionsTransactionSchema = z30.object({
+var SingleActionTransactionSchema = z30.object({
   ...TransactionBaseSchema.shape,
+  ...TransactionSingleActionSchema.shape
+});
+var TransactionMultiActionsSchema = z30.object({
   action: z30.optional(z30.never()),
   actions: z30.array(ActionSchema).check(z30.minLength(1))
 });
+var MultiActionsTransactionSchema = z30.object({
+  ...TransactionBaseSchema.shape,
+  ...TransactionMultiActionsSchema.shape
+});
 var TransactionSchema = z30.union([
   SingleActionTransactionSchema,
   MultiActionsTransactionSchema
 ]);
 var SingleActionTransactionIntentSchema = z30.object({
-  action: ActionSchema,
-  actions: z30.optional(z30.never()),
+  ...TransactionSingleActionSchema.shape,
   receiverAccountId: AccountIdSchema
 });
 var MultiActionsTransactionIntentSchema = z30.object({
-  action: z30.optional(z30.never()),
-  actions: z30.array(ActionSchema).check(z30.minLength(1)),
+  ...TransactionMultiActionsSchema.shape,
   receiverAccountId: AccountIdSchema
 });
 var TransactionIntentSchema = z30.union([
@@ -2227,10 +2243,9 @@ var toNativeAction = (action) => {
   if (action.actionType === "DeleteKey") return toNativeDeleteKeyAction(action);
   return toNativeDeleteAccountAction(action);
 };
-var toNativeActions = (transaction) => {
-  if (transaction.action) return [toNativeAction(transaction.action)];
-  if (transaction.actions)
-    return transaction.actions.map((action) => toNativeAction(action));
+var toNativeActions = (actions) => {
+  if (actions.action) return [toNativeAction(actions.action)];
+  if (actions.actions) return actions.actions.map((action) => toNativeAction(action));
   return [];
 };
 var toNativeTransaction = (transaction) => ({
@@ -3985,23 +4000,26 @@ var throwableAddFunctionCallKey = asThrowable(safeAddFunctionCallKey);
 import * as z47 from "zod/mini";
 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);
-      }
-    )();
+    try {
+      const output = args.options.serializeArgs({
+        functionArgs: args.functionArgs
+      });
+      if (!(output instanceof Uint8Array))
+        return result.err(
+          createNatError({
+            kind: "CreateAction.FunctionCall.SerializeArgs.InvalidOutput",
+            context: { output }
+          })
+        );
+      return result.ok(output);
+    } catch (e) {
+      return result.err(
+        createNatError({
+          kind: "CreateAction.FunctionCall.SerializeArgs.Failed",
+          context: { cause: e, functionArgs: args.functionArgs }
+        })
+      );
+    }
   }
   if (args?.functionArgs) {
     const jsonArgs = JsonSchema.safeParse(args.functionArgs);
@@ -4376,6 +4394,7 @@ export {
   throwableDeleteAccount as deleteAccount,
   throwableDeleteKey as deleteKey,
   throwableDeployContract as deployContract,
+  fromJsonBytes,
   throwableFunctionCall as functionCall,
   throwableGas as gas,
   isNatError,
@@ -4410,6 +4429,7 @@ export {
   safeYoctoNear,
   throwableStake as stake,
   throwableTeraGas as teraGas,
+  toJsonBytes,
   throwableTransfer as transfer,
   throwableYoctoNear as yoctoNear
 };