near-api-ts 0.2.0

package/src/helpers/crypto/sign.ts

@@ -0,0 +1,69 @@
+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';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import {
+  fromCurveString,
+  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 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 signatureObj = secp256k1.sign(message, u8SecretKey);
+
+  const u8Signature = new Uint8Array([
+    ...signatureObj.toBytes(),
+    signatureObj.recovery,
+  ]);
+
+  return {
+    signature: toSecp256k1CurveString(u8Signature),
+    u8Signature,
+  };
+};
+
+type SignInput = {
+  message: Hex;
+  privateKey: PrivateKey;
+};
+
+type SignOutput = {
+  signature: Signature;
+  u8Signature: Uint8Array;
+};
+
+export const sign = ({ message, privateKey }: SignInput): SignOutput => {
+  const { curve, u8Data: u8PrivateKey } = fromCurveString(privateKey);
+  return curve === 'ed25519'
+    ? signByEd25519Key(message, u8PrivateKey)
+    : signBySecp256k1Key(message, u8PrivateKey);
+};

package/src/helpers/gas.ts

@@ -0,0 +1,25 @@
+import type { GasLimit, GasOption, GasInput, TeraGasInput } from 'nat-types/common';
+
+const TeraCoefficient = 10n ** 12n;
+
+export const gas = (gas: GasInput) => {
+  // TODO Validate
+  return {
+    gas: BigInt(gas),
+    teraGas: String(BigInt(gas) / TeraCoefficient), // We don't keep decimals here
+  };
+};
+
+export const teraGas = (teraGas: TeraGasInput) => {
+  // TODO Validate
+  return {
+    gas: BigInt(teraGas) * TeraCoefficient,
+    teraGas,
+  };
+};
+
+export const fromGasOption = (gasOption: GasOption): GasLimit => {
+  if ('teraGas' in gasOption) return teraGas(gasOption.teraGas);
+  if ('gas' in gasOption) return gas(gasOption.gas);
+  throw new Error('Invalid gas option');
+};

package/src/helpers/near.ts

@@ -0,0 +1,118 @@
+import { convertTokensToUnits } from '@common/utils/tokenConverter/convertTokensToUnits';
+import { convertUnitsToTokens } from '@common/utils/tokenConverter/convertUnitsToTokens';
+import { NearDecimals } from '@common/configs/constants';
+import { nodeInspectSymbol } from '@common/utils/common';
+import type {
+  Units,
+  Tokens,
+  NearOption,
+  NearToken,
+  Near,
+  YoctoNear,
+} from 'nat-types/common';
+import type { InspectOptionsStylized } from 'node:util';
+
+const cache = {
+  near: new WeakMap<NearToken, string>(),
+  yoctoNear: new WeakMap<NearToken, bigint>(),
+};
+
+/**
+ * We use it as a prototype for all new NearToken instances. It allows us to reuse
+ * these functions without creating a new fn instances every time we create a new NearToken
+ */
+const nearTokenProto: ThisType<NearToken> = {
+  // Lazy getter - calculate the 'near' value only after the first direct access;
+  // save the result in the cache
+  get near(): Near {
+    const maybeValue = cache.near.get(this);
+    if (maybeValue) return maybeValue;
+    const value = convertUnitsToTokens(this.yoctoNear, NearDecimals);
+    cache.near.set(this, value);
+
+    return value;
+  },
+
+  get yoctoNear(): YoctoNear {
+    const maybeValue = cache.yoctoNear.get(this);
+    if (maybeValue) return maybeValue;
+
+    const value = convertTokensToUnits(this.near, NearDecimals);
+    cache.yoctoNear.set(this, value);
+
+    return value;
+  },
+
+  // TODO add support for NearToken and avoid creating a new instance if x is NearToken
+  add(x: NearOption): NearToken {
+    return yoctoNear(this.yoctoNear + fromNearOption(x).yoctoNear);
+  },
+
+  sub(x: NearOption): NearToken {
+    return yoctoNear(this.yoctoNear - fromNearOption(x).yoctoNear);
+  },
+
+  mul(x: NearOption): NearToken {
+    return yoctoNear(this.yoctoNear * fromNearOption(x).yoctoNear);
+  },
+
+  gt(x: NearOption): boolean {
+    return this.yoctoNear > fromNearOption(x).yoctoNear;
+  },
+
+  lt(x: NearOption): boolean {
+    return this.yoctoNear < fromNearOption(x).yoctoNear;
+  },
+
+  toString() {
+    return JSON.stringify({
+      near: this.near,
+      yoctoNear: this.yoctoNear.toString(),
+    });
+  },
+
+  // In Node.js, this allows you to see the near/yoctoNear getter values,
+  // which are not normally visible unless you access them directly.
+  // This does not work in the browser — there you can only see a getter’s value
+  // by explicitly expanding/clicking on it.
+  ...(nodeInspectSymbol && {
+    [nodeInspectSymbol as symbol](
+      this: NearToken,
+      _depth: number,
+      _opts: InspectOptionsStylized,
+    ) {
+      return { near: this.near, yoctoNear: this.yoctoNear };
+    },
+  }),
+} as const;
+
+export const yoctoNear = (units: Units): NearToken => {
+  // TODO validate units
+  const yoctoNear = BigInt(units);
+  const obj = Object.create(nearTokenProto) as NearToken;
+
+  Object.defineProperty(obj, 'yoctoNear', {
+    value: yoctoNear,
+    enumerable: true,
+  });
+
+  return Object.freeze(obj);
+};
+
+export const near = (tokens: Tokens): NearToken => {
+  // TODO validate tokens
+  const obj = Object.create(nearTokenProto) as NearToken;
+
+  Object.defineProperty(obj, 'near', {
+    value: tokens,
+    enumerable: true,
+  });
+
+  return Object.freeze(obj);
+};
+
+export const fromNearOption = (nearOption: NearOption): NearToken => {
+  if ('yoctoNear' in nearOption) return yoctoNear(nearOption.yoctoNear);
+  if ('near' in nearOption) return near(nearOption.near);
+  throw new Error('Invalid nearOption format');
+};

