@uswap/toolboxes 4.3.6

package/src/near/__tests__/core.test.ts

@@ -0,0 +1,70 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { JsonRpcProvider } from "@near-js/providers";
+import { AssetValue, Chain, getRPCUrl } from "@uswap/helpers";
+import { getFullAccessPublicKey } from "../helpers/core";
+import { getNearToolbox } from "../toolbox";
+
+const accountId = "ea03292d08136cca439513a33c76af083e5204eceb4ce720320fff84071a447f";
+
+const context: { provider: JsonRpcProvider; toolbox: Awaited<ReturnType<typeof getNearToolbox>> } = {} as any;
+
+beforeAll(async () => {
+  const rpcUrl = await getRPCUrl(Chain.Near);
+  context.provider = new JsonRpcProvider({ url: rpcUrl });
+});
+
+beforeEach(async () => {
+  context.toolbox = await getNearToolbox();
+});
+
+describe("NEAR createTransaction", () => {
+  test("should retrieve full access public key for valid account", async () => {
+    const toolbox = context.toolbox;
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({ chain: Chain.Near, value: "0.001" }),
+      recipient: accountId,
+      sender: accountId,
+    });
+
+    expect(transaction).toBeDefined();
+    expect(transaction.publicKey).toBeDefined();
+  }, 30000);
+
+  test("should throw error for invalid account", async () => {
+    const provider = context.provider;
+    const invalidAccountId = "non-existent-account-12345.testnet";
+
+    await expect(async () => {
+      await getFullAccessPublicKey(provider, invalidAccountId);
+    }).toThrow();
+  }, 10000);
+
+  test("should handle network errors gracefully", async () => {
+    const invalidProvider = new JsonRpcProvider({ url: "https://invalid-rpc-url.test" });
+
+    await expect(async () => {
+      await getFullAccessPublicKey(invalidProvider, "any-account.testnet");
+    }).toThrow();
+  }, 10000);
+
+  test("should work with contract function call transaction", async () => {
+    const toolbox = context.toolbox;
+    const provider = context.provider;
+
+    const contractTransaction = await toolbox.createContractFunctionCall({
+      args: { account_id: accountId },
+      attachedDeposit: "1250000000000000000000",
+      contractId: "wrap.testnet",
+      gas: "300000000000000",
+      methodName: "storage_deposit",
+      sender: accountId,
+    });
+
+    expect(contractTransaction).toBeDefined();
+    expect(contractTransaction.publicKey).toBeDefined();
+
+    const { publicKey } = await getFullAccessPublicKey(provider, accountId);
+    expect(publicKey.toString()).toBe(contractTransaction.publicKey.toString());
+  }, 30000);
+});

package/src/near/helpers/core.ts

