@swapkit/toolboxes 1.0.0-beta.2 → 1.0.0-beta.20

package/src/index.ts

@@ -6,15 +6,18 @@ import {
   FeeOption,
   type GenericCreateTransactionParams,
   type SubstrateChain,
+  SwapKitError,
   type UTXOChain,
 } from "@swapkit/helpers";
 import type { getCosmosToolbox } from "@swapkit/toolboxes/cosmos";
 
 import type { ETHToolbox, EVMCreateTransactionParams, getEvmToolbox } from "@swapkit/toolboxes/evm";
+import type { getNearToolbox } from "@swapkit/toolboxes/near";
 import type { RadixToolbox } from "@swapkit/toolboxes/radix";
 import type { getRippleToolbox } from "@swapkit/toolboxes/ripple";
 import type { SolanaCreateTransactionParams, getSolanaToolbox } from "@swapkit/toolboxes/solana";
 import type { getSubstrateToolbox } from "@swapkit/toolboxes/substrate";
+import type { createTronToolbox } from "@swapkit/toolboxes/tron";
 import type { getUtxoToolbox } from "@swapkit/toolboxes/utxo";
 
 export async function getAddressValidator() {
@@ -24,11 +27,14 @@ export async function getAddressValidator() {
   const { substrateValidateAddress } = await import("@swapkit/toolboxes/substrate");
   const { getUTXOAddressValidator } = await import("@swapkit/toolboxes/utxo");
   const { getSolanaAddressValidator } = await import("@swapkit/toolboxes/solana");
+  const { validateNearAddress } = await import("@swapkit/toolboxes/near");
   const { rippleValidateAddress } = await import("@swapkit/toolboxes/ripple");
   const { radixValidateAddress } = await import("@swapkit/toolboxes/radix");
+  const { getTronAddressValidator } = await import("@swapkit/toolboxes/tron");
 
   const solanaValidateAddress = await getSolanaAddressValidator();
   const utxoValidateAddress = await getUTXOAddressValidator();
+  const tronValidateAddress = await getTronAddressValidator();
 
   return function validateAddress({ address, chain }: { address: string; chain: Chain }) {
     const isValid = match(chain)
@@ -52,68 +58,62 @@ export async function getAddressValidator() {
         substrateValidateAddress({ address, chain: chain as SubstrateChain }),
       )
       .with(Chain.Radix, () => radixValidateAddress(address))
+      .with(Chain.Near, () => validateNearAddress(address))
       .with(Chain.Ripple, () => rippleValidateAddress(address))
       .with(Chain.Solana, () => solanaValidateAddress(address))
+      .with(Chain.Tron, () => tronValidateAddress(address))
       .otherwise(() => false);
 
     return isValid;
   };
 }
 
-export async function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
-  const toolbox = await getToolbox(chain);
-
+export function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
   return async function estimateFee(params: CreateTransactionParams[T]) {
-    switch (chain) {
-      case Chain.Arbitrum:
-      case Chain.Avalanche:
-      case Chain.Optimism:
-      case Chain.BinanceSmartChain:
-      case Chain.Base:
-      case Chain.Polygon:
-      case Chain.Ethereum: {
-        const txObject = await (
-          toolbox as Awaited<ReturnType<typeof ETHToolbox>>
-        ).createTransaction(params as EVMCreateTransactionParams);
-        return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
-          ...txObject,
-          feeOption: params.feeOptionKey || FeeOption.Fast,
-          chain,
-        });
-      }
-      case Chain.Bitcoin:
-      case Chain.BitcoinCash:
-      case Chain.Dogecoin:
-      case Chain.Dash:
-      case Chain.Litecoin: {
-        return (toolbox as Awaited<ReturnType<typeof getUtxoToolbox>>).estimateTransactionFee(
-          params as CreateTransactionParams[Chain.Bitcoin],
-        );
-      }
+    const { match } = await import("ts-pattern");
 
-      case Chain.THORChain:
-      case Chain.Maya:
-      case Chain.Kujira:
-      case Chain.Cosmos: {
+    return match(chain as Chain)
+      .returnType<Promise<AssetValue>>()
+      .with(
+        Chain.Arbitrum,
+        Chain.Avalanche,
+        Chain.Optimism,
+        Chain.BinanceSmartChain,
+        Chain.Base,
+        Chain.Polygon,
+        Chain.Ethereum,
+        async (chain) => {
+          const toolbox = await getToolbox(chain);
+          const txObject = await toolbox.createTransaction(params);
+
+          return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
+            ...txObject,
+            feeOption: params.feeOptionKey || FeeOption.Fast,
+            chain,
+          });
+        },
+      )
+      .with(
+        Chain.Bitcoin,
+        Chain.BitcoinCash,
+        Chain.Dogecoin,
+        Chain.Dash,
+        Chain.Litecoin,
+        Chain.Polkadot,
+        Chain.Solana,
+        Chain.Ripple,
+        Chain.Tron,
+        Chain.Near,
+        async (chain) => {
+          const toolbox = await getToolbox(chain);
+          return toolbox.estimateTransactionFee(params) as Promise<AssetValue>;
+        },
+      )
+      .with(Chain.THORChain, Chain.Maya, Chain.Kujira, Chain.Cosmos, async () => {
         const { estimateTransactionFee } = await import("@swapkit/toolboxes/cosmos");
         return estimateTransactionFee(params);
-      }
-
-      case Chain.Polkadot: {
-        return (
-          toolbox as Awaited<ReturnType<typeof getSubstrateToolbox<Chain.Polkadot>>>
-        ).estimateTransactionFee(params);
-      }
-
-      case Chain.Solana: {
-        return (toolbox as Awaited<ReturnType<typeof getSolanaToolbox>>).estimateTransactionFee(
-          params as CreateTransactionParams[Chain.Solana],
-        );
-      }
-
-      default:
-        return AssetValue.from({ chain });
-    }
+      })
+      .otherwise(async () => AssetValue.from({ chain }));
   };
 }
 
