@t402/ton 2.0.0 → 2.1.0

package/dist/cjs/index.js

@@ -62,6 +62,9 @@ __export(src_exports, {
   normalizeNetwork: () => normalizeNetwork,
   parseJettonTransferBody: () => parseJettonTransferBody,
   parseTonAddress: () => parseTonAddress,
+  registerExactTonClientScheme: () => registerExactTonScheme,
+  registerExactTonFacilitatorScheme: () => registerExactTonScheme3,
+  registerExactTonServerScheme: () => registerExactTonScheme2,
   toClientTonSigner: () => toClientTonSigner,
   toFacilitatorTonSigner: () => toFacilitatorTonSigner,
   validateTonAddress: () => validateTonAddress
@@ -314,15 +317,26 @@ var ExactTonScheme = class {
   }
 };
 
-// src/signer.ts
-function toClientTonSigner(signer) {
-  return signer;
-}
-function toFacilitatorTonSigner(client) {
-  return {
-    ...client,
-    getAddresses: () => [client.address]
-  };
+// src/exact/client/register.ts
+function registerExactTonScheme(client, config) {
+  const scheme = new ExactTonScheme(
+    config.signer,
+    config.getJettonWalletAddress,
+    config.schemeConfig
+  );
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      client.register(network, scheme);
+    });
+  } else {
+    client.register("ton:*", scheme);
+  }
+  if (config.policies) {
+    config.policies.forEach((policy) => {
+      client.registerPolicy(policy);
+    });
+  }
+  return client;
 }
 
 // src/tokens.ts