@@ -0,0 +1,85 @@
+import type { KeyPair } from "@near-js/crypto";
+import type { Provider } from "@near-js/providers";
+import { KeyPairSigner } from "@near-js/signers";
+import { type DerivationPathArray, derivationPathToString, SwapKitError } from "@uswap/helpers";
+import type { NearSigner } from "../types";
+
+export async function getValidateNearAddress() {
+  const { validateAccountId } = await import("near-sdk-js");
+  return (address: string) => {
+    // Use the official NEAR SDK validation function if available
+    try {
+      return validateAccountId(address);
+    } catch {
+      const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+
+      return address.length >= 2 && address.length <= 64 && ACCOUNT_ID_REGEX.test(address);
+    }
+  };
+}
+
+export async function getNearSignerFromPhrase(params: {
+  phrase: string;
+  derivationPath?: DerivationPathArray;
+  index?: number;
+}) {
+  const { parseSeedPhrase } = await import("near-seed-phrase");
+  const { KeyPair } = await import("@near-js/crypto");
+
+  const index = params.index || 0;
+  const derivationPath = params.derivationPath
+    ? derivationPathToString(params.derivationPath.slice(0, 3) as [number, number, number])
+    : `m/44'/397'/${index}'`;
+
+  const { secretKey } = parseSeedPhrase(params.phrase, derivationPath);
+  const keyPair = KeyPair.fromString(secretKey as any);
+
+  return createNearSignerFromKeyPair(keyPair);
+}
+
+export async function getNearSignerFromPrivateKey(privateKey: string) {
+  const { KeyPair } = await import("@near-js/crypto");
+  const keyPair = KeyPair.fromString(privateKey as any);
+  return createNearSignerFromKeyPair(keyPair);
+}
+
+class SKKeyPairSigner extends KeyPairSigner {
+  #keyPair: KeyPair;
+
+  constructor(keyPair: KeyPair) {
+    super(keyPair);
+    this.#keyPair = keyPair;
+  }
+
+  getAddress(): Promise<string> {
+    const publicKey = this.#keyPair.getPublicKey();
+    const hexAddress = Buffer.from(publicKey.data).toString("hex");
+    return Promise.resolve(hexAddress);
+  }
+}
+
+function createNearSignerFromKeyPair(keyPair: KeyPair): NearSigner {
+  const keyPairSigner = new SKKeyPairSigner(keyPair);
+
+  return keyPairSigner;
+}
+
+export async function getFullAccessPublicKey(provider: Provider, accountId: string) {
+  const response = await provider.query({
+    account_id: accountId,
+    finality: "final",
+    request_type: "view_access_key_list",
+  });
+
+  const fullAccessKey = (response as any).keys.find((key: any) => key.access_key.permission === "FullAccess");
+
+  if (!fullAccessKey) {
+    throw new SwapKitError("toolbox_near_no_public_key_found");
+  }
+  const { PublicKey } = await import("@near-js/crypto");
+
+  const publicKey = PublicKey.fromString(fullAccessKey.public_key);
+  const nonce = (fullAccessKey.access_key.nonce as number) || 0;
+
+  return { nonce, publicKey };
+}

package/src/near/helpers/gasEstimation.ts

@@ -0,0 +1,96 @@
+import type { Account } from "@near-js/accounts";
+import type { NearGasEstimateParams } from "../types/contract";
+
+export const GAS_COSTS = {
+  ACCESS_KEY_ADDITION: "5",
+  ACCESS_KEY_DELETION: "5",
+  ACCOUNT_CREATION: "30",
+  CONTRACT_CALL: "150",
+  CONTRACT_DEPLOYMENT: "200",
+  SIMPLE_TRANSFER: "1",
+  STAKE: "10",
+  STORAGE_DEPOSIT: "150",
+  TOKEN_TRANSFER: "150",
+} as const;
+
+export function isSimpleTransfer(params: NearGasEstimateParams): params is { recipient: string; amount: string } {
+  return "recipient" in params && "amount" in params && !("contractId" in params);
+}
+
+export function isContractCall(
+  params: NearGasEstimateParams,
+): params is { contractId: string; methodName: string; args?: Record<string, any>; attachedDeposit?: string } {
+  return "contractId" in params && "methodName" in params;
+}
+
+export function isBatchTransaction(params: NearGasEstimateParams): params is { actions: any[] } {
+  return "actions" in params;
+}
+
+export function isAccountCreation(
+  params: NearGasEstimateParams,
+): params is { newAccountId: string; publicKey?: string } {
+  return "newAccountId" in params;
+}
+
+export function isContractDeployment(params: NearGasEstimateParams): params is { contractCode: Uint8Array } {
+  return "contractCode" in params;
+}
+
+export function isCustomEstimator(
+  params: NearGasEstimateParams,
+): params is { customEstimator: (account: Account) => Promise<string> } {
+  return "customEstimator" in params;
+}
+
+export function estimateBatchGas(actions: any[]) {
+  let totalGas = 0;
+
+  for (const action of actions) {
+    switch (action.enum) {
+      case "transfer":
+        totalGas += Number(GAS_COSTS.SIMPLE_TRANSFER);
+        break;
+      case "functionCall":
+        totalGas += Number(GAS_COSTS.CONTRACT_CALL);
+        break;
+      case "createAccount":
+        totalGas += Number(GAS_COSTS.ACCOUNT_CREATION);
+        break;
+      case "deployContract":
+        totalGas += Number(GAS_COSTS.CONTRACT_DEPLOYMENT);
+        break;
+      case "addKey":
+        totalGas += Number(GAS_COSTS.ACCESS_KEY_ADDITION);
+        break;
+      case "deleteKey":
+        totalGas += Number(GAS_COSTS.ACCESS_KEY_DELETION);
+        break;
+      case "stake":
+        totalGas += Number(GAS_COSTS.STAKE);
+        break;
+      default:
+        totalGas += Number(GAS_COSTS.CONTRACT_CALL);
+    }
+  }
+
+  return totalGas.toString();
+}
+
+export function getContractMethodGas(methodName: string) {
+  if (methodName === "ft_transfer" || methodName === "ft_transfer_call") {
+    return GAS_COSTS.TOKEN_TRANSFER;
+  }
+  if (methodName === "storage_deposit") {
+    return GAS_COSTS.STORAGE_DEPOSIT;
+  }
+  return GAS_COSTS.CONTRACT_CALL;
+}
+
+export function tgasToGas(tgas: string): string {
+  return (BigInt(tgas) * BigInt(10 ** 12)).toString();
+}
+
+export function gasToTGas(gas: string): string {
+  return (BigInt(gas) / BigInt(10 ** 12)).toString();
+}