@@ -127,8 +127,10 @@ type Toolboxes = {
   [key in SubstrateChain]: Awaited<ReturnType<typeof getSubstrateToolbox>>;
 } & {
   [Chain.Radix]: Awaited<ReturnType<typeof RadixToolbox>>;
+  [Chain.Near]: Awaited<ReturnType<typeof getNearToolbox>>;
   [Chain.Ripple]: Awaited<ReturnType<typeof getRippleToolbox>>;
   [Chain.Solana]: Awaited<ReturnType<typeof getSolanaToolbox>>;
+  [Chain.Tron]: Awaited<ReturnType<typeof createTronToolbox>>;
 };
 
 type ToolboxParams = { [key in EVMChain]: Parameters<typeof getEvmToolbox>[1] } & {
@@ -139,8 +141,10 @@ type ToolboxParams = { [key in EVMChain]: Parameters<typeof getEvmToolbox>[1] }
   [key in SubstrateChain]: Parameters<typeof getSubstrateToolbox>[1];
 } & {
   [Chain.Radix]: Parameters<typeof RadixToolbox>[0];
+  [Chain.Near]: Parameters<typeof getNearToolbox>[0];
   [Chain.Ripple]: Parameters<typeof getRippleToolbox>[0];
   [Chain.Solana]: Parameters<typeof getSolanaToolbox>[0];
+  [Chain.Tron]: Parameters<typeof createTronToolbox>[0];
 };
 
 type CreateTransactionParams = { [key in EVMChain]: EVMCreateTransactionParams } & {
@@ -151,85 +155,98 @@ type CreateTransactionParams = { [key in EVMChain]: EVMCreateTransactionParams }
   [key in SubstrateChain]: GenericCreateTransactionParams;
 } & {
   [Chain.Radix]: GenericCreateTransactionParams;
+  [Chain.Ripple]: GenericCreateTransactionParams;
+  [Chain.Near]: GenericCreateTransactionParams;
   [Chain.Solana]: SolanaCreateTransactionParams;
+  [Chain.Tron]: GenericCreateTransactionParams;
 };
 
 export async function getToolbox<T extends keyof Toolboxes>(
   chain: T,
   params?: ToolboxParams[T],
 ): Promise<Toolboxes[T]> {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Optimism:
-    case Chain.BinanceSmartChain:
-    case Chain.Base:
-    case Chain.Polygon:
-    case Chain.Ethereum: {
-      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const evmToolbox = await getEvmToolbox(chain, params as Parameters<typeof getEvmToolbox>[1]);
-      return evmToolbox as Toolboxes[T];
-    }
-
-    case Chain.Litecoin:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.BitcoinCash:
-    case Chain.Bitcoin: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const utxoToolbox = await getUtxoToolbox(
-        chain,
-        params as Parameters<typeof getUtxoToolbox>[1],
-      );
-      return utxoToolbox as Toolboxes[T];
-    }
+  const { match } = await import("ts-pattern");
 
