@t402/aptos 2.3.0

package/dist/index.js

@@ -0,0 +1,759 @@
+"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, {
+  APTOS_ACCOUNT_MODULE: () => APTOS_ACCOUNT_MODULE,
+  APTOS_CAIP2_NAMESPACE: () => APTOS_CAIP2_NAMESPACE,
+  APTOS_DEVNET_CAIP2: () => APTOS_DEVNET_CAIP2,
+  APTOS_DEVNET_CHAIN_ID: () => APTOS_DEVNET_CHAIN_ID,
+  APTOS_MAINNET_CAIP2: () => APTOS_MAINNET_CAIP2,
+  APTOS_MAINNET_CHAIN_ID: () => APTOS_MAINNET_CHAIN_ID,
+  APTOS_NETWORKS: () => APTOS_NETWORKS,
+  APTOS_TESTNET_CAIP2: () => APTOS_TESTNET_CAIP2,
+  APTOS_TESTNET_CHAIN_ID: () => APTOS_TESTNET_CHAIN_ID,
+  DEFAULT_DEVNET_RPC: () => DEFAULT_DEVNET_RPC,
+  DEFAULT_GAS_UNIT_PRICE: () => DEFAULT_GAS_UNIT_PRICE,
+  DEFAULT_MAINNET_RPC: () => DEFAULT_MAINNET_RPC,
+  DEFAULT_MAX_GAS_AMOUNT: () => DEFAULT_MAX_GAS_AMOUNT,
+  DEFAULT_TESTNET_RPC: () => DEFAULT_TESTNET_RPC,
+  DEFAULT_TOKEN_SYMBOL: () => DEFAULT_TOKEN_SYMBOL,
+  DEFAULT_TX_EXPIRATION_SECONDS: () => DEFAULT_TX_EXPIRATION_SECONDS,
+  ExactDirectAptosClient: () => ExactDirectAptosClient,
+  ExactDirectAptosFacilitator: () => ExactDirectAptosFacilitator,
+  ExactDirectAptosServer: () => ExactDirectAptosServer,
+  FA_TRANSFER_FUNCTION: () => FA_TRANSFER_FUNCTION,
+  FUNGIBLE_ASSET_MODULE: () => FUNGIBLE_ASSET_MODULE,
+  PRIMARY_FUNGIBLE_STORE_MODULE: () => PRIMARY_FUNGIBLE_STORE_MODULE,
+  SCHEME_EXACT_DIRECT: () => SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
+  compareAddresses: () => compareAddresses,
+  createAssetIdentifier: () => createAssetIdentifier,
+  extractChainId: () => extractChainId,
+  extractTransferDetails: () => extractTransferDetails,
+  formatAmount: () => formatAmount,
+  getDefaultRpcUrl: () => getDefaultRpcUrl,
+  getDefaultToken: () => getDefaultToken,
+  getSupportedTokens: () => getSupportedTokens,
+  getTokenByAddress: () => getTokenByAddress,
+  getTokenConfig: () => getTokenConfig,
+  isAptosNetwork: () => isAptosNetwork,
+  isFATransferTransaction: () => isFATransferTransaction,
+  isTokenSupported: () => isTokenSupported,
+  isValidAptosAddress: () => isValidAptosAddress,
+  isValidTxHash: () => isValidTxHash,
+  normalizeAptosAddress: () => normalizeAptosAddress,
+  parseAmount: () => parseAmount,
+  parseAssetIdentifier: () => parseAssetIdentifier,
+  parseFATransferFromEvents: () => parseFATransferFromEvents,
+  registerExactDirectAptosClient: () => registerExactDirectAptosClient,
+  registerExactDirectAptosFacilitator: () => registerExactDirectAptosFacilitator,
+  registerExactDirectAptosServer: () => registerExactDirectAptosServer
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var APTOS_CAIP2_NAMESPACE = "aptos";
+var APTOS_MAINNET_CAIP2 = "aptos:1";
+var APTOS_TESTNET_CAIP2 = "aptos:2";
+var APTOS_DEVNET_CAIP2 = "aptos:149";
+var APTOS_NETWORKS = [
+  APTOS_MAINNET_CAIP2,
+  APTOS_TESTNET_CAIP2,
+  APTOS_DEVNET_CAIP2
+];
+var APTOS_MAINNET_CHAIN_ID = 1;
+var APTOS_TESTNET_CHAIN_ID = 2;
+var APTOS_DEVNET_CHAIN_ID = 149;
+var DEFAULT_MAINNET_RPC = "https://fullnode.mainnet.aptoslabs.com/v1";
+var DEFAULT_TESTNET_RPC = "https://fullnode.testnet.aptoslabs.com/v1";
+var DEFAULT_DEVNET_RPC = "https://fullnode.devnet.aptoslabs.com/v1";
+var SCHEME_EXACT_DIRECT = "exact-direct";
+var PRIMARY_FUNGIBLE_STORE_MODULE = "0x1::primary_fungible_store";
+var FUNGIBLE_ASSET_MODULE = "0x1::fungible_asset";
+var APTOS_ACCOUNT_MODULE = "0x1::aptos_account";
+var FA_TRANSFER_FUNCTION = `${PRIMARY_FUNGIBLE_STORE_MODULE}::transfer`;
+var DEFAULT_MAX_GAS_AMOUNT = 100000n;
+var DEFAULT_GAS_UNIT_PRICE = 100n;
+var DEFAULT_TX_EXPIRATION_SECONDS = 600;
+
+// src/types.ts
+function extractChainId(network) {
+  const parts = network.split(":");
+  if (parts.length !== 2 || parts[0] !== "aptos") {
+    throw new Error(`Invalid Aptos network identifier: ${network}`);
+  }
+  const chainId = parseInt(parts[1], 10);
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid chain ID in network identifier: ${network}`);
+  }
+  return chainId;
+}
+
+// src/tokens.ts
+var TOKEN_REGISTRY = {
+  [APTOS_MAINNET_CAIP2]: [
+    {
+      metadataAddress: "0xf73e887a8754f540ee6e1a93bdc6dde2af69fc7ca5de32013e89dd44244473cb",
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6
+    },
+    {
+      metadataAddress: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6
+    }
+  ],
+  [APTOS_TESTNET_CAIP2]: [
+    {
+      // Testnet USDT (may differ from mainnet)
+      metadataAddress: "0xf73e887a8754f540ee6e1a93bdc6dde2af69fc7ca5de32013e89dd44244473cb",
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6
+    }
+  ],
+  [APTOS_DEVNET_CAIP2]: []
+};
+function getTokenConfig(network, symbol) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  return tokens.find(
+    (t) => t.symbol.toUpperCase() === symbol.toUpperCase()
+  );
+}
+function getSupportedTokens(network) {
+  return TOKEN_REGISTRY[network] || [];
+}
+function isTokenSupported(network, symbol) {
+  return getTokenConfig(network, symbol) !== void 0;
+}
+function getTokenByAddress(network, metadataAddress) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  const normalizedAddress = metadataAddress.toLowerCase();
+  return tokens.find(
+    (t) => t.metadataAddress.toLowerCase() === normalizedAddress
+  );
+}
+var DEFAULT_TOKEN_SYMBOL = "USDT";
+function getDefaultToken(network) {
+  return getTokenConfig(network, DEFAULT_TOKEN_SYMBOL);
+}
+
+// src/utils.ts
+function isValidAptosAddress(address) {
+  if (!address) return false;
+  if (!address.startsWith("0x")) return false;
+  const hex = address.slice(2);
+  if (hex.length === 0 || hex.length > 64) return false;
+  return /^[0-9a-fA-F]+$/.test(hex);
+}
+function normalizeAptosAddress(address) {
+  if (!address.startsWith("0x")) {
+    throw new Error("Aptos address must start with 0x");
+  }
+  const hex = address.slice(2).toLowerCase();
+  return "0x" + hex.padStart(64, "0");
+}
+function compareAddresses(addr1, addr2) {
+  try {
+    return normalizeAptosAddress(addr1) === normalizeAptosAddress(addr2);
+  } catch {
+    return false;
+  }
+}
+function isValidTxHash(txHash) {
+  if (!txHash) return false;
+  if (!txHash.startsWith("0x")) return false;
+  const hex = txHash.slice(2);
+  if (hex.length !== 64) return false;
+  return /^[0-9a-fA-F]+$/.test(hex);
+}
+function getDefaultRpcUrl(network) {
+  switch (network) {
+    case APTOS_MAINNET_CAIP2:
+      return DEFAULT_MAINNET_RPC;
+    case APTOS_TESTNET_CAIP2:
+      return DEFAULT_TESTNET_RPC;
+    case APTOS_DEVNET_CAIP2:
+      return DEFAULT_DEVNET_RPC;
+    default:
+      throw new Error(`Unknown Aptos network: ${network}`);
+  }
+}
+function isAptosNetwork(network) {
+  return network.startsWith(`${APTOS_CAIP2_NAMESPACE}:`);
+}
+function parseAssetIdentifier(asset) {
+  const parts = asset.split("/");
+  if (parts.length !== 2) return null;
+  const network = parts[0];
+  if (!isAptosNetwork(network)) return null;
+  const [assetType, address] = parts[1].split(":");
+  if (assetType !== "fa" || !address) return null;
+  if (!isValidAptosAddress(address)) return null;
+  return { network, metadataAddress: address };
+}
+function createAssetIdentifier(network, metadataAddress) {
+  return `${network}/fa:${metadataAddress}`;
+}
+function parseFATransferFromEvents(events) {
+  const withdrawEvent = events.find(
+    (e) => e.type === "0x1::fungible_asset::Withdraw" || e.type.includes("::fungible_asset::Withdraw")
+  );
+  const depositEvent = events.find(
+    (e) => e.type === "0x1::fungible_asset::Deposit" || e.type.includes("::fungible_asset::Deposit")
+  );
+  if (!withdrawEvent || !depositEvent) {
+    return null;
+  }
+  const withdrawData = withdrawEvent.data;
+  const depositData = depositEvent.data;
+  if (!withdrawData.amount || !depositData.store) {
+    return null;
+  }
+  const from = withdrawEvent.guid.accountAddress;
+  const to = depositEvent.guid.accountAddress;
+  const amount = BigInt(withdrawData.amount);
+  return {
+    from,
+    to,
+    amount,
+    metadataAddress: ""
+    // Will be filled from transaction details
+  };
+}
+function isFATransferTransaction(tx) {
+  if (!tx.payload) return false;
+  if (tx.payload.type !== "entry_function_payload") return false;
+  return tx.payload.function === FA_TRANSFER_FUNCTION || tx.payload.function?.includes("primary_fungible_store::transfer") || false;
+}
+function extractTransferDetails(tx) {
+  if (!tx.success) return null;
+  if (!tx.payload || tx.payload.type !== "entry_function_payload") return null;
+  const args = tx.payload.arguments;
+  if (!args || args.length < 3) return null;
+  const metadataAddress = args[0];
+  const to = args[1];
+  const amount = BigInt(args[2]);
+  return {
+    from: tx.sender,
+    to,
+    amount,
+    metadataAddress
+  };
+}
+function formatAmount(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const wholePart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const paddedFractional = fractionalPart.toString().padStart(decimals, "0");
+  return `${wholePart}.${paddedFractional}`;
+}
+function parseAmount(amount, decimals) {
+  const [whole, fractional = ""] = amount.split(".");
+  const paddedFractional = fractional.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole + paddedFractional);
+}
+
+// src/exact-direct/client/scheme.ts
+var ExactDirectAptosClient = class {
+  constructor(signer, config = {}) {
+    this.signer = signer;
+    void config;
+  }
+  scheme = SCHEME_EXACT_DIRECT;
+  /**
+   * Create a payment payload by executing the transfer
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    this.validateRequirements(paymentRequirements);
+    const from = await this.signer.getAddress();
+    const assetInfo = parseAssetIdentifier(paymentRequirements.asset);
+    if (!assetInfo) {
+      throw new Error(`Invalid asset identifier: ${paymentRequirements.asset}`);
+    }
+    const amount = BigInt(paymentRequirements.amount);
+    const balance = await this.signer.getBalance(assetInfo.metadataAddress);
+    if (balance < amount) {
+      throw new Error(
+        `Insufficient balance: have ${balance}, need ${amount}`
+      );
+    }
+    const txHash = await this.signer.transfer(
+      paymentRequirements.payTo,
+      assetInfo.metadataAddress,
+      amount
+    );
+    const payload = {
+      txHash,
+      from,
+      to: paymentRequirements.payTo,
+      amount: paymentRequirements.amount,
+      metadataAddress: assetInfo.metadataAddress
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+  /**
+   * Validate payment requirements
+   */
+  validateRequirements(requirements) {
+    if (requirements.scheme !== SCHEME_EXACT_DIRECT) {
+      throw new Error(
+        `Invalid scheme: expected ${SCHEME_EXACT_DIRECT}, got ${requirements.scheme}`
+      );
+    }
+    if (!requirements.network.startsWith(`${APTOS_CAIP2_NAMESPACE}:`)) {
+      throw new Error(`Invalid network: ${requirements.network}`);
+    }
+    if (!isValidAptosAddress(requirements.payTo)) {
+      throw new Error(`Invalid payTo address: ${requirements.payTo}`);
+    }
+    const amount = BigInt(requirements.amount);
+    if (amount <= 0n) {
+      throw new Error(`Invalid amount: ${requirements.amount}`);
+    }
+    const assetInfo = parseAssetIdentifier(requirements.asset);
+    if (!assetInfo) {
+      throw new Error(`Invalid asset: ${requirements.asset}`);
+    }
+    const tokenConfig = getTokenConfig(requirements.network, "USDT");
+    if (tokenConfig && !compareAddresses(tokenConfig.metadataAddress, assetInfo.metadataAddress)) {
+      console.warn(
+        `Using non-standard token: ${assetInfo.metadataAddress}`
+      );
+    }
+  }
+};
+
+// src/exact-direct/client/register.ts
+function registerExactDirectAptosClient(client, config) {
+  const scheme = new ExactDirectAptosClient(config.signer, config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("aptos:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/exact-direct/server/scheme.ts
+var ExactDirectAptosServer = class {
+  scheme = SCHEME_EXACT_DIRECT;
+  moneyParsers = [];
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parse price into Aptos-specific amount
+   */
+  async parsePrice(price, network) {
+    if (!isAptosNetwork(network)) {
+      throw new Error(`Invalid Aptos network: ${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, network);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount, network);
+  }
+  /**
+   * Enhance payment requirements with Aptos-specific details
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, facilitatorExtensions) {
+    void facilitatorExtensions;
+    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.
+   */
+  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.
+   */
+  defaultMoneyConversion(amount, network) {
+    const token = this.getDefaultAsset(network);
+    const tokenAmount = parseAmount(amount.toString(), token.decimals);
+    return {
+      amount: tokenAmount.toString(),
+      asset: createAssetIdentifier(network, token.metadataAddress),
+      extra: {
+        symbol: token.symbol,
+        name: token.name,
+        decimals: token.decimals
+      }
+    };
+  }
+  /**
+   * Get the default asset info for a network.
+   */
+  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 registerExactDirectAptosServer(server, config = {}) {
+  const scheme = new ExactDirectAptosServer(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("aptos:*", scheme);
+  }
+  return server;
+}
+
+// src/exact-direct/facilitator/scheme.ts
+var ExactDirectAptosFacilitator = class {
+  constructor(signer, config) {
+    this.signer = signer;
+    this.config = {
+      maxTransactionAge: config?.maxTransactionAge ?? 3600,
+      usedTxCacheDuration: config?.usedTxCacheDuration ?? 24 * 60 * 60 * 1e3
+      // 24 hours
+    };
+    this.startCleanupInterval();
+  }
+  scheme = SCHEME_EXACT_DIRECT;
+  caipFamily = `${APTOS_CAIP2_NAMESPACE}:*`;
+  config;
+  usedTxs = /* @__PURE__ */ new Map();
+  /**
+   * 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 facilitator signer addresses for a network
+   */
+  getSigners(network) {
+    return this.signer.getAddresses(network);
+  }
+  /**
+   * Verify a payment payload
+   */
+  async verify(payload, requirements) {
+    if (payload.accepted.scheme !== SCHEME_EXACT_DIRECT) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_scheme"
+      };
+    }
+    if (!isAptosNetwork(payload.accepted.network)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_network"
+      };
+    }
+    const aptosPayload = payload.payload;
+    if (!isValidTxHash(aptosPayload.txHash)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_tx_hash_format"
+      };
+    }
+    if (this.isTxUsed(aptosPayload.txHash)) {
+      return {
+        isValid: false,
+        invalidReason: "transaction_already_used",
+        payer: aptosPayload.from
+      };
+    }
+    try {
+      const tx = await this.signer.queryTransaction(aptosPayload.txHash);
+      if (!tx) {
+        return {
+          isValid: false,
+          invalidReason: "transaction_not_found",
+          payer: aptosPayload.from
+        };
+      }
+      if (!tx.success) {
+        return {
+          isValid: false,
+          invalidReason: `transaction_failed: ${tx.vmStatus}`,
+          payer: aptosPayload.from
+        };
+      }
+      if (this.config.maxTransactionAge > 0) {
+        const txTimestamp = parseInt(tx.timestamp, 10) / 1e6;
+        const now = Date.now() / 1e3;
+        const age = now - txTimestamp;
+        if (age > this.config.maxTransactionAge) {
+          return {
+            isValid: false,
+            invalidReason: `transaction_too_old: ${Math.round(age)} seconds`,
+            payer: aptosPayload.from
+          };
+        }
+      }
+      const transferDetails = extractTransferDetails(tx);
+      if (!transferDetails) {
+        return {
+          isValid: false,
+          invalidReason: "could_not_extract_transfer_details",
+          payer: aptosPayload.from
+        };
+      }
+      const expectedAsset = parseAssetIdentifier(requirements.asset);
+      if (!expectedAsset) {
+        return {
+          isValid: false,
+          invalidReason: `invalid_asset_in_requirements: ${requirements.asset}`,
+          payer: aptosPayload.from
+        };
+      }
+      if (!compareAddresses(transferDetails.to, requirements.payTo)) {
+        return {
+          isValid: false,
+          invalidReason: `recipient_mismatch: expected ${requirements.payTo}, got ${transferDetails.to}`,
+          payer: aptosPayload.from
+        };
+      }
+      if (!compareAddresses(
+        transferDetails.metadataAddress,
+        expectedAsset.metadataAddress
+      )) {
+        return {
+          isValid: false,
+          invalidReason: `token_mismatch: expected ${expectedAsset.metadataAddress}, got ${transferDetails.metadataAddress}`,
+          payer: aptosPayload.from
+        };
+      }
+      const expectedAmount = BigInt(requirements.amount);
+      if (transferDetails.amount < expectedAmount) {
+        return {
+          isValid: false,
+          invalidReason: `insufficient_amount: expected ${expectedAmount}, got ${transferDetails.amount}`,
+          payer: aptosPayload.from
+        };
+      }
+      this.markTxUsed(aptosPayload.txHash);
+      return {
+        isValid: true,
+        payer: transferDetails.from
+      };
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `verification_error: ${error instanceof Error ? error.message : String(error)}`,
+        payer: aptosPayload.from
+      };
+    }
+  }
+  /**
+   * Settle a payment (no-op for exact-direct since client already executed)
+   */
+  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: requirements.network
+      };
+    }
+    const aptosPayload = payload.payload;
+    return {
+      success: true,
+      transaction: aptosPayload.txHash,
+      network: requirements.network,
+      payer: aptosPayload.from
+    };
+  }
+  /**
+   * Check if a transaction has been used
+   */
+  isTxUsed(txHash) {
+    return this.usedTxs.has(txHash.toLowerCase());
+  }
+  /**
+   * Mark a transaction as used
+   */
+  markTxUsed(txHash) {
+    this.usedTxs.set(txHash.toLowerCase(), 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 registerExactDirectAptosFacilitator(facilitator, config) {
+  const scheme = new ExactDirectAptosFacilitator(
+    config.signer,
+    config.schemeConfig
+  );
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      facilitator.register(network, scheme);
+    });
+  } else {
+    facilitator.register("aptos:*", scheme);
+  }
+  return facilitator;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APTOS_ACCOUNT_MODULE,
+  APTOS_CAIP2_NAMESPACE,
+  APTOS_DEVNET_CAIP2,
+  APTOS_DEVNET_CHAIN_ID,
+  APTOS_MAINNET_CAIP2,
+  APTOS_MAINNET_CHAIN_ID,
+  APTOS_NETWORKS,
+  APTOS_TESTNET_CAIP2,
+  APTOS_TESTNET_CHAIN_ID,
+  DEFAULT_DEVNET_RPC,
+  DEFAULT_GAS_UNIT_PRICE,
+  DEFAULT_MAINNET_RPC,
+  DEFAULT_MAX_GAS_AMOUNT,
+  DEFAULT_TESTNET_RPC,
+  DEFAULT_TOKEN_SYMBOL,
+  DEFAULT_TX_EXPIRATION_SECONDS,
+  ExactDirectAptosClient,
+  ExactDirectAptosFacilitator,
+  ExactDirectAptosServer,
+  FA_TRANSFER_FUNCTION,
+  FUNGIBLE_ASSET_MODULE,
+  PRIMARY_FUNGIBLE_STORE_MODULE,
+  SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY,
+  compareAddresses,
+  createAssetIdentifier,
+  extractChainId,
+  extractTransferDetails,
+  formatAmount,
+  getDefaultRpcUrl,
+  getDefaultToken,
+  getSupportedTokens,
+  getTokenByAddress,
+  getTokenConfig,
+  isAptosNetwork,
+  isFATransferTransaction,
+  isTokenSupported,
+  isValidAptosAddress,
+  isValidTxHash,
+  normalizeAptosAddress,
+  parseAmount,
+  parseAssetIdentifier,
+  parseFATransferFromEvents,
+  registerExactDirectAptosClient,
+  registerExactDirectAptosFacilitator,
+  registerExactDirectAptosServer
+});
+//# sourceMappingURL=index.js.map