@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/near/toolbox.ts

@@ -1,509 +0,0 @@
-import {
-  AssetValue,
-  BaseDecimal,
-  Chain,
-  type DerivationPathArray,
-  SKConfig,
-  SwapKitError,
-} from "@swapkit/helpers";
-import type { Account } from "near-api-js";
-import type { SignedTransaction, Transaction } from "near-api-js/lib/transaction";
-import {
-  getFullAccessPublicKey,
-  getNearSignerFromPhrase,
-  getNearSignerFromPrivateKey,
-  getValidateNearAddress,
-} from "./helpers";
-import {
-  GAS_COSTS,
-  estimateBatchGas,
-  getContractMethodGas,
-  isAccountCreation,
-  isBatchTransaction,
-  isContractCall,
-  isContractDeployment,
-  isCustomEstimator,
-  isSimpleTransfer,
-} from "./helpers/gasEstimation";
-import { createNEP141Token } from "./helpers/nep141";
-import type {
-  NearCreateTransactionParams,
-  NearFunctionCallParams,
-  NearToolboxParams,
-  NearTransferParams,
-} from "./types";
-import type { NearContractInterface, NearGasEstimateParams } from "./types/contract";
-
-export async function getNearToolbox(toolboxParams?: NearToolboxParams) {
-  const { P, match } = await import("ts-pattern");
-  const { providers } = await import("near-api-js");
-  const signer = await match(toolboxParams)
-    .with({ phrase: P.string }, async (params) => {
-      const signer = await getNearSignerFromPhrase(params);
-      return signer;
-    })
-    .with({ signer: P.any }, ({ signer }) => signer)
-    .otherwise(() => undefined);
-
-  const url = SKConfig.get("rpcUrls")[Chain.Near];
-
-  const provider = new providers.JsonRpcProvider({ url });
-
-  async function getAccount(address?: string) {
-    const { Account } = await import("near-api-js");
-
-    const _address = address || (await getAddress());
-
-    const account = new Account(_address, provider, signer);
-
-    return account;
-  }
-
-  async function getAddress() {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
-    const address = await signer.getAddress();
-    return address;
-  }
-
-  async function transfer(params: NearTransferParams) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
-
-    const { recipient, assetValue } = params;
-
-    const nearValidateAddress = await getValidateNearAddress();
-
-    if (!nearValidateAddress(recipient)) {
-      throw new SwapKitError("toolbox_near_invalid_address");
-    }
-
-    const account = await getAccount();
-
-    if (assetValue.isGasAsset === false) {
-      // NEP-141 token transfer
-      const contractId = assetValue.address;
-      if (!contractId) {
-        throw new SwapKitError("toolbox_near_missing_contract_address");
-      }
-
-      const amount = assetValue.getBaseValue("string");
-
-      return callFunction({
-        contractId,
-        methodName: "ft_transfer",
-        args: {
-          receiver_id: recipient,
-          amount,
-          memo: params.memo,
-        },
-      });
-    }
-
-    try {
-      const transferAmount = assetValue.getBaseValue("string");
-
-      const result = await account.transfer({
-        receiverId: recipient,
-        amount: transferAmount,
-      });
-
-      return result.transaction_outcome.id;
-    } catch (error) {
-      throw new SwapKitError("toolbox_near_transfer_failed", { error });
-    }
-  }
-
-  async function createTransaction(params: NearCreateTransactionParams) {
-    const { recipient, assetValue, memo, feeRate: gas, attachedDeposit, sender: signerId } = params;
-    const validateNearAddress = await getValidateNearAddress();
-
-    if (!validateNearAddress(recipient)) {
-      throw new SwapKitError("toolbox_near_invalid_address", { address: recipient });
-    }
-
-    if (!validateNearAddress(signerId)) {
-      throw new SwapKitError("toolbox_near_invalid_address", { address: signerId });
-    }
-
-    // Handle NEP-141 token transfers
-    if (!assetValue.isGasAsset) {
-      const contractId = assetValue.address;
-      if (!contractId) {
-        throw new SwapKitError("toolbox_near_missing_contract_address");
-      }
-
-      return createContractFunctionCall({
-        sender: signerId,
-        contractId,
-        methodName: "ft_transfer",
-        args: {
-          receiver_id: recipient,
-          amount: assetValue.getBaseValue("string"),
-          memo: memo || null,
-        },
-        gas: gas.toString() || "100000000000000", // 100 TGas default
-        attachedDeposit: "1", // 1 yoctoNEAR required for NEP-141 transfers
-      });
-    }
-
-    // Native NEAR transfer
-    const { publicKey, nonce } = await getFullAccessPublicKey(provider, signerId);
-    const baseAmount = assetValue.getBaseValue("bigint");
-
-    const { SCHEMA } = await import("near-api-js/lib/transaction");
-    const { transactions, utils } = await import("near-api-js");
-
-    const txActions = [transactions.transfer(baseAmount)];
-
-    if (memo && attachedDeposit) {
-      txActions.push(
-        transactions.functionCall("memo", { memo }, BigInt(gas), BigInt(attachedDeposit)),
-      );
-    }
-
-    const block = await provider.block({ finality: "final" });
-    const blockHash = utils.serialize.base_decode(block.header.hash);
-
-    const transaction = transactions.createTransaction(
-      signerId,
-      publicKey,
-      recipient,
-      nonce,
-      txActions,
-      blockHash,
-    );
-
-    const serializedTx = utils.serialize.serialize(SCHEMA.Transaction, transaction);
-    const serializedBase64 = Buffer.from(serializedTx).toString("base64");
-
-    return {
-      serialized: serializedBase64,
-      publicKey: publicKey.toString(),
-      details: {
-        signerId,
-        nonce: nonce,
-        blockHash: utils.serialize.base_encode(blockHash),
-      },
-    };
-  }
-
-  async function createContractFunctionCall(params: {
-    sender: string;
-    contractId: string;
-    methodName: string;
-    args: any;
-    gas: string;
-    attachedDeposit: string;
-  }) {
-    const { sender: accountId } = params;
-
-    const { publicKey, nonce } = await getFullAccessPublicKey(provider, accountId);
-
-    const { SCHEMA } = await import("near-api-js/lib/transaction");
-    const { transactions, utils } = await import("near-api-js");
-    const block = await provider.block({ finality: "final" });
-    const blockHash = utils.serialize.base_decode(block.header.hash);
-
-    const actions = [
-      transactions.functionCall(
-        params.methodName,
-        Buffer.from(JSON.stringify(params.args)),
-        BigInt(params.gas),
-        BigInt(params.attachedDeposit),
-      ),
-    ];
-
-    const transaction = transactions.createTransaction(
-      accountId,
-      publicKey,
-      params.contractId,
-      nonce,
-      actions,
-      blockHash,
-    );
-
-    const serializedTx = utils.serialize.serialize(SCHEMA.Transaction, transaction);
-    const serializedBase64 = Buffer.from(serializedTx).toString("base64");
-
-    return {
-      serialized: serializedBase64,
-      publicKey: publicKey.toString(),
-      details: {
-        signerId: accountId,
-        receiverId: params.contractId,
-        methodName: params.methodName,
-        nonce: nonce,
-        blockHash: utils.serialize.base_encode(blockHash),
-      },
-    };
-  }
-
-  async function signTransaction(transaction: Transaction) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
-
-    // Use the new signer interface method
-    const [_hash, signedTx] = await signer.signTransaction(transaction);
-    return signedTx;
-  }
-
-  async function broadcastTransaction(signedTransaction: SignedTransaction) {
-    const result = await provider.sendTransaction(signedTransaction);
-    return result.transaction.hash;
-  }
-
-  async function estimateTransactionFee(params: NearTransferParams | NearGasEstimateParams) {
-    if ("assetValue" in params) {
-      const baseTransferCost = "115123062500"; // gas units for transfer
-      const receiptCreationCost = "108059500000"; // gas units for receipt
-
-      const totalGasUnits = BigInt(baseTransferCost) + BigInt(receiptCreationCost);
-
-      const gasPrice = await getCurrentGasPrice();
-
-      // NEAR doesn't support fee multipliers - gas price is fixed by the network
-      const totalCostYocto = totalGasUnits * BigInt(gasPrice.toString());
-
-      return AssetValue.from({
-        chain: Chain.Near,
-        value: totalCostYocto.toString(),
-        fromBaseDecimal: BaseDecimal[Chain.Near],
-      });
-    }
-
-    // Handle new gas estimation params
-    const account = signer ? await getAccount() : undefined;
-    return estimateGas(params, account);
-  }
-
-  async function getCurrentGasPrice() {
-    try {
-      const result = await provider.query({
-        request_type: "call_function",
-        finality: "final",
-        account_id: "system",
-        method_name: "gas_price",
-        args_base64: "",
-      });
-
-      return result;
-    } catch {
-      return "100000000"; // 0.0001 NEAR per Tgas
-    }
-  }
-
-  async function createSubAccount(subAccountId: string, publicKey: string, initialBalance: string) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
-
-    const account = await getAccount();
-    const { utils } = await import("near-api-js");
-
-    const balanceInYocto = utils.format.parseNearAmount(initialBalance) || "0";
-
-    const result = await account.createAccount(
-      subAccountId,
-      utils.PublicKey.fromString(publicKey),
-      BigInt(balanceInYocto),
-    );
-
-    return result.transaction.hash;
-  }
-
-  async function callFunction(params: NearFunctionCallParams) {
-    try {
-      if (!signer) {
-        throw new SwapKitError("toolbox_near_no_signer");
-      }
-
-      const { transactions } = await import("near-api-js");
-
-      const { contractId, methodName, args, deposit } = params;
-      const account = await getAccount();
-
-      const estimatedGas = await estimateGas({
-        methodName,
-        args: args || {},
-        contractId,
-      });
-
-      const functionAction = transactions.functionCall(
-        methodName,
-        args || {},
-        estimatedGas.getBaseValue("bigint"),
-        BigInt(deposit || "0"),
-      );
-
-      const result = await account.signAndSendTransaction({
-        receiverId: contractId,
-        actions: [functionAction],
-      });
-
-      return result.transaction_outcome.id;
-    } catch (error) {
-      throw new SwapKitError("toolbox_near_transfer_failed", { error });
-    }
-  }
-
-  // Create typed contract interface
-  async function createContract(contractInterface: NearContractInterface) {
-    const { createNearContract } = await import("./helpers/contractFactory");
-    const account = await getAccount();
-
-    return createNearContract({
-      account,
-      contractId: contractInterface.contractId,
-      viewMethods: contractInterface.viewMethods,
-      changeMethods: contractInterface.changeMethods,
-    });
-  }
-
-  async function executeBatchTransaction(batch: { receiverId: string; actions: any[] }) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
-
-    if (batch.actions.length === 0) {
-      throw new SwapKitError("toolbox_near_empty_batch");
-    }
-
-    const account = await getAccount();
-
-    // Use account.signAndSendTransaction for batch operations
-    const result = await account.signAndSendTransaction({
-      receiverId: batch.receiverId,
-      actions: batch.actions,
-    });
-
-    return result.transaction.hash;
-  }
-
-  async function nep141(contractId: string) {
-    const account = await getAccount();
-    return createNEP141Token({ contractId, account });
-  }
-
-  async function getBalance(address: string) {
-    try {
-      const account = await getAccount(address);
-
-      let nativeBalance: AssetValue;
-      try {
-        const value = await account.getBalance();
-
-        nativeBalance = AssetValue.from({
-          chain: Chain.Near,
-          value,
-          fromBaseDecimal: BaseDecimal[Chain.Near],
-        });
-      } catch {
-        nativeBalance = AssetValue.from({
-          chain: Chain.Near,
-          value: "0",
-          fromBaseDecimal: BaseDecimal[Chain.Near],
-        });
-      }
-
-      //   // Then, fetch token balances from API
-      //   let tokenBalances: AssetValue[] = [];
-      //   try {
-      //     const apiBalances = await SwapKitApi.getChainBalance({
-      //       chain: Chain.Near,
-      //       address,
-      //       scamFilter,
-      //     });
-
-      //     tokenBalances = apiBalances
-      //       .filter(({ identifier }) => identifier !== Chain.Near) // Filter out native NEAR
-      //       .map(({ identifier, value, decimal }) => {
-      //         return new AssetValue({
-      //           decimal: decimal || BaseDecimal[Chain.Near],
-      //           value,
-      //           identifier,
-      //         });
-      //       });
-      //   } catch (error) {
-      //     // If API fails, just return on-chain balance
-      //     console.warn("Failed to fetch token balances from API:", error);
-      //   }
-
-      // Merge native balance with token balances
-      //   return [nativeBalance, ...tokenBalances];
-      return [nativeBalance];
-    } catch (error) {
-      throw new SwapKitError("toolbox_near_balance_failed", { error });
-    }
-  }
-
-  async function estimateGas(params: NearGasEstimateParams, account?: Account) {
-    const gasInTGas = await match(params)
-      .when(isSimpleTransfer, () => GAS_COSTS.SIMPLE_TRANSFER)
-      .when(isContractCall, (p) => getContractMethodGas(p.methodName))
-      .when(isBatchTransaction, (p) => estimateBatchGas(p.actions))
-      .when(isAccountCreation, () => GAS_COSTS.ACCOUNT_CREATION)
-      .when(isContractDeployment, () => GAS_COSTS.CONTRACT_DEPLOYMENT)
-      .when(isCustomEstimator, (p) => {
-        if (!account) {
-          throw new SwapKitError("toolbox_near_no_account");
-        }
-        return p.customEstimator(account);
-      })
-      .otherwise(() => {
-        throw new SwapKitError("toolbox_near_invalid_gas_params");
-      });
-
-    // Convert TGas to gas price in NEAR
-    const gasPrice = await getGasPrice();
-    const gasInUnits = BigInt(gasInTGas) * BigInt(10 ** 12); // Convert TGas to gas units
-    const costInYoctoNear = gasInUnits * BigInt(gasPrice);
-
-    return AssetValue.from({
-      chain: Chain.Near,
-      value: costInYoctoNear,
-      fromBaseDecimal: BaseDecimal[Chain.Near],
-    });
-  }
-
-  // Get current gas price from network
-  async function getGasPrice() {
-    try {
-      const result = await provider.gasPrice(null);
-      return result.gas_price || "100000000";
-    } catch (_error) {
-      // Fallback to default
-      return "100000000";
-    }
-  }
-
-  return {
-    getAddress,
-    getPublicKey: async () => (signer ? (await signer.getPublicKey()).toString() : ""),
-    provider,
-    transfer,
-    createTransaction,
-    createContractFunctionCall,
-    estimateTransactionFee,
-    broadcastTransaction,
-    signTransaction,
-    getBalance,
-    validateAddress: await getValidateNearAddress(),
-    getSignerFromPhrase: (params: {
-      phrase: string;
-      derivationPath?: DerivationPathArray;
-      index?: number;
-    }) => getNearSignerFromPhrase(params),
-    getSignerFromPrivateKey: getNearSignerFromPrivateKey,
-    callFunction,
-    createSubAccount,
-    createContract,
-    executeBatchTransaction,
-    nep141,
-    getGasPrice,
-    estimateGas,
-  };
-}