package/src/index.ts

@@ -0,0 +1,19 @@
+// Client
+export { createClient } from './client/createClient/createClient';
+export { testnet, mainnet } from './client/presets/networks';
+// Key Services
+export { createMemoryKeyService } from './keyServices/memoryKeyService/createMemoryKeyService';
+// Signers
+export { createMemorySigner } from './signers/memorySigner/createMemorySigner';
+// Action Creators
+export { transfer } from './helpers/actionCreators/transfer';
+export { createAccount } from './helpers/actionCreators/createAccount';
+export { addFullAccessKey } from './helpers/actionCreators/addFullAccessKey';
+export { addFunctionCallKey } from './helpers/actionCreators/addFunctionCallKey';
+export { functionCall } from './helpers/actionCreators/functionCall';
+export { deleteKey } from './helpers/actionCreators/deleteKey';
+export { deleteAccount } from './helpers/actionCreators/deleteAccount';
+export { deployContract } from './helpers/actionCreators/deployContract';
+// Helpers
+export { near, yoctoNear } from './helpers/near';
+export { gas, teraGas } from './helpers/gas';

package/src/keyServices/memoryKeyService/createFindPrivateKey.ts

@@ -0,0 +1,11 @@
+import type { KeyPairs } from 'nat-types/keyServices/memoryKeyService';
+import type { PublicKey } from 'nat-types/crypto';
+
+export const createFindPrivateKey =
+  (keyPairs: KeyPairs) => (publicKey: PublicKey) => {
+    const privateKey = keyPairs[publicKey];
+    if (keyPairs[publicKey]) return privateKey;
+    throw new Error(
+      `Cannot find a corresponding private key for '${publicKey}'`,
+    );
+  };

package/src/keyServices/memoryKeyService/createMemoryKeyService.ts

@@ -0,0 +1,23 @@
+import { createSignTransaction } from './createSignTransaction';
+import { parseKeySources } from './parseKeySources';
+import { createFindPrivateKey } from './createFindPrivateKey';
+import type {
+  Context,
+  MemoryKeyService,
+  CreateMemoryKeyServiceInput,
+} from 'nat-types/keyServices/memoryKeyService';
+
+export const createMemoryKeyService = async (
+  params: CreateMemoryKeyServiceInput,
+): Promise<MemoryKeyService> => {
+  const context: Context = {
+    keyPairs: parseKeySources(params),
+  } as Context;
+
+  context.findPrivateKey = createFindPrivateKey(context.keyPairs);
+
+  return {
+    signTransaction: createSignTransaction(context),
+    getKeyPairs: () => context.keyPairs,
+  };
+};

