near-api-ts 0.3.0 → 0.4.0

package/README.md

@@ -15,7 +15,6 @@ import {
   createTestnetClient,
   createMemoryKeyService,
   createMemorySigner,
-  testnet,
   transfer,
 } from 'near-api-ts';
 

package/dist/index.d.cts

@@ -775,7 +775,9 @@ type BaseDeserializeResult = ({ rawResult, }: {
     rawResult: RawCallResult;
 }) => unknown;
 type MaybeBaseDeserializeResult = BaseDeserializeResult | undefined;
-type BaseSerializeArgs<A> = (args: {
+type BaseSerializeArgs<A> = [A] extends [undefined] ? (args?: {
+    functionArgs: A;
+}) => Uint8Array : (args: {
     functionArgs: A;
 }) => Uint8Array;
 type BaseFnCallArgs = {

package/dist/index.d.ts

@@ -775,7 +775,9 @@ type BaseDeserializeResult = ({ rawResult, }: {
     rawResult: RawCallResult;
 }) => unknown;
 type MaybeBaseDeserializeResult = BaseDeserializeResult | undefined;
-type BaseSerializeArgs<A> = (args: {
+type BaseSerializeArgs<A> = [A] extends [undefined] ? (args?: {
+    functionArgs: A;
+}) => Uint8Array : (args: {
     functionArgs: A;
 }) => Uint8Array;
 type BaseFnCallArgs = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-api-ts",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Typescript library for interactions with Near Protocol in the browser or Node.js",
   "type": "module",
   "exports": {
@@ -40,7 +40,6 @@
     "@scure/base": "^1.2.6",
     "borsh": "^2.0.0",
     "lodash-es": "^4.17.21",
-    "valibot": "^1.1.0",
-    "zod": "^4.0.11"
+    "zod": "^4.1.12"
   }
 }

package/src/_common/transformers/toNative/actions/addKey.ts

@@ -3,19 +3,19 @@ import type {
   NativeAddKeyAction,
 } from 'nat-types/actions/addKey';
 import { toNativePublicKey } from '@common/transformers/toNative/publicKey';
-import { fromNearOption } from '../../../../helpers/near';
+import { nearToken } from '../../../../helpers/nearToken';
 
 const getPermission = (
-  params: AddKeyAction['params'],
+  action: AddKeyAction,
 ): NativeAddKeyAction['addKey']['accessKey']['permission'] => {
-  if (params.accessType === 'FullAccess') return { fullAccess: {} };
+  if (action.accessType === 'FullAccess') return { fullAccess: {} };
 
-  const { contractAccountId, gasBudget, allowedFunctions } = params;
+  const { contractAccountId, gasBudget, allowedFunctions } = action;
 
   return {
     functionCall: {
       receiverId: contractAccountId,
-      allowance: gasBudget && fromNearOption(gasBudget).yoctoNear,
+      allowance: gasBudget && nearToken(gasBudget).yoctoNear,
       methodNames: allowedFunctions ?? [],
     },
   };
@@ -25,10 +25,10 @@ export const toNativeAddKeyAction = (
   action: AddKeyAction,
 ): NativeAddKeyAction => ({
   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),
     },
   },
 });

package/src/_common/transformers/toNative/actions/deleteAccount.ts

@@ -7,6 +7,6 @@ export const toNativeDeleteAccountAction = (
   action: DeleteAccountAction,
 ): NativeDeleteAccountAction => ({
   deleteAccount: {
-    beneficiaryId: action.params.beneficiaryAccountId,
+    beneficiaryId: action.beneficiaryAccountId,
   },
 });

package/src/_common/transformers/toNative/actions/deleteKey.ts

@@ -8,6 +8,6 @@ export const toNativeDeleteKeyAction = (
   action: DeleteKeyAction,
 ): NativeDeleteKeyAction => ({
   deleteKey: {
-    publicKey: toNativePublicKey(action.params.publicKey),
+    publicKey: toNativePublicKey(action.publicKey),
   },
 });

package/src/_common/transformers/toNative/actions/deployContract.ts

@@ -7,9 +7,9 @@ import type {
 export const toNativeDeployContractAction = (
   action: DeployContractAction,
 ): NativeDeployContractAction => {
-  const code = action.params.wasmBytes
-    ? action.params.wasmBytes
-    : base64.decode(action.params.wasmBase64);
+  const code = action.wasmBytes
+    ? action.wasmBytes
+    : base64.decode(action.wasmBase64);
 
   return {
     deployContract: { code },

package/src/_common/transformers/toNative/actions/functionCall.ts

@@ -2,21 +2,19 @@ import type {
   FunctionCallAction,
   NativeFunctionCallAction,
 } from 'nat-types/actions/functionCall';
-import { fromNearOption } from '../../../../helpers/near';
-import { fromGasOption } from '../../../../helpers/gas';
-import { toContractFnArgsBytes } from '@common/transformers/contract';
-import type { MaybeJsonLikeValue } from 'nat-types/common';
+import { nearToken } from '../../../../helpers/nearToken';
+import { nearGas } from '../../../../helpers/nearGas';
 
-export const toNativeFunctionCallAction = <AJ extends MaybeJsonLikeValue>(
-  action: FunctionCallAction<AJ>,
+export const toNativeFunctionCallAction = (
+  action: FunctionCallAction,
 ): NativeFunctionCallAction => {
-  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: nearGas(gasLimit).gas,
+      deposit: attachedDeposit ? nearToken(attachedDeposit).yoctoNear : 0n,
     },
   };
 };

package/src/_common/transformers/toNative/actions/transfer.ts

@@ -2,12 +2,12 @@ import type {
   TransferAction,
   NativeTransferAction,
 } from 'nat-types/actions/transfer';
-import { fromNearOption } from '../../../../helpers/near';
+import { nearToken } from '../../../../helpers/nearToken';
 
 export const toNativeTransferAction = (
   action: TransferAction,
 ): NativeTransferAction => ({
   transfer: {
-    deposit: fromNearOption(action.params.amount).yoctoNear,
+    deposit: nearToken(action.amount).yoctoNear,
   },
 });

package/src/client/methods/account/getAccountState.ts

@@ -1,7 +1,7 @@
 import * as z from 'zod/mini';
 import { toNativeBlockReference } from '@common/transformers/toNative/blockReference';
 import { AccountViewSchema, CryptoHashSchema } from '@near-js/jsonrpc-types';
-import { yoctoNear } from '../../../helpers/near';
+import { yoctoNear } from '../../../helpers/nearToken';
 import { addTo } from '@common/utils/addTo';
 import type {
   CreateGetAccountState,

package/src/client/methods/account/helpers/transformKey.ts

@@ -1,4 +1,4 @@
-import { yoctoNear } from '../../../../helpers/near';
+import { yoctoNear } from '../../../../helpers/nearToken';
 import type { AccessKeyInfoView } from '@near-js/jsonrpc-types';
 import type { AccountKey, FunctionCallKey } from 'nat-types/accountKey';
 import type { PublicKey } from 'nat-types/crypto';

package/src/client/methods/protocol/getGasPrice.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod/mini';
 import { RpcGasPriceResponseSchema } from '@near-js/jsonrpc-types';
-import { yoctoNear } from '../../../helpers/near';
+import { yoctoNear } from '../../../helpers/nearToken';
 import type {
   CreateGetGasPrice,
   GetGasPriceResult,

package/src/client/rpcError.ts

@@ -3,7 +3,7 @@ import { oneLine } from '@common/utils/common';
 import type { RpcRequestLog } from 'nat-types/client/transport';
 import type { TransportError } from './transport/transportError';
 
-const Brand = Symbol.for('near-api-ts.RpcError');
+const Brand = Symbol.for('near-api-ts.RpcError'); // TODO check if it's a valid solution!
 
 const parseRequestValidationError = (name: string) => {
   if (name === 'PARSE_ERROR')
@@ -100,7 +100,7 @@ export class RpcError extends Error {
     super(
       `[${code}]: ${message} \n` +
         `Type: ${args.__rawRpcError.name} \n` +
-        `Cause: ${JSON.stringify(args.__rawRpcError.cause, null, 2)}`,
+        `Cause: ${JSON.stringify(args.__rawRpcError, null, 2)}`,
     );
     this.name = 'RpcError';
     this.code = code;

package/src/helpers/actionCreators/addFullAccessKey.ts

@@ -1,14 +1,12 @@
 import type {
-  AddKeyAction,
-  FullAccessKeyParams,
+  AddFullAccessKeyAction,
+  CreateAddFullAccessKeyActionArgs,
 } from 'nat-types/actions/addKey';
 
-export const addFullAccessKey = ({
-  publicKey,
-}: Omit<FullAccessKeyParams, 'accessType'>): AddKeyAction => ({
+export const addFullAccessKey = (
+  args: CreateAddFullAccessKeyActionArgs,
+): AddFullAccessKeyAction => ({
+  ...args,
   actionType: 'AddKey',
-  params: {
-    accessType: 'FullAccess',
-    publicKey,
-  },
+  accessType: 'FullAccess',
 });

package/src/helpers/actionCreators/addFunctionCallKey.ts

@@ -1,20 +1,12 @@
 import type {
-  AddKeyAction,
-  FunctionCallKeyParams,
+  AddFunctionCallKeyAction,
+  CreateAddFunctionCallKeyActionArgs,
 } from 'nat-types/actions/addKey';
 
-export const addFunctionCallKey = ({
-  publicKey,
-  contractAccountId,
-  gasBudget,
-  allowedFunctions,
-}: Omit<FunctionCallKeyParams, 'accessType'>): AddKeyAction => ({
+export const addFunctionCallKey = (
+  args: CreateAddFunctionCallKeyActionArgs,
+): AddFunctionCallKeyAction => ({
+  ...args,
   actionType: 'AddKey',
-  params: {
-    accessType: 'FunctionCall',
-    publicKey,
-    contractAccountId,
-    gasBudget,
-    allowedFunctions,
-  },
+  accessType: 'FunctionCall',
 });

package/src/helpers/actionCreators/deleteAccount.ts

@@ -1,11 +1,11 @@
 import type {
   DeleteAccountAction,
-  DeleteAccountActionParams,
+  CreateDeleteAccountActionArgs,
 } from 'nat-types/actions/deleteAccount';
 
 export const deleteAccount = (
-  params: DeleteAccountActionParams,
+  args: CreateDeleteAccountActionArgs,
 ): DeleteAccountAction => ({
+  ...args,
   actionType: 'DeleteAccount',
-  params,
 });

package/src/helpers/actionCreators/deleteKey.ts

@@ -1,9 +1,11 @@
 import type {
   DeleteKeyAction,
-  DeleteKeyActionParams,
+  CreateDeleteKeyActionArgs,
 } from 'nat-types/actions/deleteKey';
 
-export const deleteKey = (params: DeleteKeyActionParams): DeleteKeyAction => ({
+export const deleteKey = (
+  args: CreateDeleteKeyActionArgs,
+): DeleteKeyAction => ({
+  ...args,
   actionType: 'DeleteKey',
-  params,
 });

package/src/helpers/actionCreators/deployContract.ts

@@ -1,13 +1,11 @@
 import type {
   DeployContractAction,
-  DeployContractActionParams,
+  CreateDeployContractActionArgs,
 } from 'nat-types/actions/deployContract';
 
 export const deployContract = (
-  params: DeployContractActionParams,
+  args: CreateDeployContractActionArgs,
 ): DeployContractAction => ({
+  ...args,
   actionType: 'DeployContract',
-  params,
 });
-
-

package/src/helpers/actionCreators/functionCall.ts

@@ -1,12 +1,24 @@
 import type {
-  FunctionCallAction,
-  FunctionCallParams,
+  CreateFunctionCallAction,
+  InnerCreateFunctionCallActionArgs,
 } from 'nat-types/actions/functionCall';
-import type { MaybeJsonLikeValue } from 'nat-types/common';
+import { toJsonBytes } from '@common/utils/common';
 
-export const functionCall = <AJ extends MaybeJsonLikeValue>(
-  params: FunctionCallParams<AJ>,
-): FunctionCallAction<AJ> => ({
-  actionType: 'FunctionCall',
-  params,
+const serializeFunctionArgs = (args: InnerCreateFunctionCallActionArgs) => {
+  if (args?.options?.serializeArgs)
+    return args.options.serializeArgs({ functionArgs: args.functionArgs });
+
+  if (args?.functionArgs) return toJsonBytes(args?.functionArgs);
+
+  return new Uint8Array();
+};
+
+export const functionCall: CreateFunctionCallAction = (
+  args: InnerCreateFunctionCallActionArgs,
+) => ({
+  actionType: 'FunctionCall' as const,
+  functionName: args.functionName,
+  gasLimit: args.gasLimit,
+  functionArgs: serializeFunctionArgs(args),
+  attachedDeposit: args.attachedDeposit,
 });

package/src/helpers/actionCreators/transfer.ts

@@ -1,9 +1,9 @@
 import type {
   TransferAction,
-  TransferActionParams,
+  CreateTransferActionArgs,
 } from 'nat-types/actions/transfer';
 
-export const transfer = (params: TransferActionParams): TransferAction => ({
+export const transfer = (args: CreateTransferActionArgs): TransferAction => ({
+  ...args,
   actionType: 'Transfer',
-  params,
 });

package/src/helpers/crypto/getPublicKey.ts

@@ -1,52 +1,20 @@
-import * as v from 'valibot';
-import type {
-  PublicKey,
-  PrivateKey,
-  Ed25519CurveString,
-  Secp256k1CurveString,
-} from 'nat-types/crypto';
 import {
   fromCurveString,
   toEd25519CurveString,
   toSecp256k1CurveString,
 } from '@common/transformers/curveString';
-import {
-  BinarySecp256k1PrivateKeySchema,
-  BinaryEd25519PrivateKeySchema,
-} from '@common/schemas/valibot/privateKey';
 import { BinaryCryptoKeyLengths } from '@common/configs/constants';
+import type { PublicKey, PrivateKey } from 'nat-types/crypto';
 
 const { Ed25519, Secp256k1 } = BinaryCryptoKeyLengths;
 
-const getBinaryEd25519PublicKey = (
-  u8Ed25519PrivateKey: Uint8Array,
-): Uint8Array => {
-  const validEd25519PrivateKey = v.parse(
-    BinaryEd25519PrivateKeySchema,
-    u8Ed25519PrivateKey,
-  );
-  return validEd25519PrivateKey.slice(Ed25519.SecretKey);
-};
-
-const getEd25519PublicKey = (u8PrivateKey: Uint8Array): Ed25519CurveString => {
-  const u8PublicKey = getBinaryEd25519PublicKey(u8PrivateKey);
+const getEd25519PublicKey = (u8PrivateKey: Uint8Array) => {
+  const u8PublicKey = u8PrivateKey.slice(Ed25519.SecretKey);
   return toEd25519CurveString(u8PublicKey);
 };
 
-const getBinarySecp256k1PublicKey = (
-  u8Secp256k1PrivateKey: Uint8Array,
-): Uint8Array => {
-  const validU8PrivateKey = v.parse(
-    BinarySecp256k1PrivateKeySchema,
-    u8Secp256k1PrivateKey,
-  );
-  return validU8PrivateKey.slice(Secp256k1.SecretKey);
-};
-
-const getSecp256k1PublicKey = (
-  u8Secp256k1PrivateKey: Uint8Array,
-): Secp256k1CurveString => {
-  const u8PublicKey = getBinarySecp256k1PublicKey(u8Secp256k1PrivateKey);
+const getSecp256k1PublicKey = (u8PrivateKey: Uint8Array) => {
+  const u8PublicKey = u8PrivateKey.slice(Secp256k1.SecretKey);
   return toSecp256k1CurveString(u8PublicKey);
 };
 

package/src/helpers/crypto/sign.ts

@@ -1,4 +1,3 @@
-import * as v from 'valibot';
 import type { PrivateKey, Signature } from 'nat-types/crypto';
 import type { Hex } from 'nat-types/common';
 import { ed25519 } from '@noble/curves/ed25519';
@@ -8,36 +7,25 @@ import {
   toEd25519CurveString,
   toSecp256k1CurveString,
 } from '@common/transformers/curveString';
-import {
-  BinarySecp256k1PrivateKeySchema,
-  BinaryEd25519PrivateKeySchema,
-} from '@common/schemas/valibot/privateKey';
 import { BinaryCryptoKeyLengths } from '@common/configs/constants';
 
-const { Ed25519, Secp256k1 } = BinaryCryptoKeyLengths;
-
-const getBinaryEd25519SecretKey = (u8PrivateKey: Uint8Array) =>
-  v
-    .parse(BinaryEd25519PrivateKeySchema, u8PrivateKey)
-    .slice(0, Ed25519.SecretKey);
-
 const signByEd25519Key = (message: Hex, u8PrivateKey: Uint8Array) => {
-  const u8SecretKey = getBinaryEd25519SecretKey(u8PrivateKey);
+  const u8SecretKey = u8PrivateKey.slice(
+    0,
+    BinaryCryptoKeyLengths.Ed25519.SecretKey,
+  );
   const u8Signature = ed25519.sign(message, u8SecretKey);
-
   return {
     signature: toEd25519CurveString(u8Signature),
     u8Signature,
   };
 };
 
-const getBinarySecp256k1SecretKey = (u8PrivateKey: Uint8Array) =>
-  v
-    .parse(BinarySecp256k1PrivateKeySchema, u8PrivateKey)
-    .slice(0, Secp256k1.SecretKey);
-
 const signBySecp256k1Key = (message: Hex, u8PrivateKey: Uint8Array) => {
-  const u8SecretKey = getBinarySecp256k1SecretKey(u8PrivateKey);
+  const u8SecretKey = u8PrivateKey.slice(
+    0,
+    BinaryCryptoKeyLengths.Secp256k1.SecretKey,
+  );
   const signatureObj = secp256k1.sign(message, u8SecretKey);
 
   const u8Signature = new Uint8Array([
@@ -51,17 +39,17 @@ const signBySecp256k1Key = (message: Hex, u8PrivateKey: Uint8Array) => {
   };
 };
 
-type SignInput = {
+type SignArgs = {
   message: Hex;
   privateKey: PrivateKey;
 };
 
-type SignOutput = {
+type SignResult = {
   signature: Signature;
   u8Signature: Uint8Array;
 };
 
-export const sign = ({ message, privateKey }: SignInput): SignOutput => {
+export const sign = ({ message, privateKey }: SignArgs): SignResult => {
   const { curve, u8Data: u8PrivateKey } = fromCurveString(privateKey);
   return curve === 'ed25519'
     ? signByEd25519Key(message, u8PrivateKey)

package/src/helpers/nearGas.ts

@@ -0,0 +1,123 @@
+import type {
+  Gas,
+  GasInputAmount,
+  NearGas,
+  NearGasArgs,
+  TeraGas,
+  TeraGasInputAmount,
+} from 'nat-types/nearGas';
+import { nodeInspectSymbol } from '@common/utils/common';
+import type { InspectOptionsStylized } from 'node:util';
+
+const TeraCoefficient = 1_000_000_000_000n; // 10 ** 12
+const NearGasBrand = Symbol('NearGasBrand');
+
+const cache = {
+  gas: new WeakMap<NearGas, Gas>(),
+  teraGas: new WeakMap<NearGas, TeraGas>(),
+};
+
+const toGas = (x: NearGasArgs | NearGas): Gas =>
+  isNearGas(x) ? x.gas : nearGas(x).gas;
+
+/**
+ * We use it as a prototype for all new NearGas instances. It allows us to reuse
+ * these functions without creating a new fn instances every time we create a new NearGas
+ */
+const nearGasProto: ThisType<NearGas> = {
+  [NearGasBrand]: true,
+  // Lazy getter - calculate the 'gas' value only after the first direct access;
+  // save the result in the cache
+  get gas(): Gas {
+    const maybeValue = cache.gas.get(this);
+    if (maybeValue) return maybeValue;
+
+    const value = BigInt(this.teraGas) * TeraCoefficient;
+    cache.gas.set(this, value);
+
+    return value;
+  },
+
+  get teraGas(): TeraGas {
+    const maybeValue = cache.teraGas.get(this);
+    if (maybeValue) return maybeValue;
+
+    const value = String(this.gas / TeraCoefficient); // We don't keep decimals
+    cache.teraGas.set(this, value);
+
+    return value;
+  },
+
+  add(x: NearGasArgs | NearGas): NearGas {
+    return gas(this.gas + toGas(x));
+  },
+
+  sub(x: NearGasArgs | NearGas): NearGas {
+    return gas(this.gas - toGas(x));
+  },
+
+  mul(x: NearGasArgs | NearGas): NearGas {
+    return gas(this.gas * toGas(x));
+  },
+
+  gt(x: NearGasArgs | NearGas): boolean {
+    return this.gas > toGas(x);
+  },
+
+  lt(x: NearGasArgs | NearGas): boolean {
+    return this.gas < toGas(x);
+  },
+
+  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 as symbol](
+      this: NearGas,
+      _depth: number,
+      _opts: InspectOptionsStylized,
+    ) {
+      return { teraGas: this.teraGas, gas: this.gas };
+    },
+  }),
+} as const;
+
+export const gas = (gasInputAmount: GasInputAmount): NearGas => {
+  const gasValue = BigInt(gasInputAmount); // TODO validate
+  const nearGas = Object.create(nearGasProto) as NearGas;
+
+  Object.defineProperty(nearGas, 'gas', {
+    value: gasValue,
+    enumerable: true,
+  });
+
+  return Object.freeze(nearGas);
+};
+
+export const teraGas = (teraGas: TeraGasInputAmount): NearGas => {
+  const nearGas = Object.create(nearGasProto) as NearGas;
+
+  Object.defineProperty(nearGas, 'teraGas', {
+    value: teraGas, // TODO Validate
+    enumerable: true,
+  });
+
+  return Object.freeze(nearGas);
+};
+
+export const nearGas = (args: NearGasArgs): NearGas => {
+  if ('teraGas' in args) return teraGas(args.teraGas);
+  if ('gas' in args) return gas(args.gas);
+  throw new Error('Invalid gas option');
+};
+
+export const isNearGas = (value: unknown): value is NearGas =>
+  typeof value === 'object' && value !== null && NearGasBrand in value;