package/src/near/types/contract.ts

@@ -1,48 +0,0 @@
-import type { Account } from "near-api-js";
-
-// Custom interface for contract metadata (not in SDK)
-export interface NearContractInterface {
-  contractId: string;
-  viewMethods: string[];
-  changeMethods: string[];
-  metadata?: {
-    version: string;
-    standards: string[]; // e.g., ["nep141", "nep171"]
-  };
-}
-
-// Enhanced call parameters
-export interface NearCallParams {
-  contractId: string;
-  methodName: string;
-  args?: Record<string, any>;
-  gas?: string | any; // BN type
-  attachedDeposit?: string | any; // BN type
-  isView?: boolean;
-}
-
-// Gas estimation using discriminated unions for type inference
-export type NearGasEstimateParams =
-  | {
-      recipient: string;
-      amount: string;
-    }
-  | {
-      contractId: string;
-      methodName: string;
-      args?: Record<string, any>;
-      attachedDeposit?: string;
-    }
-  | {
-      actions: any[]; // Action type from near-api-js
-    }
-  | {
-      newAccountId: string;
-      publicKey?: string;
-    }
-  | {
-      contractCode: Uint8Array;
-    }
-  | {
-      customEstimator: (account: Account) => Promise<string>;
-    };

package/src/near/types/nep141.ts