package/src/keyServices/memoryKeyService/createSignTransaction.ts

@@ -0,0 +1,24 @@
+import { getTransactionHash } from '../../helpers/crypto/getTransactionHash';
+import { sign } from '../../helpers/crypto/sign';
+import type {
+  Context,
+  SignTransaction,
+} from 'nat-types/keyServices/memoryKeyService';
+
+export const createSignTransaction =
+  (context: Context): SignTransaction =>
+  async (transaction) => {
+    // TODO Implement validation
+    const privateKey = context.findPrivateKey(transaction.signerPublicKey);
+
+    const { transactionHash, u8TransactionHash } =
+      getTransactionHash(transaction);
+
+    const { signature } = sign({ message: u8TransactionHash, privateKey });
+
+    return {
+      transaction,
+      transactionHash,
+      signature,
+    };
+  };

package/src/keyServices/memoryKeyService/parseKeySources.ts

@@ -0,0 +1,49 @@
+import { getPublicKey } from '../../helpers/crypto/getPublicKey';
+import type {
+  KeyPairs,
+  KeySource,
+  CreateMemoryKeyServiceInput,
+} from 'nat-types/keyServices/memoryKeyService';
+import type { PrivateKey, PublicKey } from 'nat-types/crypto';
+
+const parseKeySource = (
+  keySource: KeySource,
+): { publicKey: PublicKey; privateKey: PrivateKey } => {
+  if ('privateKey' in keySource) {
+    return {
+      publicKey: getPublicKey(keySource.privateKey),
+      privateKey: keySource.privateKey,
+    };
+  }
+
+  // TODO implement
+  if ('seedPhrase' in keySource) {
+    return {
+      publicKey: 'ed25519:213',
+      privateKey: 'ed25519:213',
+    };
+  }
+
+  throw new Error('Unknown keySource');
+};
+
+export const parseKeySources = (
+  params: CreateMemoryKeyServiceInput,
+): KeyPairs => {
+  if (params.keySource) {
+    const { publicKey, privateKey } = parseKeySource(params.keySource);
+    return { [publicKey]: privateKey };
+  }
+
+  if (params.keySources)
+    return Object.fromEntries(
+      params.keySources.map((keySource) => {
+        const { publicKey, privateKey } = parseKeySource(keySource);
+        return [publicKey, privateKey];
+      }),
+    );
+
+  throw new Error(
+    'Cannot create MemoryKeyService - no private keys were found',
+  );
+};

package/src/signers/memorySigner/createMemorySigner.ts

@@ -0,0 +1,35 @@
+import { createKeyPool } from './keyPool/createKeyPool';
+import { createTaskQueue } from './taskQueue/createTaskQueue';
+import { createMatcher } from './matcher/createMatcher';
+import { createResolver } from './resolver/createResolver';
+import { createState } from './state/createState';
+import { SignerTaskTtlMs } from '@common/configs/constants';
+import type { CreateMemorySigner } from 'nat-types/signers/memorySigner';
+
+export const createMemorySigner: CreateMemorySigner = async (args) => {
+  const context: any = {
+    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,
+  };
+};

package/src/signers/memorySigner/executors/executeTransaction.ts

@@ -0,0 +1,30 @@
+import { getSignedTransaction } from './helpers/getSignedTransaction';
+
+export const executeTransaction = async (
+  signerContext: any,
+  task: any,
+  key: any,
+) => {
+  try {
+    const nextNonce = key.nonce + 1;
+
+    const signedTransaction = getSignedTransaction(
+      signerContext,
+      task,
+      key,
+      nextNonce,
+    );
+
+    const result = await signerContext.client.sendSignedTransaction({
+      signedTransaction,
+    });
+
+    key.incrementNonce();
+
+    signerContext.resolver.completeTask(task.taskId, {
+      result,
+    });
+  } catch (e) {
+    signerContext.resolver.completeTask(task.taskId, { error: e });
+  }
+};

package/src/signers/memorySigner/executors/helpers/getSignedTransaction.ts