package/src/near/helpers/nep141.ts

@@ -0,0 +1,50 @@
+import type { Account, Contract } from "@near-js/accounts";
+
+export interface NEP141Metadata {
+  spec: string;
+  name: string;
+  symbol: string;
+  icon?: string;
+  reference?: string;
+  reference_hash?: string;
+  decimals: number;
+}
+
+export interface StorageBalance {
+  total: string;
+  available: string;
+}
+
+export interface StorageBalanceBounds {
+  min: string;
+  max?: string;
+}
+
+export type NEP141Token = {
+  transfer: (receiverId: string, amount: string, memo?: string) => Promise<void>;
+  transferCall: (receiverId: string, amount: string, msg: string, memo?: string) => Promise<void>;
+  balanceOf: (accountId: string) => Promise<string>;
+  totalSupply: () => Promise<string>;
+  metadata: () => Promise<NEP141Metadata>;
+  storageBalanceOf: (accountId: string) => Promise<StorageBalance | null>;
+  storageDeposit: (accountId?: string, amount?: string) => Promise<StorageBalance>;
+  ensureStorage: (accountId: string) => Promise<void>;
+  contract: Contract;
+};
+
+// Create a Near contract instance
+export async function createNearContract<T extends Contract>({
+  account,
+  contractId,
+  viewMethods,
+  changeMethods,
+}: {
+  account: Account;
+  contractId: string;
+  viewMethods: string[];
+  changeMethods: string[];
+}) {
+  const { Contract } = await import("@near-js/accounts");
+
+  return new Contract(account, contractId, { changeMethods, useLocalViewExecution: true, viewMethods }) as T;
+}

package/src/near/index.ts

@@ -0,0 +1,21 @@
+import type { getNearToolbox } from "./toolbox";
+
+export * from "./helpers/core";
+export * from "./helpers/gasEstimation";
+export * from "./helpers/nep141";
+export * from "./toolbox";
+export * from "./types";
+
+export type NearWallet = Awaited<ReturnType<typeof getNearToolbox>>;
+
+export type {
+  NearCallParams,
+  NearContractInterface,
+  NearGasEstimateParams,
+} from "./types/contract";
+export type {
+  FungibleTokenMetadata,
+  StorageBalance,
+  StorageBalanceBounds,
+  TokenTransferParams,
+} from "./types/nep141";