@t402/near 2.3.0

package/dist/cjs/index.js

@@ -0,0 +1,711 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_FT_TRANSFER_GAS: () => DEFAULT_FT_TRANSFER_GAS,
+  DEFAULT_STORAGE_DEPOSIT: () => DEFAULT_STORAGE_DEPOSIT,
+  DEFAULT_STORAGE_DEPOSIT_GAS: () => DEFAULT_STORAGE_DEPOSIT_GAS,
+  DEFAULT_VALIDITY_DURATION: () => DEFAULT_VALIDITY_DURATION,
+  ExactDirectNearClient: () => ExactDirectNearClient,
+  ExactDirectNearFacilitator: () => ExactDirectNearFacilitator,
+  ExactDirectNearServer: () => ExactDirectNearServer,
+  FT_TRANSFER_DEPOSIT: () => FT_TRANSFER_DEPOSIT,
+  MAX_TRANSACTION_AGE: () => MAX_TRANSACTION_AGE,
+  NEAR_CAIP2_NAMESPACE: () => NEAR_CAIP2_NAMESPACE,
+  NEAR_MAINNET_CAIP2: () => NEAR_MAINNET_CAIP2,
+  NEAR_MAINNET_RPC: () => NEAR_MAINNET_RPC,
+  NEAR_NETWORKS: () => NEAR_NETWORKS,
+  NEAR_NETWORK_IDS: () => NEAR_NETWORK_IDS,
+  NEAR_TESTNET_CAIP2: () => NEAR_TESTNET_CAIP2,
+  NEAR_TESTNET_RPC: () => NEAR_TESTNET_RPC,
+  NEP141_FT_BALANCE_OF: () => NEP141_FT_BALANCE_OF,
+  NEP141_FT_TRANSFER: () => NEP141_FT_TRANSFER,
+  NEP141_STORAGE_BALANCE_OF: () => NEP141_STORAGE_BALANCE_OF,
+  NEP141_STORAGE_DEPOSIT: () => NEP141_STORAGE_DEPOSIT,
+  NETWORK_RPC_ENDPOINTS: () => NETWORK_RPC_ENDPOINTS,
+  SCHEME_EXACT_DIRECT: () => SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
+  extractNetworkId: () => extractNetworkId,
+  formatAmount: () => formatAmount,
+  getDefaultToken: () => getDefaultToken,
+  getNetworkTokens: () => getNetworkTokens,
+  getRpcEndpoint: () => getRpcEndpoint,
+  getTokenByContract: () => getTokenByContract,
+  getTokenConfig: () => getTokenConfig,
+  isNetworkSupported: () => isNetworkSupported,
+  isTransactionSuccessful: () => isTransactionSuccessful,
+  isValidAccountId: () => isValidAccountId,
+  normalizeNetwork: () => normalizeNetwork,
+  parseFtTransferArgs: () => parseFtTransferArgs,
+  queryTokenBalance: () => queryTokenBalance,
+  queryTransaction: () => queryTransaction,
+  registerExactDirectNearClient: () => registerExactDirectNearClient,
+  registerExactDirectNearFacilitator: () => registerExactDirectNearFacilitator,
+  registerExactDirectNearServer: () => registerExactDirectNearServer,
+  rpcCall: () => rpcCall,
+  toTokenUnits: () => toTokenUnits
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var NEAR_MAINNET_CAIP2 = "near:mainnet";
+var NEAR_TESTNET_CAIP2 = "near:testnet";
+var NEAR_NETWORKS = [NEAR_MAINNET_CAIP2, NEAR_TESTNET_CAIP2];
+var NEAR_NETWORK_IDS = {
+  [NEAR_MAINNET_CAIP2]: "mainnet",
+  [NEAR_TESTNET_CAIP2]: "testnet"
+};
+var NEAR_MAINNET_RPC = "https://rpc.mainnet.near.org";
+var NEAR_TESTNET_RPC = "https://rpc.testnet.near.org";
+var NETWORK_RPC_ENDPOINTS = {
+  [NEAR_MAINNET_CAIP2]: NEAR_MAINNET_RPC,
+  [NEAR_TESTNET_CAIP2]: NEAR_TESTNET_RPC
+};
+var NEP141_FT_TRANSFER = "ft_transfer";
+var NEP141_FT_BALANCE_OF = "ft_balance_of";
+var NEP141_STORAGE_DEPOSIT = "storage_deposit";
+var NEP141_STORAGE_BALANCE_OF = "storage_balance_of";
+var DEFAULT_FT_TRANSFER_GAS = "30000000000000";
+var DEFAULT_STORAGE_DEPOSIT_GAS = "10000000000000";
+var FT_TRANSFER_DEPOSIT = "1";
+var DEFAULT_STORAGE_DEPOSIT = "1250000000000000000000";
+var SCHEME_EXACT_DIRECT = "exact-direct";
+var DEFAULT_VALIDITY_DURATION = 3600;
+var MAX_TRANSACTION_AGE = 5 * 60 * 1e3;
+var NEAR_CAIP2_NAMESPACE = "near";
+
+// src/tokens.ts
+var TOKEN_REGISTRY = {
+  [NEAR_MAINNET_CAIP2]: [
+    {
+      // USDC on NEAR (Rainbow Bridge)
+      contractId: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      priority: 1
+    },
+    {
+      // USDT on NEAR
+      contractId: "usdt.tether-token.near",
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6,
+      priority: 2
+    }
+  ],
+  [NEAR_TESTNET_CAIP2]: [
+    {
+      // Fake USDC on testnet
+      contractId: "usdc.fakes.testnet",
+      symbol: "USDC",
+      name: "USD Coin (Testnet)",
+      decimals: 6,
+      priority: 1
+    }
+  ]
+};
+function getTokenConfig(network, symbol) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  return tokens.find((t) => t.symbol.toUpperCase() === symbol.toUpperCase());
+}
+function getTokenByContract(network, contractId) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  return tokens.find((t) => t.contractId === contractId);
+}
+function getDefaultToken(network) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens || tokens.length === 0) return void 0;
+  return [...tokens].sort((a, b) => a.priority - b.priority)[0];
+}
+function getNetworkTokens(network) {
+  return TOKEN_REGISTRY[network] || [];
+}
+function isNetworkSupported(network) {
+  return network in TOKEN_REGISTRY;
+}
+
+// src/utils.ts
+function normalizeNetwork(network) {
+  if (network.startsWith(`${NEAR_CAIP2_NAMESPACE}:`)) {
+    return network;
+  }
+  return `${NEAR_CAIP2_NAMESPACE}:${network}`;
+}
+function extractNetworkId(network) {
+  if (network.includes(":")) {
+    return network.split(":")[1];
+  }
+  return network;
+}
+function isValidAccountId(accountId) {
+  if (!accountId || accountId.length < 2 || accountId.length > 64) {
+    return false;
+  }
+  const regex = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9_-]*[a-z0-9])?)*$/;
+  return regex.test(accountId);
+}
+function getRpcEndpoint(network) {
+  const normalizedNetwork = normalizeNetwork(network);
+  return NETWORK_RPC_ENDPOINTS[normalizedNetwork] || NETWORK_RPC_ENDPOINTS["near:mainnet"];
+}
+async function rpcCall(network, method, params) {
+  const endpoint = getRpcEndpoint(network);
+  const request = {
+    jsonrpc: "2.0",
+    id: `t402-${Date.now()}`,
+    method,
+    params
+  };
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+  const data = await response.json();
+  if (data.error) {
+    throw new Error(`NEAR RPC error: ${data.error.message}`);
+  }
+  return data.result;
+}
+async function queryTransaction(network, txHash, senderAccountId) {
+  return rpcCall(network, "tx", [txHash, senderAccountId]);
+}
+async function queryTokenBalance(network, accountId, tokenContract) {
+  try {
+    const result = await rpcCall(network, "query", {
+      request_type: "call_function",
+      finality: "final",
+      account_id: tokenContract,
+      method_name: "ft_balance_of",
+      args_base64: btoa(JSON.stringify({ account_id: accountId }))
+    });
+    const bytes = new Uint8Array(result.result);
+    const text = new TextDecoder().decode(bytes);
+    const balance = text.replace(/"/g, "");
+    return BigInt(balance);
+  } catch (error) {
+    console.error("Error fetching token balance:", error);
+    return 0n;
+  }
+}
+function parseFtTransferArgs(argsBase64) {
+  try {
+    const argsJson = atob(argsBase64);
+    return JSON.parse(argsJson);
+  } catch {
+    try {
+      return JSON.parse(argsBase64);
+    } catch {
+      return null;
+    }
+  }
+}
+function isTransactionSuccessful(status) {
+  return status.SuccessValue !== void 0 && status.Failure === void 0;
+}
+function formatAmount(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const remainder = amount % divisor;
+  const decimal = remainder.toString().padStart(decimals, "0").slice(0, 2);
+  return `${whole}.${decimal}`;
+}
+function toTokenUnits(decimalAmount, decimals) {
+  const amount = typeof decimalAmount === "string" ? parseFloat(decimalAmount) : decimalAmount;
+  if (isNaN(amount)) {
+    throw new Error(`Invalid amount: ${decimalAmount}`);
+  }
+  const multiplier = 10 ** decimals;
+  return BigInt(Math.floor(amount * multiplier));
+}
+
+// src/exact-direct/client/scheme.ts
+var ExactDirectNearClient = class {
+  /**
+   * Creates a new ExactDirectNearScheme instance.
+   *
+   * @param signer - The NEAR signer for client operations
+   * @param config - Optional configuration overrides
+   */
+  constructor(signer, config = {}) {
+    this.signer = signer;
+    this.config = config;
+    this.scheme = SCHEME_EXACT_DIRECT;
+  }
+  /**
+   * Creates a payment payload by executing the transfer.
+   *
+   * Unlike other schemes where the client creates a signed message for
+   * the facilitator to execute, the exact-direct scheme has the client
+   * execute the transfer directly. The transaction hash is then used
+   * as proof of payment.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload with transaction hash
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    normalizeNetwork(paymentRequirements.network);
+    if (!paymentRequirements.asset) {
+      throw new Error("Asset (token contract address) is required");
+    }
+    if (!paymentRequirements.payTo) {
+      throw new Error("PayTo address is required");
+    }
+    if (!paymentRequirements.amount) {
+      throw new Error("Amount is required");
+    }
+    if (!isValidAccountId(paymentRequirements.payTo)) {
+      throw new Error(`Invalid recipient account ID: ${paymentRequirements.payTo}`);
+    }
+    if (!isValidAccountId(this.signer.accountId)) {
+      throw new Error(`Invalid sender account ID: ${this.signer.accountId}`);
+    }
+    const tokenContract = paymentRequirements.asset;
+    const recipient = paymentRequirements.payTo;
+    const amount = paymentRequirements.amount;
+    const ftTransferArgs = {
+      receiver_id: recipient,
+      amount
+    };
+    if (this.config.memo) {
+      ftTransferArgs.memo = this.config.memo;
+    }
+    const txHash = await this.signer.signAndSendTransaction(
+      tokenContract,
+      "ft_transfer",
+      ftTransferArgs,
+      this.config.gasAmount || DEFAULT_FT_TRANSFER_GAS,
+      FT_TRANSFER_DEPOSIT
+    );
+    const payload = {
+      txHash,
+      from: this.signer.accountId,
+      to: recipient,
+      amount
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+};
+
+// src/exact-direct/client/register.ts
+function registerExactDirectNearClient(client, config) {
+  const scheme = new ExactDirectNearClient(config.signer, config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("near:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/exact-direct/server/scheme.ts
+var ExactDirectNearServer = class {
+  constructor(config = {}) {
+    this.scheme = SCHEME_EXACT_DIRECT;
+    this.moneyParsers = [];
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   * Multiple parsers can be registered - they will be tried in registration order.
+   * Each parser receives a decimal amount (e.g., 1.50 for $1.50).
+   * If a parser returns null, the next parser in the chain will be tried.
+   * The default parser is always the final fallback.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount.
+   * If price is already an AssetAmount, returns it directly.
+   * If price is Money (string | number), parses to decimal and tries custom parsers.
+   * Falls back to default conversion if all custom parsers return null.
+   *
+   * @param price - The price to parse
+   * @param network - The network to use
+   * @returns Promise that resolves to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    const normalizedNetwork = normalizeNetwork(network);
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset address must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, normalizedNetwork);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount, normalizedNetwork);
+  }
+  /**
+   * Build payment requirements for this scheme/network combination.
+   *
+   * @param paymentRequirements - Base payment requirements with amount/asset already set
+   * @param supportedKind - The supported kind from facilitator's /supported endpoint
+   * @param extensionKeys - Extensions supported by the facilitator
+   * @returns Enhanced payment requirements ready to be sent to clients
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const extra = { ...paymentRequirements.extra };
+    if (supportedKind.extra?.assetSymbol) {
+      extra.assetSymbol = supportedKind.extra.assetSymbol;
+    }
+    if (supportedKind.extra?.assetDecimals) {
+      extra.assetDecimals = supportedKind.extra.assetDecimals;
+    }
+    return {
+      ...paymentRequirements,
+      extra
+    };
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   * Handles formats like "$1.50", "1.50", 1.50, etc.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Default money conversion implementation.
+   * Converts decimal amount to the preferred token on the specified network.
+   */
+  defaultMoneyConversion(amount, network) {
+    const token = this.getDefaultAsset(network);
+    const tokenAmount = toTokenUnits(amount, token.decimals);
+    return {
+      amount: tokenAmount.toString(),
+      asset: token.contractId,
+      extra: {
+        symbol: token.symbol,
+        name: token.name,
+        decimals: token.decimals
+      }
+    };
+  }
+  /**
+   * Get the default asset info for a network.
+   * Priority: configured preferredToken > network default
+   */
+  getDefaultAsset(network) {
+    if (this.config.preferredToken) {
+      const preferred = getTokenConfig(network, this.config.preferredToken);
+      if (preferred) return preferred;
+    }
+    const defaultToken = getDefaultToken(network);
+    if (defaultToken) return defaultToken;
+    throw new Error(`No tokens configured for network ${network}`);
+  }
+  /**
+   * Get all supported networks
+   */
+  static getSupportedNetworks() {
+    return Object.keys(TOKEN_REGISTRY);
+  }
+  /**
+   * Check if a network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in TOKEN_REGISTRY;
+  }
+};
+
+// src/exact-direct/server/register.ts
+function registerExactDirectNearServer(server, config = {}) {
+  const scheme = new ExactDirectNearServer(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("near:*", scheme);
+  }
+  return server;
+}
+
+// src/exact-direct/facilitator/scheme.ts
+var ExactDirectNearFacilitator = class {
+  constructor(signer, config) {
+    this.signer = signer;
+    this.scheme = SCHEME_EXACT_DIRECT;
+    this.caipFamily = `${NEAR_CAIP2_NAMESPACE}:*`;
+    this.usedTxs = /* @__PURE__ */ new Map();
+    this.config = {
+      maxTransactionAge: config?.maxTransactionAge ?? MAX_TRANSACTION_AGE,
+      usedTxCacheDuration: config?.usedTxCacheDuration ?? 24 * 60 * 60 * 1e3
+      // 24 hours
+    };
+    this.startCleanupInterval();
+  }
+  /**
+   * Get extra data for a supported kind
+   */
+  getExtra(network) {
+    const token = getDefaultToken(network);
+    if (!token) {
+      return void 0;
+    }
+    return {
+      assetSymbol: token.symbol,
+      assetDecimals: token.decimals
+    };
+  }
+  /**
+   * Get signer addresses for a network
+   */
+  getSigners(network) {
+    return this.signer.getAddresses(network);
+  }
+  /**
+   * Verify a payment payload
+   */
+  async verify(payload, requirements) {
+    const network = normalizeNetwork(requirements.network);
+    if (payload.accepted.scheme !== SCHEME_EXACT_DIRECT) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_scheme"
+      };
+    }
+    if (normalizeNetwork(payload.accepted.network) !== network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch"
+      };
+    }
+    const nearPayload = payload.payload;
+    if (!nearPayload.txHash) {
+      return {
+        isValid: false,
+        invalidReason: "missing_tx_hash"
+      };
+    }
+    if (!nearPayload.from || !isValidAccountId(nearPayload.from)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_from_address"
+      };
+    }
+    if (this.isTxUsed(nearPayload.txHash)) {
+      return {
+        isValid: false,
+        invalidReason: "transaction_already_used",
+        payer: nearPayload.from
+      };
+    }
+    try {
+      const tx = await this.signer.queryTransaction(nearPayload.txHash, nearPayload.from);
+      if (!isTransactionSuccessful(tx.status)) {
+        return {
+          isValid: false,
+          invalidReason: "transaction_failed",
+          payer: nearPayload.from
+        };
+      }
+      if (tx.transaction.receiver_id !== requirements.asset) {
+        return {
+          isValid: false,
+          invalidReason: "wrong_token_contract",
+          payer: nearPayload.from
+        };
+      }
+      let ftTransferArgs = null;
+      for (const action of tx.transaction.actions) {
+        if (action.FunctionCall?.method_name === "ft_transfer") {
+          ftTransferArgs = parseFtTransferArgs(action.FunctionCall.args);
+          break;
+        }
+      }
+      if (!ftTransferArgs) {
+        return {
+          isValid: false,
+          invalidReason: "no_ft_transfer_action",
+          payer: nearPayload.from
+        };
+      }
+      if (ftTransferArgs.receiver_id !== requirements.payTo) {
+        return {
+          isValid: false,
+          invalidReason: "wrong_recipient",
+          payer: nearPayload.from
+        };
+      }
+      const txAmount = BigInt(ftTransferArgs.amount);
+      const requiredAmount = BigInt(requirements.amount);
+      if (txAmount < requiredAmount) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_amount",
+          payer: nearPayload.from
+        };
+      }
+      this.markTxUsed(nearPayload.txHash);
+      return {
+        isValid: true,
+        payer: nearPayload.from
+      };
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "transaction_not_found",
+        payer: nearPayload.from
+      };
+    }
+  }
+  /**
+   * Settle a payment - for exact-direct, the transfer is already complete
+   */
+  async settle(payload, requirements) {
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        success: false,
+        errorReason: verifyResult.invalidReason || "verification_failed",
+        payer: verifyResult.payer,
+        transaction: "",
+        network: normalizeNetwork(requirements.network)
+      };
+    }
+    const nearPayload = payload.payload;
+    return {
+      success: true,
+      transaction: nearPayload.txHash,
+      network: normalizeNetwork(requirements.network),
+      payer: nearPayload.from
+    };
+  }
+  /**
+   * Check if a transaction has been used
+   */
+  isTxUsed(txHash) {
+    return this.usedTxs.has(txHash);
+  }
+  /**
+   * Mark a transaction as used
+   */
+  markTxUsed(txHash) {
+    this.usedTxs.set(txHash, Date.now());
+  }
+  /**
+   * Start the cleanup interval for used transactions
+   */
+  startCleanupInterval() {
+    setInterval(
+      () => {
+        const cutoff = Date.now() - this.config.usedTxCacheDuration;
+        for (const [txHash, usedAt] of this.usedTxs.entries()) {
+          if (usedAt < cutoff) {
+            this.usedTxs.delete(txHash);
+          }
+        }
+      },
+      60 * 60 * 1e3
+    );
+  }
+};
+
+// src/exact-direct/facilitator/register.ts
+function registerExactDirectNearFacilitator(facilitator, config) {
+  const scheme = new ExactDirectNearFacilitator(config.signer, config.schemeConfig);
+  facilitator.register(config.networks, scheme);
+  return facilitator;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FT_TRANSFER_GAS,
+  DEFAULT_STORAGE_DEPOSIT,
+  DEFAULT_STORAGE_DEPOSIT_GAS,
+  DEFAULT_VALIDITY_DURATION,
+  ExactDirectNearClient,
+  ExactDirectNearFacilitator,
+  ExactDirectNearServer,
+  FT_TRANSFER_DEPOSIT,
+  MAX_TRANSACTION_AGE,
+  NEAR_CAIP2_NAMESPACE,
+  NEAR_MAINNET_CAIP2,
+  NEAR_MAINNET_RPC,
+  NEAR_NETWORKS,
+  NEAR_NETWORK_IDS,
+  NEAR_TESTNET_CAIP2,
+  NEAR_TESTNET_RPC,
+  NEP141_FT_BALANCE_OF,
+  NEP141_FT_TRANSFER,
+  NEP141_STORAGE_BALANCE_OF,
+  NEP141_STORAGE_DEPOSIT,
+  NETWORK_RPC_ENDPOINTS,
+  SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY,
+  extractNetworkId,
+  formatAmount,
+  getDefaultToken,
+  getNetworkTokens,
+  getRpcEndpoint,
+  getTokenByContract,
+  getTokenConfig,
+  isNetworkSupported,
+  isTransactionSuccessful,
+  isValidAccountId,
+  normalizeNetwork,
+  parseFtTransferArgs,
+  queryTokenBalance,
+  queryTransaction,
+  registerExactDirectNearClient,
+  registerExactDirectNearFacilitator,
+  registerExactDirectNearServer,
+  rpcCall,
+  toTokenUnits
+});
+//# sourceMappingURL=index.js.map