-    case Chain.Cosmos:
-    case Chain.Kujira:
-    case Chain.Maya:
-    case Chain.THORChain: {
+  return match(chain as Chain)
+    .returnType<Promise<Toolboxes[T]>>()
+    .with(
+      Chain.Arbitrum,
+      Chain.Avalanche,
+      Chain.Optimism,
+      Chain.BinanceSmartChain,
+      Chain.Base,
+      Chain.Polygon,
+      Chain.Ethereum,
+      async () => {
+        const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+        const evmToolbox = await getEvmToolbox(
+          chain as EVMChain,
+          params as Parameters<typeof getEvmToolbox>[1],
+        );
+        return evmToolbox as Toolboxes[T];
+      },
+    )
+    .with(
+      Chain.Litecoin,
+      Chain.Dash,
+      Chain.Dogecoin,
+      Chain.BitcoinCash,
+      Chain.Bitcoin,
+      async () => {
+        const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+        const utxoToolbox = await getUtxoToolbox(
+          chain as UTXOChain,
+          params as Parameters<typeof getUtxoToolbox>[1],
+        );
+        return utxoToolbox as Toolboxes[T];
+      },
+    )
+    .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, async () => {
       const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
       const cosmosToolbox = await getCosmosToolbox(
-        chain,
+        chain as CosmosChain,
         params as Parameters<typeof getCosmosToolbox>[1],
       );
-
       return cosmosToolbox as Toolboxes[T];
-    }
-
-    case Chain.Chainflip:
-    case Chain.Polkadot: {
+    })
+    .with(Chain.Chainflip, Chain.Polkadot, async () => {
       const { getSubstrateToolbox } = await import("@swapkit/toolboxes/substrate");
       const substrateToolbox = await getSubstrateToolbox(
-        chain,
+        chain as SubstrateChain,
         params as Parameters<typeof getSubstrateToolbox>[1],
       );
       return substrateToolbox as Toolboxes[T];
-    }
-
-    case Chain.Radix: {
+    })
+    .with(Chain.Radix, async () => {
       const { RadixToolbox } = await import("@swapkit/toolboxes/radix");
       const radixToolbox = await RadixToolbox(params as Parameters<typeof RadixToolbox>[0]);
       return radixToolbox as Toolboxes[T];
-    }
-
-    case Chain.Ripple: {
+    })
+    .with(Chain.Ripple, async () => {
       const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
       const rippleToolbox = await getRippleToolbox(
         params as Parameters<typeof getRippleToolbox>[0],
       );
       return rippleToolbox as Toolboxes[T];
-    }
-
-    case Chain.Solana: {
+    })
+    .with(Chain.Solana, async () => {
       const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
       const solanaToolbox = await getSolanaToolbox(
         params as Parameters<typeof getSolanaToolbox>[0],
       );
       return solanaToolbox as Toolboxes[T];
-    }
-
-    default:
-      throw new Error(`Chain ${chain} is not supported`);
-  }
+    })
+    .with(Chain.Tron, async () => {
+      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const tronToolbox = await createTronToolbox(params);
+      return tronToolbox as Toolboxes[T];
+    })
+    .with(Chain.Near, async () => {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const nearToolbox = await getNearToolbox(params as Parameters<typeof getNearToolbox>[0]);
+      return nearToolbox as Toolboxes[T];
+    })
+    .otherwise(() => {
+      throw new SwapKitError("toolbox_not_supported", { chain });
+    });
 }

