@swapkit/toolboxes 4.3.10 → 4.13.2

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

@@ -1,70 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { JsonRpcProvider } from "@near-js/providers";
-import { AssetValue, Chain, getRPCUrl } from "@swapkit/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

@@ -1,85 +0,0 @@
-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 "@swapkit/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

@@ -1,96 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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";