@@ -0,0 +1,32 @@
+import { getTransactionHash } from '../../../../helpers/crypto/getTransactionHash';
+import { sign } from '../../../../helpers/crypto/sign';
+import type { SignedTransaction } from 'nat-types/signedTransaction';
+
+export const getSignedTransaction = (
+  signerContext: any,
+  task: any,
+  key: any,
+  nextNonce: bigint,
+): SignedTransaction => {
+  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,
+  };
+};

package/src/signers/memorySigner/executors/signTransaction.ts

@@ -0,0 +1,26 @@
+import { getSignedTransaction } from './helpers/getSignedTransaction';
+
+export const signTransaction = async (
+  signerContext: any,
+  task: any,
+  key: any,
+) => {
+  try {
+    const nextNonce = key.nonce + 1;
+
+    const signedTransaction = getSignedTransaction(
+      signerContext,
+      task,
+      key,
+      nextNonce,
+    );
+
+    key.incrementNonce();
+
+    signerContext.resolver.completeTask(task.taskId, {
+      result: signedTransaction,
+    });
+  } catch (e) {
+    signerContext.resolver.completeTask(task.taskId, { error: e });
+  }
+};

package/src/signers/memorySigner/keyPool/createFindKeyForTask.ts

@@ -0,0 +1,27 @@
+const findSigningKey = (keyPriority: any, keyList: any) => {
+  if (keyPriority.type === 'FullAccess') {
+    return keyList.fullAccess.find((key: any) => !key.isLocked);
+  }
+
+  // If keyType is FunctionCall - find the key which follows all criteria
+  return keyList.functionCall.find((key: any) => {
+    const isUnlocked = key.isLocked === false;
+
+    const isContractIdMatch =
+      key.contractAccountId === keyPriority.contractAccountId;
+
+    // No allowedFunctions means that the key can call every contract function
+    const isFnCallAllowed =
+      key.allowedFunctions === undefined ||
+      key.allowedFunctions.includes(keyPriority.calledFnName);
+
+    return isUnlocked && isContractIdMatch && isFnCallAllowed;
+  });
+};
+
+export const createFindKeyForTask = (keyList: any) => (task: any) => {
+  for (const keyPriority of task.signingKeyPriority) {
+    const key = findSigningKey(keyPriority, keyList);
+    if (key) return key;
+  }
+};

package/src/signers/memorySigner/keyPool/createIsKeyForTaskExist.ts

@@ -0,0 +1,22 @@
+const isKeyExist = (keyPriority: any, keyList: any) => {
+  // If exists at least 1 FA key - return true
+  if (keyPriority.type === 'FullAccess') return keyList.fullAccess.length > 0;
+
+  // If keyType is FunctionCall - find the key which follows all criteria
+  return keyList.functionCall.find((key: any) => {
+    const isContractIdMatch =
+      key.contractAccountId === keyPriority.contractAccountId;
+
+    // No allowedFunctions means that the key can call every contract function
+    const isFnCallAllowed =
+      key.allowedFunctions === undefined ||
+      key.allowedFunctions.includes(keyPriority.calledFnName);
+
+    return isContractIdMatch && isFnCallAllowed;
+  });
+};
+
+export const createIsKeyForTaskExist = (keyList: any) => (task: any) =>
+  task.signingKeyPriority.some((keyPriority: any) =>
+    isKeyExist(keyPriority, keyList),
+  );

package/src/signers/memorySigner/keyPool/createKeyPool.ts

@@ -0,0 +1,37 @@
+import { createFindKeyForTask } from './createFindKeyForTask';
+import { createIsKeyForTaskExist } from './createIsKeyForTaskExist';
+import { getFullAccessKeyList } from './getFullAccessKeyList';
+import { getFunctionCallKeyList } from './getFunctionCallKeyList';
+import type { SignerContext } from 'nat-types/signers/memorySigner';
+import type { AccountKey } from 'nat-types/accountKey';
+
+const getAllowedSigningKeys = (
+  signerContext: SignerContext,
+  accountKeys: AccountKey[],
+) => {
+  if (!signerContext.signingKeys) return accountKeys;
+  const set = new Set(signerContext.signingKeys);
+  return accountKeys.filter((key) => set.has(key.publicKey));
+};
+
+export const createKeyPool = async (signerContext: SignerContext) => {
+  const { accountKeys } = await signerContext.client.getAccountKeys({
+    accountId: signerContext.signerAccountId,
+  });
+
+  // If the user want to handle all tasks only by a specific key - remove others
+  const filteredKeys = getAllowedSigningKeys(signerContext, accountKeys);
+
+  const keyList = {
+    fullAccess: getFullAccessKeyList(filteredKeys, signerContext),
+    functionCall: getFunctionCallKeyList(filteredKeys, signerContext),
+  };
+
+  if (keyList.fullAccess.length === 0 && keyList.functionCall.length === 0)
+    throw new Error('Cannot create a signer with no account keys');
+
+  return {
+    findKeyForTask: createFindKeyForTask(keyList),
+    isKeyForTaskExist: createIsKeyForTaskExist(keyList),
+  };
+};