@@ -1,66 +0,0 @@
-// NEP-141 Fungible Token Standard Types
-
-export interface FungibleTokenMetadata {
-  spec: string; // e.g., "ft-1.0.0"
-  name: string; // e.g., "Wrapped NEAR"
-  symbol: string; // e.g., "wNEAR"
-  icon?: string; // Data URL or IPFS link
-  reference?: string; // URL to additional metadata
-  reference_hash?: string; // Base64-encoded hash of reference content
-  decimals: number; // e.g., 24 for NEAR
-}
-
-export interface StorageBalance {
-  total: string;
-  available: string;
-}
-
-export interface StorageBalanceBounds {
-  min: string;
-  max?: string;
-}
-
-// NEP-141 Contract Interface
-export interface NEP141Contract {
-  // View methods
-  ft_balance_of(args: { account_id: string }): Promise<string>;
-  ft_total_supply(): Promise<string>;
-  ft_metadata(): Promise<FungibleTokenMetadata>;
-  storage_balance_of(args: { account_id: string }): Promise<StorageBalance | null>;
-  storage_balance_bounds(): Promise<StorageBalanceBounds>;
-
-  // Change methods
-  ft_transfer(
-    args: { receiver_id: string; amount: string; memo?: string | null },
-    gas?: any, // BN type
-    deposit?: any, // BN type
-  ): Promise<any>; // Returns transaction result
-
-  ft_transfer_call(
-    args: {
-      receiver_id: string;
-      amount: string;
-      memo?: string | null;
-      msg: string;
-    },
-    gas?: any,
-    deposit?: any,
-  ): Promise<any>; // Returns transaction result
-
-  storage_deposit(
-    args: { account_id?: string; registration_only?: boolean },
-    gas?: any,
-    deposit?: any,
-  ): Promise<StorageBalance>;
-
-  storage_withdraw(args: { amount?: string }, gas?: any, deposit?: any): Promise<StorageBalance>;
-
-  storage_unregister(args: { force?: boolean }, gas?: any, deposit?: any): Promise<boolean>;
-}
-
-// Token transfer parameters
-export interface TokenTransferParams {
-  recipient: string;
-  amount: string;
-  memo?: string;
-}