package/src/near/helpers/contractFactory.ts

@@ -0,0 +1,22 @@
+import type { Account, Contract } from "near-api-js";
+
+// Create a Near contract instance
+export async function createNearContract<T extends Contract>({
+  account,
+  contractId,
+  viewMethods,
+  changeMethods,
+}: {
+  account: Account;
+  contractId: string;
+  viewMethods: string[];
+  changeMethods: string[];
+}): Promise<T> {
+  const { Contract } = await import("near-api-js");
+
+  return new Contract(account, contractId, {
+    viewMethods,
+    changeMethods,
+    useLocalViewExecution: true, // Enable local view execution for efficiency
+  }) as T;
+}

package/src/near/helpers/core.ts

@@ -0,0 +1,86 @@
+import type { Provider } from "@near-js/providers";
+import { type DerivationPathArray, SwapKitError, derivationPathToString } from "@swapkit/helpers";
+import { type KeyPair, KeyPairSigner } from "near-api-js";
+import type { NearSigner } from "../types";
+
+export async function validateNearAddress(address: string) {
+  // Use the official NEAR SDK validation function if available
+  try {
+    const { validateAccountId } = await import("near-sdk-js");
+    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-api-js");
+
+  // Handle derivation path logic here
+  // NEAR uses a 3-level derivation path: m/44'/397'/index'
+  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-api-js/lib/utils");
+  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> {
+    // For implicit accounts, derive account ID from public key
+    // NEAR implicit accounts use hex representation of the public key
+    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) {
+  // Get the first full access key for the account
+  const response = await provider.query({
+    request_type: "view_access_key_list",
+    finality: "final",
+    account_id: accountId,
+  });
+
+  const fullAccessKey = (response as any).keys.find(
+    (key: any) => key.access_key.permission === "FullAccess",
+  );
+
+  if (!fullAccessKey) {
+    throw new SwapKitError("toolbox_near_invalid_address");
+  }
+
+  const { utils } = await import("near-api-js");
+  return utils.PublicKey.fromString(fullAccessKey.public_key);
+}

package/src/near/helpers/gasEstimation.ts

@@ -0,0 +1,110 @@
+import type { Account } from "near-api-js";
+import type { NearGasEstimateParams } from "../types/contract";
+
+// Gas constants (in TGas - 10^12 gas units)
+export const GAS_COSTS = {
+  SIMPLE_TRANSFER: "1", // 1 TGas
+  TOKEN_TRANSFER: "100", // 100 TGas
+  CONTRACT_CALL: "100", // 100 TGas base
+  ACCOUNT_CREATION: "30", // 30 TGas
+  CONTRACT_DEPLOYMENT: "200", // 200 TGas
+  ACCESS_KEY_ADDITION: "5", // 5 TGas
+  ACCESS_KEY_DELETION: "5", // 5 TGas
+  STAKE: "10", // 10 TGas
+  STORAGE_DEPOSIT: "100", // 100 TGas
+} as const;
+
+// Type guards for discriminated union
+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;
+}
+
+// Helper function to estimate gas for batch actions
+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();
+}
+
+// Helper function to get gas cost for contract methods
+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;
+}
+
+// Convert TGas string to gas units
+export function tgasToGas(tgas: string): string {
+  return (BigInt(tgas) * BigInt(10 ** 12)).toString();
+}
+
+// Convert gas units to TGas
+export function gasToTGas(gas: string): string {
+  return (BigInt(gas) / BigInt(10 ** 12)).toString();
+}

package/src/near/helpers/index.ts

@@ -0,0 +1,5 @@
+export * from "./core";
+
+export { createNearContract } from "./contractFactory";
+export * from "./gasEstimation";
+export { createNEP141Token } from "./nep141";