package/src/signers/memorySigner/keyPool/getFullAccessKeyList.ts

@@ -0,0 +1,39 @@
+import {
+  createUnlock,
+  createLock,
+  createIncrementNonce,
+} from './helpers/keyUtils';
+import type { AccountKey, FullAccessKey } from 'nat-types/accountKey';
+import type { SignerContext } from 'nat-types/signers/memorySigner';
+import type { KeyPairs } from 'nat-types/keyServices/memoryKeyService';
+
+const transformKey = (fullAccessKey: FullAccessKey, keyPairs: KeyPairs) => {
+  const { publicKey, nonce } = fullAccessKey;
+
+  const key: any = {
+    type: 'FullAccess',
+    publicKey,
+    privateKey: keyPairs[publicKey],
+    isLocked: false,
+    nonce,
+  };
+  key.lock = createLock(key);
+  key.unlock = createUnlock(key);
+  key.incrementNonce = createIncrementNonce(key);
+
+  return key;
+};
+
+export const getFullAccessKeyList = (
+  accountKeys: AccountKey[],
+  signerContext: SignerContext,
+) => {
+  const keyPairs = signerContext.keyService.getKeyPairs();
+
+  return accountKeys
+    .filter(
+      ({ publicKey, accessType }) =>
+        Object.hasOwn(keyPairs, publicKey) && accessType === 'FullAccess',
+    )
+    .map((key) => transformKey(key as FullAccessKey, keyPairs));
+};

package/src/signers/memorySigner/keyPool/getFunctionCallKeyList.ts

@@ -0,0 +1,43 @@
+import {
+  createIncrementNonce,
+  createLock,
+  createUnlock,
+} from './helpers/keyUtils';
+import type { AccountKey, FunctionCallKey } from 'nat-types/accountKey';
+import type { SignerContext } from 'nat-types/signers/memorySigner';
+import type { KeyPairs } from 'nat-types/keyServices/memoryKeyService';
+
+const transformKey = (functionCallKey: FunctionCallKey, keyPairs: KeyPairs) => {
+  const { publicKey, nonce, contractAccountId, allowedFunctions } =
+    functionCallKey;
+
+  const key: any = {
+    type: 'FunctionCall', // TODO Rename to accessType
+    publicKey,
+    privateKey: keyPairs[publicKey],
+    isLocked: false,
+    nonce,
+    contractAccountId,
+    allowedFunctions,
+  };
+
+  key.lock = createLock(key);
+  key.unlock = createUnlock(key);
+  key.incrementNonce = createIncrementNonce(key);
+
+  return key;
+};
+
+export const getFunctionCallKeyList = (
+  accountKeys: AccountKey[],
+  signerContext: SignerContext,
+) => {
+  const keyPairs = signerContext.keyService.getKeyPairs();
+
+  return accountKeys
+    .filter(
+      ({ publicKey, accessType }) =>
+        Object.hasOwn(keyPairs, publicKey) && accessType === 'FunctionCall',
+    )
+    .map((key) => transformKey(key as FunctionCallKey, keyPairs));
+};

package/src/signers/memorySigner/keyPool/helpers/keyUtils.ts

@@ -0,0 +1,13 @@
+export const createLock = (key: any) => () => {
+  key.isLocked = true;
+  console.log('Key locked', key.publicKey);
+};
+
+export const createUnlock = (key: any) => () => {
+  key.isLocked = false;
+  console.log('Key unlocked', key.publicKey);
+};
+
+export const createIncrementNonce = (key: any) => () => {
+  key.nonce = key.nonce + 1;
+};