@t402/tron 1.0.0

package/dist/cjs/index.js

@@ -0,0 +1,863 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/constants.ts
+var TRON_MAINNET_CAIP2, TRON_NILE_CAIP2, TRON_SHASTA_CAIP2, TRON_NETWORKS, TRON_MAINNET_ENDPOINT, TRON_NILE_ENDPOINT, TRON_SHASTA_ENDPOINT, NETWORK_ENDPOINTS, TRC20_TRANSFER_SELECTOR, TRC20_APPROVE_SELECTOR, TRC20_BALANCE_OF_SELECTOR, DEFAULT_FEE_LIMIT, MIN_FEE_LIMIT, MAX_FEE_LIMIT, SUN_PER_TRX, SCHEME_EXACT, DEFAULT_VALIDITY_DURATION, MIN_VALIDITY_BUFFER, TRON_ADDRESS_PREFIX, TRON_ADDRESS_LENGTH, TRON_ADDRESS_HEX_PREFIX, USDT_ADDRESSES, DEFAULT_USDT_DECIMALS, DEFAULT_TRX_DECIMALS;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    TRON_MAINNET_CAIP2 = "tron:mainnet";
+    TRON_NILE_CAIP2 = "tron:nile";
+    TRON_SHASTA_CAIP2 = "tron:shasta";
+    TRON_NETWORKS = [TRON_MAINNET_CAIP2, TRON_NILE_CAIP2, TRON_SHASTA_CAIP2];
+    TRON_MAINNET_ENDPOINT = "https://api.trongrid.io";
+    TRON_NILE_ENDPOINT = "https://api.nileex.io";
+    TRON_SHASTA_ENDPOINT = "https://api.shasta.trongrid.io";
+    NETWORK_ENDPOINTS = {
+      [TRON_MAINNET_CAIP2]: TRON_MAINNET_ENDPOINT,
+      [TRON_NILE_CAIP2]: TRON_NILE_ENDPOINT,
+      [TRON_SHASTA_CAIP2]: TRON_SHASTA_ENDPOINT
+    };
+    TRC20_TRANSFER_SELECTOR = "a9059cbb";
+    TRC20_APPROVE_SELECTOR = "095ea7b3";
+    TRC20_BALANCE_OF_SELECTOR = "70a08231";
+    DEFAULT_FEE_LIMIT = 1e8;
+    MIN_FEE_LIMIT = 1e7;
+    MAX_FEE_LIMIT = 1e9;
+    SUN_PER_TRX = 1e6;
+    SCHEME_EXACT = "exact";
+    DEFAULT_VALIDITY_DURATION = 3600;
+    MIN_VALIDITY_BUFFER = 30;
+    TRON_ADDRESS_PREFIX = "T";
+    TRON_ADDRESS_LENGTH = 34;
+    TRON_ADDRESS_HEX_PREFIX = 65;
+    USDT_ADDRESSES = {
+      [TRON_MAINNET_CAIP2]: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      [TRON_NILE_CAIP2]: "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf",
+      [TRON_SHASTA_CAIP2]: "TG3XXyExBkPp9nzdajDZsozEu4BkaSJozs"
+    };
+    DEFAULT_USDT_DECIMALS = 6;
+    DEFAULT_TRX_DECIMALS = 6;
+  }
+});
+
+// src/tokens.ts
+var tokens_exports = {};
+__export(tokens_exports, {
+  TRC20_REGISTRY: () => TRC20_REGISTRY,
+  getDefaultToken: () => getDefaultToken,
+  getNetworkTokens: () => getNetworkTokens,
+  getNetworksForToken: () => getNetworksForToken,
+  getSupportedNetworks: () => getSupportedNetworks,
+  getTRC20Config: () => getTRC20Config,
+  getTokenByAddress: () => getTokenByAddress,
+  getUsdtNetworks: () => getUsdtNetworks,
+  isNetworkSupported: () => isNetworkSupported
+});
+function getTRC20Config(network, symbol) {
+  const registry = TRC20_REGISTRY[network];
+  if (!registry) return void 0;
+  return registry.tokens[symbol];
+}
+function getNetworkTokens(network) {
+  const registry = TRC20_REGISTRY[network];
+  if (!registry) return [];
+  return Object.values(registry.tokens);
+}
+function getDefaultToken(network) {
+  const registry = TRC20_REGISTRY[network];
+  return registry?.defaultToken;
+}
+function getTokenByAddress(network, contractAddress) {
+  const registry = TRC20_REGISTRY[network];
+  if (!registry) return void 0;
+  const upperAddress = contractAddress.toUpperCase();
+  return Object.values(registry.tokens).find(
+    (token) => token.contractAddress.toUpperCase() === upperAddress
+  );
+}
+function getNetworksForToken(symbol) {
+  return Object.entries(TRC20_REGISTRY).filter(([_, registry]) => symbol in registry.tokens).map(([network]) => network);
+}
+function getUsdtNetworks() {
+  return getNetworksForToken("USDT");
+}
+function isNetworkSupported(network) {
+  return network in TRC20_REGISTRY;
+}
+function getSupportedNetworks() {
+  return Object.keys(TRC20_REGISTRY);
+}
+var USDT_MAINNET, USDT_NILE, USDT_SHASTA, TRC20_REGISTRY;
+var init_tokens = __esm({
+  "src/tokens.ts"() {
+    "use strict";
+    init_constants();
+    USDT_MAINNET = {
+      contractAddress: USDT_ADDRESSES[TRON_MAINNET_CAIP2],
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: DEFAULT_USDT_DECIMALS
+    };
+    USDT_NILE = {
+      contractAddress: USDT_ADDRESSES[TRON_NILE_CAIP2],
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: DEFAULT_USDT_DECIMALS
+    };
+    USDT_SHASTA = {
+      contractAddress: USDT_ADDRESSES[TRON_SHASTA_CAIP2],
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: DEFAULT_USDT_DECIMALS
+    };
+    TRC20_REGISTRY = {
+      [TRON_MAINNET_CAIP2]: {
+        network: TRON_MAINNET_CAIP2,
+        defaultToken: USDT_MAINNET,
+        tokens: {
+          USDT: USDT_MAINNET
+        }
+      },
+      [TRON_NILE_CAIP2]: {
+        network: TRON_NILE_CAIP2,
+        defaultToken: USDT_NILE,
+        tokens: {
+          USDT: USDT_NILE
+        }
+      },
+      [TRON_SHASTA_CAIP2]: {
+        network: TRON_SHASTA_CAIP2,
+        defaultToken: USDT_SHASTA,
+        tokens: {
+          USDT: USDT_SHASTA
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_FEE_LIMIT: () => DEFAULT_FEE_LIMIT,
+  DEFAULT_TRX_DECIMALS: () => DEFAULT_TRX_DECIMALS,
+  DEFAULT_USDT_DECIMALS: () => DEFAULT_USDT_DECIMALS,
+  DEFAULT_VALIDITY_DURATION: () => DEFAULT_VALIDITY_DURATION,
+  ExactTronClientScheme: () => ExactTronScheme,
+  ExactTronFacilitatorScheme: () => ExactTronScheme3,
+  ExactTronServerScheme: () => ExactTronScheme2,
+  MAX_FEE_LIMIT: () => MAX_FEE_LIMIT,
+  MIN_FEE_LIMIT: () => MIN_FEE_LIMIT,
+  MIN_VALIDITY_BUFFER: () => MIN_VALIDITY_BUFFER,
+  NETWORK_ENDPOINTS: () => NETWORK_ENDPOINTS,
+  SCHEME_EXACT: () => SCHEME_EXACT,
+  SUN_PER_TRX: () => SUN_PER_TRX,
+  TRC20_APPROVE_SELECTOR: () => TRC20_APPROVE_SELECTOR,
+  TRC20_BALANCE_OF_SELECTOR: () => TRC20_BALANCE_OF_SELECTOR,
+  TRC20_REGISTRY: () => TRC20_REGISTRY,
+  TRC20_TRANSFER_SELECTOR: () => TRC20_TRANSFER_SELECTOR,
+  TRON_ADDRESS_HEX_PREFIX: () => TRON_ADDRESS_HEX_PREFIX,
+  TRON_ADDRESS_LENGTH: () => TRON_ADDRESS_LENGTH,
+  TRON_ADDRESS_PREFIX: () => TRON_ADDRESS_PREFIX,
+  TRON_MAINNET_CAIP2: () => TRON_MAINNET_CAIP2,
+  TRON_NETWORKS: () => TRON_NETWORKS,
+  TRON_NILE_CAIP2: () => TRON_NILE_CAIP2,
+  TRON_SHASTA_CAIP2: () => TRON_SHASTA_CAIP2,
+  USDT_ADDRESSES: () => USDT_ADDRESSES,
+  addressesEqual: () => addressesEqual,
+  calculateExpiration: () => calculateExpiration,
+  convertFromSmallestUnits: () => convertFromSmallestUnits,
+  convertToSmallestUnits: () => convertToSmallestUnits,
+  estimateTransactionFee: () => estimateTransactionFee,
+  formatAddress: () => formatAddress,
+  generatePaymentReference: () => generatePaymentReference,
+  getDefaultToken: () => getDefaultToken,
+  getEndpoint: () => getEndpoint,
+  getNetworkTokens: () => getNetworkTokens,
+  getNetworksForToken: () => getNetworksForToken,
+  getSupportedNetworks: () => getSupportedNetworks,
+  getTRC20Config: () => getTRC20Config,
+  getTokenByAddress: () => getTokenByAddress,
+  getUsdtNetworks: () => getUsdtNetworks,
+  isNetworkSupported: () => isNetworkSupported,
+  isTronNetwork: () => isTronNetwork,
+  isValidHex: () => isValidHex,
+  normalizeNetwork: () => normalizeNetwork,
+  registerExactTronClientScheme: () => registerExactTronScheme,
+  registerExactTronFacilitatorScheme: () => registerExactTronScheme3,
+  registerExactTronServerScheme: () => registerExactTronScheme2,
+  validateTronAddress: () => validateTronAddress
+});
+module.exports = __toCommonJS(src_exports);
+init_constants();
+init_tokens();
+
+// src/utils.ts
+init_constants();
+function normalizeNetwork(network) {
+  if (TRON_NETWORKS.includes(network)) {
+    return network;
+  }
+  const lower = network.toLowerCase();
+  if (lower === "mainnet" || lower === "tron") {
+    return "tron:mainnet";
+  }
+  if (lower === "nile" || lower === "tron-nile") {
+    return "tron:nile";
+  }
+  if (lower === "shasta" || lower === "tron-shasta") {
+    return "tron:shasta";
+  }
+  throw new Error(`Unsupported TRON network: ${network}`);
+}
+function getEndpoint(network) {
+  const normalized = normalizeNetwork(network);
+  const endpoint = NETWORK_ENDPOINTS[normalized];
+  if (!endpoint) {
+    throw new Error(`No endpoint configured for network: ${network}`);
+  }
+  return endpoint;
+}
+function isTronNetwork(network) {
+  try {
+    normalizeNetwork(network);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function validateTronAddress(address) {
+  if (!address || address.length !== TRON_ADDRESS_LENGTH) {
+    return false;
+  }
+  if (!address.startsWith(TRON_ADDRESS_PREFIX)) {
+    return false;
+  }
+  for (const char of address) {
+    if (!BASE58_ALPHABET.includes(char)) {
+      return false;
+    }
+  }
+  return true;
+}
+function addressesEqual(addr1, addr2) {
+  if (!addr1 || !addr2) return false;
+  return addr1 === addr2;
+}
+function formatAddress(address, options) {
+  if (!address) return "";
+  if (options?.truncate && address.length > options.truncate * 2 + 3) {
+    return `${address.slice(0, options.truncate)}...${address.slice(-options.truncate)}`;
+  }
+  return address;
+}
+function convertToSmallestUnits(decimalAmount, decimals = DEFAULT_USDT_DECIMALS) {
+  const parts = decimalAmount.split(".");
+  const wholePart = parts[0] || "0";
+  let fractionalPart = parts[1] || "";
+  if (fractionalPart.length > decimals) {
+    fractionalPart = fractionalPart.slice(0, decimals);
+  } else {
+    fractionalPart = fractionalPart.padEnd(decimals, "0");
+  }
+  const result = (wholePart + fractionalPart).replace(/^0+/, "") || "0";
+  return result;
+}
+function convertFromSmallestUnits(smallestUnits, decimals = DEFAULT_USDT_DECIMALS) {
+  const padded = smallestUnits.padStart(decimals + 1, "0");
+  const wholePart = padded.slice(0, -decimals) || "0";
+  const fractionalPart = padded.slice(-decimals);
+  const trimmedFractional = fractionalPart.replace(/0+$/, "");
+  if (trimmedFractional) {
+    return `${wholePart}.${trimmedFractional}`;
+  }
+  return wholePart;
+}
+function generatePaymentReference() {
+  const timestamp = Date.now();
+  const random = Math.floor(Math.random() * 1e6);
+  return `t402_${timestamp}_${random}`;
+}
+function calculateExpiration(validitySeconds) {
+  return Date.now() + validitySeconds * 1e3;
+}
+function isValidHex(hex) {
+  if (!hex) return false;
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return /^[0-9a-fA-F]+$/.test(cleanHex);
+}
+function estimateTransactionFee(isActivated = true) {
+  const baseFee = 3e7;
+  const activationFee = isActivated ? 0 : 1e6;
+  return baseFee + activationFee;
+}
+
+// src/exact/client/scheme.ts
+init_constants();
+var ExactTronScheme = class {
+  constructor(signer, config) {
+    this.scheme = SCHEME_EXACT;
+    this.signer = signer;
+    this.config = config ?? {};
+  }
+  /**
+   * Creates a payment payload for a TRC20 transfer
+   *
+   * @param t402Version - Protocol version (must be 2)
+   * @param requirements - Payment requirements from server
+   * @returns Payment payload with signed transaction
+   */
+  async createPaymentPayload(t402Version, requirements) {
+    const network = normalizeNetwork(String(requirements.network));
+    if (!requirements.asset) {
+      throw new Error("Asset (TRC20 contract address) is required");
+    }
+    if (!requirements.payTo) {
+      throw new Error("PayTo address is required");
+    }
+    if (!requirements.amount) {
+      throw new Error("Amount is required");
+    }
+    if (!validateTronAddress(requirements.asset)) {
+      throw new Error(`Invalid TRC20 contract address: ${requirements.asset}`);
+    }
+    if (!validateTronAddress(requirements.payTo)) {
+      throw new Error(`Invalid payTo address: ${requirements.payTo}`);
+    }
+    if (!validateTronAddress(this.signer.address)) {
+      throw new Error(`Invalid signer address: ${this.signer.address}`);
+    }
+    const blockInfo = await this.signer.getBlockInfo();
+    const expiration = blockInfo.expiration;
+    const feeLimit = this.config.feeLimit ?? DEFAULT_FEE_LIMIT;
+    const signedTransaction = await this.signer.signTransaction({
+      contractAddress: requirements.asset,
+      to: requirements.payTo,
+      amount: requirements.amount,
+      feeLimit,
+      expiration
+    });
+    const authorization = {
+      from: this.signer.address,
+      to: requirements.payTo,
+      contractAddress: requirements.asset,
+      amount: requirements.amount,
+      expiration,
+      refBlockBytes: blockInfo.refBlockBytes,
+      refBlockHash: blockInfo.refBlockHash,
+      timestamp: Date.now()
+    };
+    const payload = {
+      signedTransaction,
+      authorization
+    };
+    void network;
+    return {
+      t402Version,
+      payload
+    };
+  }
+};
+
+// src/exact/client/register.ts
+function registerExactTronScheme(client, config) {
+  const scheme = new ExactTronScheme(config.signer, config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("tron:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
+}
+
+// src/exact/server/scheme.ts
+init_constants();
+init_tokens();
+var ExactTronScheme2 = class {
+  constructor(config) {
+    this.scheme = SCHEME_EXACT;
+    this.moneyParsers = [];
+    this.config = config ?? {};
+  }
+  /**
+   * Register a custom money parser
+   *
+   * Parsers are tried in registration order. Return null to pass to next parser.
+   *
+   * @param parser - Money parser function
+   * @returns This scheme for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parse a price into an asset amount
+   *
+   * @param price - Price to parse (string, number, or AssetAmount)
+   * @param network - Target network
+   * @returns Parsed asset amount
+   */
+  async parsePrice(price, network) {
+    const normalizedNetwork = normalizeNetwork(String(network));
+    if (!isNetworkSupported(normalizedNetwork)) {
+      throw new Error(`Unsupported network: ${network}`);
+    }
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      const assetAmount = price;
+      return {
+        amount: assetAmount.amount,
+        asset: assetAmount.asset || this.getDefaultAsset(normalizedNetwork),
+        extra: assetAmount.extra
+      };
+    }
+    const decimalAmount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      try {
+        const result = await parser(decimalAmount, network);
+        if (result !== null) {
+          return result;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return this.defaultMoneyConversion(decimalAmount, normalizedNetwork);
+  }
+  /**
+   * Enhance payment requirements with scheme-specific data
+   *
+   * @param requirements - Base payment requirements
+   * @param supportedKind - Supported payment kind
+   * @param extensionKeys - Extension keys to include
+   * @returns Enhanced payment requirements
+   */
+  async enhancePaymentRequirements(requirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const network = normalizeNetwork(String(requirements.network));
+    let tokenConfig = requirements.asset ? getTRC20Config(network, requirements.asset) || this.getTokenByAddress(network, requirements.asset) : getDefaultToken(network);
+    if (!tokenConfig) {
+      tokenConfig = getDefaultToken(network);
+    }
+    const extra = { ...requirements.extra };
+    if (tokenConfig) {
+      extra.symbol = tokenConfig.symbol;
+      extra.name = tokenConfig.name;
+      extra.decimals = tokenConfig.decimals;
+    }
+    if (supportedKind.extra) {
+      for (const key of extensionKeys) {
+        if (key in supportedKind.extra) {
+          extra[key] = supportedKind.extra[key];
+        }
+      }
+    }
+    return {
+      ...requirements,
+      asset: tokenConfig?.contractAddress || requirements.asset,
+      extra
+    };
+  }
+  /**
+   * Parse money (string/number) to decimal number
+   */
+  parseMoneyToDecimal(price) {
+    if (typeof price === "number") {
+      return price;
+    }
+    if (typeof price === "string") {
+      let cleanPrice = price.trim();
+      cleanPrice = cleanPrice.replace(/^\$/, "").trim();
+      const parts = cleanPrice.split(/\s+/);
+      const numericPart = parts[0];
+      const parsed = parseFloat(numericPart);
+      if (isNaN(parsed)) {
+        throw new Error(`Failed to parse price: ${price}`);
+      }
+      return parsed;
+    }
+    throw new Error(`Invalid price type: ${typeof price}`);
+  }
+  /**
+   * Default money to asset conversion (USDT)
+   */
+  defaultMoneyConversion(decimalAmount, network) {
+    const tokenConfig = getDefaultToken(network);
+    if (!tokenConfig) {
+      throw new Error(`No default token for network: ${network}`);
+    }
+    const amount = convertToSmallestUnits(decimalAmount.toFixed(6), tokenConfig.decimals);
+    return {
+      amount,
+      asset: tokenConfig.contractAddress,
+      extra: {
+        symbol: tokenConfig.symbol,
+        name: tokenConfig.name,
+        decimals: tokenConfig.decimals
+      }
+    };
+  }
+  /**
+   * Get default asset address for network
+   */
+  getDefaultAsset(network) {
+    const tokenConfig = getDefaultToken(network);
+    if (!tokenConfig) {
+      throw new Error(`No default token for network: ${network}`);
+    }
+    return tokenConfig.contractAddress;
+  }
+  /**
+   * Get token config by contract address
+   */
+  getTokenByAddress(network, address) {
+    const { getTokenByAddress: getTokenByAddress2 } = (init_tokens(), __toCommonJS(tokens_exports));
+    return getTokenByAddress2(network, address);
+  }
+};
+
+// src/exact/server/register.ts
+function registerExactTronScheme2(server, config = {}) {
+  const scheme = new ExactTronScheme2(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("tron:*", scheme);
+  }
+  return server;
+}
+
+// src/exact/facilitator/scheme.ts
+init_constants();
+var ExactTronScheme3 = class {
+  constructor(signer, config) {
+    this.scheme = SCHEME_EXACT;
+    this.caipFamily = "tron:*";
+    this.signer = signer;
+    this.config = config ?? {};
+  }
+  /**
+   * Get extra data to include in payment requirements
+   */
+  getExtra(network) {
+    void network;
+    if (this.config.canSponsorGas) {
+      const addresses = this.signer.getAddresses();
+      if (addresses.length > 0) {
+        return {
+          gasSponsor: addresses[0]
+        };
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get facilitator addresses that can receive payments
+   */
+  getSigners(network) {
+    void network;
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verify a payment payload
+   *
+   * Performs comprehensive validation:
+   * 1. Scheme matching
+   * 2. Network matching
+   * 3. Payload structure validation
+   * 4. Transaction signature verification
+   * 5. Authorization expiry check
+   * 6. Balance verification
+   * 7. Amount sufficiency
+   * 8. Recipient matching
+   * 9. Contract address matching
+   * 10. Account activation check
+   */
+  async verify(payload, requirements) {
+    const tronPayload = payload.payload;
+    const authorization = tronPayload.authorization;
+    if (payload.accepted.scheme !== SCHEME_EXACT || requirements.scheme !== SCHEME_EXACT) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: authorization.from
+      };
+    }
+    let payloadNetwork;
+    try {
+      payloadNetwork = normalizeNetwork(String(payload.accepted.network));
+      const requirementsNetwork = normalizeNetwork(String(requirements.network));
+      if (payloadNetwork !== requirementsNetwork) {
+        return {
+          isValid: false,
+          invalidReason: "network_mismatch",
+          payer: authorization.from
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "invalid_network",
+        payer: authorization.from
+      };
+    }
+    if (!tronPayload || !tronPayload.signedTransaction || !authorization) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_payload_structure",
+        payer: authorization?.from || ""
+      };
+    }
+    if (!validateTronAddress(authorization.from)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_sender_address",
+        payer: authorization.from
+      };
+    }
+    if (!validateTronAddress(authorization.to)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_recipient_address",
+        payer: authorization.from
+      };
+    }
+    if (!validateTronAddress(authorization.contractAddress)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_contract_address",
+        payer: authorization.from
+      };
+    }
+    const verifyResult = await this.signer.verifyTransaction({
+      signedTransaction: tronPayload.signedTransaction,
+      expectedFrom: authorization.from,
+      expectedTransfer: {
+        to: authorization.to,
+        contractAddress: authorization.contractAddress,
+        amount: authorization.amount
+      },
+      network: payloadNetwork
+    });
+    if (!verifyResult.valid) {
+      return {
+        isValid: false,
+        invalidReason: verifyResult.reason || "transaction_verification_failed",
+        payer: authorization.from
+      };
+    }
+    const now = Date.now();
+    const expirationWithBuffer = authorization.expiration - MIN_VALIDITY_BUFFER * 1e3;
+    if (now >= expirationWithBuffer) {
+      return {
+        isValid: false,
+        invalidReason: "authorization_expired",
+        payer: authorization.from
+      };
+    }
+    try {
+      const balance = await this.signer.getBalance({
+        ownerAddress: authorization.from,
+        contractAddress: authorization.contractAddress,
+        network: payloadNetwork
+      });
+      if (BigInt(balance) < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_balance",
+          payer: authorization.from
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify balance:", error);
+    }
+    if (BigInt(authorization.amount) < BigInt(requirements.amount)) {
+      return {
+        isValid: false,
+        invalidReason: "insufficient_amount",
+        payer: authorization.from
+      };
+    }
+    if (!addressesEqual(authorization.to, requirements.payTo)) {
+      return {
+        isValid: false,
+        invalidReason: "recipient_mismatch",
+        payer: authorization.from
+      };
+    }
+    if (!addressesEqual(authorization.contractAddress, requirements.asset)) {
+      return {
+        isValid: false,
+        invalidReason: "asset_mismatch",
+        payer: authorization.from
+      };
+    }
+    try {
+      const isActivated = await this.signer.isActivated(authorization.from, payloadNetwork);
+      if (!isActivated) {
+        return {
+          isValid: false,
+          invalidReason: "account_not_activated",
+          payer: authorization.from
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify account activation:", error);
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: authorization.from
+    };
+  }
+  /**
+   * Settle a verified payment
+   *
+   * Broadcasts the transaction and waits for confirmation.
+   */
+  async settle(payload, requirements) {
+    const tronPayload = payload.payload;
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: verifyResult.invalidReason ?? "verification_failed",
+        payer: tronPayload.authorization.from
+      };
+    }
+    try {
+      const network = normalizeNetwork(String(payload.accepted.network));
+      const txId = await this.signer.broadcastTransaction(
+        tronPayload.signedTransaction,
+        network
+      );
+      const confirmation = await this.signer.waitForTransaction({
+        txId,
+        network,
+        timeout: 6e4
+        // 60 seconds
+      });
+      if (!confirmation.success) {
+        return {
+          success: false,
+          network: payload.accepted.network,
+          transaction: txId,
+          errorReason: confirmation.error || "transaction_not_confirmed",
+          payer: tronPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: confirmation.txId || txId,
+        network: payload.accepted.network,
+        payer: tronPayload.authorization.from
+      };
+    } catch (error) {
+      console.error("Failed to settle TRON transaction:", error);
+      return {
+        success: false,
+        network: payload.accepted.network,
+        transaction: "",
+        errorReason: "transaction_failed",
+        payer: tronPayload.authorization.from
+      };
+    }
+  }
+};
+
+// src/exact/facilitator/register.ts
+function registerExactTronScheme3(facilitator, config) {
+  const scheme = new ExactTronScheme3(config.signer, config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      facilitator.register(network, scheme);
+    });
+  } else {
+    facilitator.register("tron:*", scheme);
+  }
+  return facilitator;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FEE_LIMIT,
+  DEFAULT_TRX_DECIMALS,
+  DEFAULT_USDT_DECIMALS,
+  DEFAULT_VALIDITY_DURATION,
+  ExactTronClientScheme,
+  ExactTronFacilitatorScheme,
+  ExactTronServerScheme,
+  MAX_FEE_LIMIT,
+  MIN_FEE_LIMIT,
+  MIN_VALIDITY_BUFFER,
+  NETWORK_ENDPOINTS,
+  SCHEME_EXACT,
+  SUN_PER_TRX,
+  TRC20_APPROVE_SELECTOR,
+  TRC20_BALANCE_OF_SELECTOR,
+  TRC20_REGISTRY,
+  TRC20_TRANSFER_SELECTOR,
+  TRON_ADDRESS_HEX_PREFIX,
+  TRON_ADDRESS_LENGTH,
+  TRON_ADDRESS_PREFIX,
+  TRON_MAINNET_CAIP2,
+  TRON_NETWORKS,
+  TRON_NILE_CAIP2,
+  TRON_SHASTA_CAIP2,
+  USDT_ADDRESSES,
+  addressesEqual,
+  calculateExpiration,
+  convertFromSmallestUnits,
+  convertToSmallestUnits,
+  estimateTransactionFee,
+  formatAddress,
+  generatePaymentReference,
+  getDefaultToken,
+  getEndpoint,
+  getNetworkTokens,
+  getNetworksForToken,
+  getSupportedNetworks,
+  getTRC20Config,
+  getTokenByAddress,
+  getUsdtNetworks,
+  isNetworkSupported,
+  isTronNetwork,
+  isValidHex,
+  normalizeNetwork,
+  registerExactTronClientScheme,
+  registerExactTronFacilitatorScheme,
+  registerExactTronServerScheme,
+  validateTronAddress
+});
+//# sourceMappingURL=index.js.map