package/src/near/types.ts

@@ -1,57 +0,0 @@
-import type {
-  ChainSigner,
-  DerivationPathArray,
-  GenericCreateTransactionParams,
-  GenericTransferParams,
-} from "@swapkit/helpers";
-import type { KeyPairSigner, Signer, transactions } from "near-api-js";
-
-interface NearKeyPairSigner
-  extends KeyPairSigner,
-    Omit<
-      ChainSigner<typeof transactions.Transaction, typeof transactions.SignedTransaction>,
-      "signTransaction"
-    > {}
-
-interface NearGeneralSigner
-  extends Signer,
-    Omit<
-      ChainSigner<typeof transactions.Transaction, typeof transactions.SignedTransaction>,
-      "signTransaction"
-    > {}
-
-// Extend both ChainSigner and NEAR's Signer class, omitting signTransaction
-export type NearSigner = NearKeyPairSigner | NearGeneralSigner;
-
-export type NearToolboxParams =
-  | { signer?: NearSigner; accountId?: string }
-  | { phrase?: string; index?: number; derivationPath?: DerivationPathArray };
-
-export interface NearTransferParams extends GenericTransferParams {}
-
-export interface NearConfig {
-  networkId: "mainnet" | "testnet" | "betanet";
-  nodeUrl: string;
-  walletUrl?: string;
-  helperUrl?: string;
-  keyStore?: any;
-}
-
-export interface NearFunctionCallParams {
-  contractId: string;
-  methodName: string;
-  args: Uint8Array | Record<string, any>;
-  deposit?: bigint | string | number;
-  gas?: bigint | string | number;
-}
-
-export interface NearCreateTransactionParams extends GenericCreateTransactionParams {
-  // NEAR-specific options
-  attachedDeposit?: string;
-  // Function call parameters
-  functionCall?: {
-    methodName: string;
-    args: object;
-    attachedDeposit: string;
-  };
-}