package/src/near/helpers/nep141.ts

@@ -0,0 +1,110 @@
+import type { Account, Contract } from "near-api-js";
+import { createNearContract } from "./contractFactory";
+
+const DEFAULT_STORAGE_DEPOSIT = "1250000000000000000000"; // 0.00125 NEAR
+
+// Define NEP-141 contract interface
+interface NEP141Contract extends Contract {
+  // View methods
+  ft_balance_of(args: { account_id: string }): Promise<string>;
+  ft_total_supply(): Promise<string>;
+  ft_metadata(): Promise<any>;
+  storage_balance_of(args: { account_id: string }): Promise<any>;
+  storage_balance_bounds(): Promise<any>;
+
+  // Change methods
+  ft_transfer(args: any, gas: any, deposit: any): Promise<any>;
+  ft_transfer_call(args: any, gas: any, deposit: any): Promise<any>;
+  storage_deposit(args: any, gas: any, deposit: any): Promise<any>;
+  storage_withdraw(args: any, gas: any, deposit: any): Promise<any>;
+  storage_unregister(force?: boolean, gas?: any): Promise<any>;
+}
+
+export async function createNEP141Token({
+  contractId,
+  account,
+}: {
+  contractId: string;
+  account: Account;
+}) {
+  const BN = (await import("bn.js")).default;
+
+  const contract = await createNearContract<NEP141Contract>({
+    account,
+    contractId,
+    viewMethods: [
+      "ft_balance_of",
+      "ft_total_supply",
+      "ft_metadata",
+      "storage_balance_of",
+      "storage_balance_bounds",
+    ],
+    changeMethods: [
+      "ft_transfer",
+      "ft_transfer_call",
+      "storage_deposit",
+      "storage_withdraw",
+      "storage_unregister",
+    ],
+  });
+
+  // Helper to ensure storage before transfers
+  const ensureStorageFor = async (accountId: string) => {
+    const balance = await contract.storage_balance_of({ account_id: accountId });
+    if (!balance) {
+      // Get minimum storage requirement
+      const bounds = await contract.storage_balance_bounds();
+      const deposit = bounds?.min || DEFAULT_STORAGE_DEPOSIT;
+
+      await contract.storage_deposit(
+        { account_id: accountId },
+        new BN("100000000000000"), // 100 TGas
+        new BN(deposit),
+      );
+    }
+  };
+
+  return {
+    transfer: async (receiverId: string, amount: string, memo?: string) => {
+      // Ensure recipient has storage before transfer
+      await ensureStorageFor(receiverId);
+
+      return contract.ft_transfer(
+        { receiver_id: receiverId, amount, memo },
+        new BN("100000000000000"), // 100 TGas
+        new BN("1"), // 1 yoctoNEAR for security
+      );
+    },
+
+    transferCall: async (receiverId: string, amount: string, msg: string, memo?: string) => {
+      // Ensure recipient has storage before transfer
+      await ensureStorageFor(receiverId);
+
+      return contract.ft_transfer_call(
+        { receiver_id: receiverId, amount, memo, msg },
+        new BN("100000000000000"), // 100 TGas
+        new BN("1"), // 1 yoctoNEAR for security
+      );
+    },
+
+    balanceOf: (accountId: string) => contract.ft_balance_of({ account_id: accountId }),
+
+    totalSupply: () => contract.ft_total_supply(),
+
+    metadata: () => contract.ft_metadata(),
+
+    storageBalanceOf: (accountId: string) => contract.storage_balance_of({ account_id: accountId }),
+
+    storageDeposit: (accountId?: string, amount?: string) =>
+      contract.storage_deposit(
+        { account_id: accountId },
+        new BN("100000000000000"),
+        new BN(amount || DEFAULT_STORAGE_DEPOSIT),
+      ),
+
+    ensureStorage: ensureStorageFor,
+
+    // Raw contract access for advanced use cases
+    contract,
+  };
+}

package/src/near/index.ts

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