@@ -391,6 +405,483 @@ function isNetworkSupported(network) {
 function getSupportedNetworks() {
   return Object.keys(JETTON_REGISTRY);
 }
+
+// src/exact/server/scheme.ts
+var ExactTonScheme2 = class {
+  constructor(config = {}) {
+    this.scheme = SCHEME_EXACT;
+    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
+   *
+   * @example
+   * tonServer.registerMoneyParser(async (amount, network) => {
+   *   // Use custom Jetton for large amounts
+   *   if (amount > 1000) {
+   *     return {
+   *       amount: (amount * 1e9).toString(),
+   *       asset: "EQCustomJettonAddress...",
+   *       extra: { tier: "premium" }
+   *     };
+   *   }
+   *   return null; // Use next parser
+   * });
+   */
+  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.
+   * Adds TON-specific fields like gas sponsor if provided by facilitator.
+   *
+   * @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 (unused)
+   * @returns Enhanced payment requirements ready to be sent to clients
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const extra = { ...paymentRequirements.extra };
+    if (supportedKind.extra?.gasSponsor) {
+      extra.gasSponsor = supportedKind.extra.gasSponsor;
+    }
+    return {
+      ...paymentRequirements,
+      extra
+    };
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   * Handles formats like "$1.50", "1.50", 1.50, etc.
+   *
+   * @param money - The money value to parse
+   * @returns 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.
+   * Converts decimal amount to the preferred Jetton on the specified network.
+   *
+   * @param amount - The decimal amount (e.g., 1.50)
+   * @param network - The network to use
+   * @returns The parsed asset amount
+   */
+  defaultMoneyConversion(amount, network) {
+    const jetton = this.getDefaultAsset(network);
+    const tokenAmount = this.convertToTokenAmount(amount.toString(), jetton.decimals);
+    return {
+      amount: tokenAmount,
+      asset: jetton.masterAddress,
+      extra: {
+        symbol: jetton.symbol,
+        name: jetton.name,
+        decimals: jetton.decimals
+      }
+    };
+  }
+  /**
+   * Convert decimal amount to token units (e.g., 0.10 -> 100000 for 6-decimal tokens)
+   *
+   * @param decimalAmount - The decimal amount to convert
+   * @param decimals - Number of decimals for the token
+   * @returns The token amount as a string
+   */
+  convertToTokenAmount(decimalAmount, decimals) {
+    const amount = parseFloat(decimalAmount);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid amount: ${decimalAmount}`);
+    }
+    const tokenAmount = Math.floor(amount * Math.pow(10, decimals));
+    return tokenAmount.toString();
+  }
+  /**
+   * Get the default asset info for a network.
+   * Priority: configured preferredJetton > USDT > first available
+   *
+   * @param network - The network to get asset info for
+   * @returns The Jetton configuration
+   */
+  getDefaultAsset(network) {
+    if (this.config.preferredJetton) {
+      const preferred = getJettonConfig(network, this.config.preferredJetton);
+      if (preferred) return preferred;
+    }
+    const defaultJetton = getDefaultJetton(network);
+    if (defaultJetton) return defaultJetton;
+    throw new Error(`No Jettons configured for network ${network}`);
+  }
+  /**
+   * Get Jetton info for a given symbol on a network
+   *
+   * @param symbol - The Jetton symbol (e.g., "USDT")
+   * @param network - The network to use
+   * @returns The Jetton configuration
+   */
+  getAssetInfo(symbol, network) {
+    const jetton = getJettonConfig(network, symbol);
+    if (jetton) return jetton;
+    if (symbol.toUpperCase() === "USD") {
+      return this.getDefaultAsset(network);
+    }
+    throw new Error(`Unsupported Jetton: ${symbol} on network ${network}`);
+  }
+  /**
+   * Get the number of decimals for a Jetton on a network
+   *
+   * @param network - The network to use
+   * @param jettonAddress - Optional Jetton address to look up
+   * @returns The number of decimals for the Jetton
+   */
+  getAssetDecimals(network, jettonAddress) {
+    if (jettonAddress) {
+      const jetton = getJettonByAddress(network, jettonAddress);
+      if (jetton) return jetton.decimals;
+    }
+    return 6;
+  }
+  /**
+   * Get all supported networks
+   */
+  static getSupportedNetworks() {
+    return Object.keys(JETTON_REGISTRY);
+  }
+  /**
+   * Check if a network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in JETTON_REGISTRY;
+  }
+};
+
+// src/exact/server/register.ts
+function registerExactTonScheme2(server, config = {}) {
+  const scheme = new ExactTonScheme2(config.schemeConfig);
+  if (config.networks && config.networks.length > 0) {
+    config.networks.forEach((network) => {
+      server.register(network, scheme);
+    });
+  } else {
+    server.register("ton:*", scheme);
+  }
+  return server;
+}
+
+// src/exact/facilitator/scheme.ts
+var import_core3 = require("@ton/core");
+var ExactTonScheme3 = class {
+  /**
+   * Creates a new ExactTonScheme facilitator instance.
+   *
+   * @param signer - The TON signer for facilitator operations
+   * @param config - Optional configuration
+   */
+  constructor(signer, config = {}) {
+    this.signer = signer;
+    this.scheme = SCHEME_EXACT;
+    this.caipFamily = "ton:*";
+    this.config = config;
+  }
+  /**
+   * Get mechanism-specific extra data for the supported kinds endpoint.
+   * For TON, optionally returns gas sponsor address if configured.
+   *
+   * @param network - The network identifier
+   * @returns Extra data object or undefined
+   */
+  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 signer addresses used by this facilitator.
+   * Returns all addresses this facilitator can use for operations.
+   *
+   * @param network - The network identifier
+   * @returns Array of facilitator addresses
+   */
+  getSigners(network) {
+    void network;
+    return [...this.signer.getAddresses()];
+  }
+  /**
+   * Verifies a payment payload.
+   *
+   * Performs comprehensive validation:
+   * 1. Scheme and network matching
+   * 2. BOC format validation
+   * 3. Message structure verification
+   * 4. Authorization expiry check
+   * 5. Balance verification
+   * 6. Amount and recipient validation
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to verification response
+   */
+  async verify(payload, requirements) {
+    const tonPayload = payload.payload;
+    const authorization = tonPayload.authorization;
+    if (payload.accepted.scheme !== SCHEME_EXACT || requirements.scheme !== SCHEME_EXACT) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: authorization.from
+      };
+    }
+    try {
+      const payloadNetwork = normalizeNetwork(payload.accepted.network);
+      const requirementsNetwork = normalizeNetwork(requirements.network);
+      if (payloadNetwork !== requirementsNetwork) {
+        return {
+          isValid: false,
+          invalidReason: "network_mismatch",
+          payer: authorization.from
+        };
+      }
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "invalid_network",
+        payer: authorization.from
+      };
+    }
+    try {
+      import_core3.Cell.fromBase64(tonPayload.signedBoc);
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "invalid_boc_format",
+        payer: authorization.from
+      };
+    }
+    const verifyResult = await this.signer.verifyMessage({
+      signedBoc: tonPayload.signedBoc,
+      expectedFrom: authorization.from,
+      expectedTransfer: {
+        jettonAmount: BigInt(authorization.jettonAmount),
+        destination: requirements.payTo,
+        jettonMaster: requirements.asset
+      }
+    });
+    if (!verifyResult.valid) {
+      return {
+        isValid: false,
+        invalidReason: verifyResult.reason || "message_verification_failed",
+        payer: authorization.from
+      };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (authorization.validUntil < now + 30) {
+      return {
+        isValid: false,
+        invalidReason: "authorization_expired",
+        payer: authorization.from
+      };
+    }
+    try {
+      const balance = await this.signer.getJettonBalance({
+        ownerAddress: authorization.from,
+        jettonMasterAddress: requirements.asset
+      });
+      if (balance < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_jetton_balance",
+          payer: authorization.from
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify Jetton balance:", error);
+    }
+    if (BigInt(authorization.jettonAmount) < 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.jettonMaster, requirements.asset)) {
+      return {
+        isValid: false,
+        invalidReason: "asset_mismatch",
+        payer: authorization.from
+      };
+    }
+    try {
+      const currentSeqno = await this.signer.getSeqno(authorization.from);
+      if (authorization.seqno < currentSeqno) {
+        return {
+          isValid: false,
+          invalidReason: "seqno_already_used",
+          payer: authorization.from
+        };
+      }
+      if (authorization.seqno > currentSeqno) {
+        return {
+          isValid: false,
+          invalidReason: "seqno_too_high",
+          payer: authorization.from
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify seqno:", error);
+    }
+    try {
+      const isDeployed = await this.signer.isDeployed(authorization.from);
+      if (!isDeployed) {
+        return {
+          isValid: false,
+          invalidReason: "wallet_not_deployed",
+          payer: authorization.from
+        };
+      }
+    } catch (error) {
+      console.warn("Could not verify wallet deployment:", error);
+    }
+    return {
+      isValid: true,
+      invalidReason: void 0,
+      payer: authorization.from
+    };
+  }
+  /**
+   * Settles a payment by broadcasting the signed message.
+   *
+   * @param payload - The payment payload to settle
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to settlement response
+   */
+  async settle(payload, requirements) {
+    const tonPayload = 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: tonPayload.authorization.from
+      };
+    }
+    try {
+      const txHash = await this.signer.sendExternalMessage(tonPayload.signedBoc);
+      const confirmation = await this.signer.waitForTransaction({
+        address: tonPayload.authorization.from,
+        seqno: tonPayload.authorization.seqno + 1,
+        // Wait for next seqno
+        timeout: 6e4
+        // 60 second timeout
+      });
+      if (!confirmation.success) {
+        return {
+          success: false,
+          errorReason: confirmation.error || "transaction_not_confirmed",
+          transaction: txHash,
+          network: payload.accepted.network,
+          payer: tonPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: confirmation.hash || txHash,
+        network: payload.accepted.network,
+        payer: tonPayload.authorization.from
+      };
+    } catch (error) {
+      console.error("Failed to settle TON transaction:", error);
+      return {
+        success: false,
+        errorReason: "transaction_failed",
+        transaction: "",
+        network: payload.accepted.network,
+        payer: tonPayload.authorization.from
+      };
+    }
+  }
+};
+
+// src/exact/facilitator/register.ts
+function registerExactTonScheme3(facilitator, config) {
+  facilitator.register(config.networks, new ExactTonScheme3(config.signer, config.schemeConfig));
+  return facilitator;
+}
+
+// src/signer.ts
+function toClientTonSigner(signer) {
+  return signer;
+}
+function toFacilitatorTonSigner(client) {
+  return {
+    ...client,
+    getAddresses: () => [client.address]
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_FORWARD_TON,
@@ -435,6 +926,9 @@ function getSupportedNetworks() {
   normalizeNetwork,
   parseJettonTransferBody,
   parseTonAddress,
+  registerExactTonClientScheme,
+  registerExactTonFacilitatorScheme,
+  registerExactTonServerScheme,
   toClientTonSigner,
   toFacilitatorTonSigner,
   validateTonAddress