@t402/ton 2.0.0

package/dist/cjs/signer-CFiw2DST.d.ts

@@ -0,0 +1,277 @@
+import { Address, Cell, SendMode } from '@ton/core';
+
+/**
+ * TON Payment Payload Types
+ *
+ * Defines the payload structure for TON Jetton payments in the t402 protocol.
+ * Uses BOC (Bag of Cells) format for message serialization.
+ */
+/**
+ * TON payment payload for the exact scheme (V2)
+ * Contains a pre-signed external message for Jetton transfer
+ */
+type ExactTonPayloadV2 = {
+    /**
+     * Base64 encoded signed external message (BOC format)
+     * Contains the complete Jetton transfer message ready for broadcast
+     * The message is signed by the client's wallet private key
+     */
+    signedBoc: string;
+    /**
+     * Transfer authorization metadata
+     * Provides human-readable and verifiable parameters
+     */
+    authorization: {
+        /**
+         * Sender wallet address (friendly format, bounceable)
+         * This is the TON wallet address that will send the Jetton transfer
+         */
+        from: string;
+        /**
+         * Recipient wallet address (friendly format)
+         * Final destination for the Jetton tokens
+         */
+        to: string;
+        /**
+         * Jetton master contract address
+         * Identifies which Jetton token is being transferred
+         */
+        jettonMaster: string;
+        /**
+         * Jetton amount in smallest units (e.g., 1000000 for 1 USDT with 6 decimals)
+         */
+        jettonAmount: string;
+        /**
+         * TON amount attached for gas (in nanoTON)
+         * Required to pay for the internal message execution
+         */
+        tonAmount: string;
+        /**
+         * Unix timestamp (seconds) after which the authorization expires
+         * Message will be rejected by the network after this time
+         */
+        validUntil: number;
+        /**
+         * Wallet sequence number at time of signing
+         * Prevents replay attacks - each seqno can only be used once
+         */
+        seqno: number;
+        /**
+         * Query ID for the Jetton transfer
+         * Used for message correlation and deduplication
+         */
+        queryId: string;
+    };
+};
+/**
+ * Alias for the current payload version
+ */
+type ExactTonPayload = ExactTonPayloadV2;
+/**
+ * Result of message verification
+ */
+type VerifyMessageResult = {
+    /** Whether the message is valid */
+    valid: boolean;
+    /** Reason for invalidity (if applicable) */
+    reason?: string;
+    /** Extracted transfer parameters */
+    transfer?: {
+        from: string;
+        to: string;
+        jettonAmount: bigint;
+        queryId: bigint;
+    };
+};
+/**
+ * Transaction confirmation result
+ */
+type TransactionConfirmation = {
+    /** Whether the transaction was confirmed */
+    success: boolean;
+    /** Logical time of the transaction */
+    lt?: bigint;
+    /** Transaction hash */
+    hash?: string;
+    /** Error message if failed */
+    error?: string;
+};
+
+/**
+ * TON Signer Interfaces
+ *
+ * Defines the signer interfaces for t402 client and facilitator operations.
+ * These interfaces abstract away the specific wallet implementation,
+ * allowing integration with various TON wallets and signing mechanisms.
+ */
+
+/**
+ * Parameters for signing a TON internal message
+ */
+type SignMessageParams = {
+    /** Destination address (typically Jetton wallet contract) */
+    to: Address;
+    /** Amount of TON to attach (for gas) in nanoTON */
+    value: bigint;
+    /** Message body (Jetton transfer cell) */
+    body: Cell;
+    /** Send mode flags (optional, defaults to PAY_GAS_SEPARATELY) */
+    sendMode?: SendMode;
+    /** Bounce flag (optional, defaults to true) */
+    bounce?: boolean;
+    /** Message validity timeout in seconds (optional) */
+    timeout?: number;
+};
+/**
+ * ClientTonSigner - Used by t402 clients to sign Jetton transfer messages
+ *
+ * This interface represents a TON wallet that can:
+ * - Sign internal messages for Jetton transfers
+ * - Query its own seqno (sequence number)
+ *
+ * Implementations may include:
+ * - WalletContractV4 with private key
+ * - TonConnect wallet adapter
+ * - Hardware wallet integration
+ */
+type ClientTonSigner = {
+    /** The wallet address */
+    readonly address: Address;
+    /**
+     * Sign an internal message for Jetton transfer
+     * Returns the complete signed external message ready for broadcast
+     *
+     * @param params - Message parameters
+     * @returns Signed external message as Cell (BOC)
+     */
+    signMessage(params: SignMessageParams): Promise<Cell>;
+    /**
+     * Get current seqno for the wallet
+     * Used for replay protection
+     *
+     * @returns Current sequence number
+     */
+    getSeqno(): Promise<number>;
+};
+/**
+ * Parameters for verifying a signed message
+ */
+type VerifyMessageParams = {
+    /** The signed BOC from client (base64) */
+    signedBoc: string;
+    /** Expected sender address */
+    expectedFrom: string;
+    /** Expected Jetton transfer details */
+    expectedTransfer: {
+        /** Expected Jetton amount */
+        jettonAmount: bigint;
+        /** Expected destination address */
+        destination: string;
+        /** Jetton master address */
+        jettonMaster: string;
+    };
+};
+/**
+ * Parameters for waiting on transaction confirmation
+ */
+type WaitForTransactionParams = {
+    /** Address to monitor */
+    address: string;
+    /** Expected seqno after transaction */
+    seqno: number;
+    /** Timeout in milliseconds (optional) */
+    timeout?: number;
+};
+/**
+ * FacilitatorTonSigner - Used by t402 facilitators to verify and settle payments
+ *
+ * This interface combines RPC capabilities with signing abilities:
+ * - Query Jetton balances and wallet addresses
+ * - Verify signed messages
+ * - Broadcast transactions
+ * - Wait for confirmations
+ */
+type FacilitatorTonSigner = {
+    /**
+     * Get all addresses this facilitator can use for signing
+     * Enables dynamic address selection for load balancing
+     */
+    getAddresses(): readonly string[];
+    /**
+     * Query Jetton balance for an owner
+     *
+     * @param params - Owner and Jetton master addresses
+     * @returns Balance in smallest units
+     */
+    getJettonBalance(params: {
+        ownerAddress: string;
+        jettonMasterAddress: string;
+    }): Promise<bigint>;
+    /**
+     * Get Jetton wallet address for an owner
+     * Derives the associated Jetton wallet contract address
+     *
+     * @param params - Owner and Jetton master addresses
+     * @returns Jetton wallet address
+     */
+    getJettonWalletAddress(params: {
+        ownerAddress: string;
+        jettonMasterAddress: string;
+    }): Promise<string>;
+    /**
+     * Verify a signed message matches expected parameters
+     * Validates the BOC structure and transfer details
+     *
+     * @param params - Verification parameters
+     * @returns Verification result
+     */
+    verifyMessage(params: VerifyMessageParams): Promise<VerifyMessageResult>;
+    /**
+     * Send a pre-signed external message to the network
+     *
+     * @param signedBoc - Base64 encoded signed BOC
+     * @returns Transaction hash or identifier
+     */
+    sendExternalMessage(signedBoc: string): Promise<string>;
+    /**
+     * Wait for transaction confirmation
+     *
+     * @param params - Transaction monitoring parameters
+     * @returns Confirmation result
+     */
+    waitForTransaction(params: WaitForTransactionParams): Promise<TransactionConfirmation>;
+    /**
+     * Get current seqno for an address
+     *
+     * @param address - Wallet address to query
+     * @returns Current seqno
+     */
+    getSeqno(address: string): Promise<number>;
+    /**
+     * Check if a wallet is deployed (active)
+     *
+     * @param address - Address to check
+     * @returns true if deployed
+     */
+    isDeployed(address: string): Promise<boolean>;
+};
+/**
+ * Converts a TON wallet to a ClientTonSigner
+ * Identity function for type compatibility
+ *
+ * @param signer - The signer to convert
+ * @returns The same signer with ClientTonSigner type
+ */
+declare function toClientTonSigner(signer: ClientTonSigner): ClientTonSigner;
+/**
+ * Creates a FacilitatorTonSigner from a single-address facilitator
+ * Wraps the single address in a getAddresses() function for compatibility
+ *
+ * @param client - Facilitator client with single address
+ * @returns FacilitatorTonSigner with getAddresses() support
+ */
+declare function toFacilitatorTonSigner(client: Omit<FacilitatorTonSigner, "getAddresses"> & {
+    address: string;
+}): FacilitatorTonSigner;
+
+export { type ClientTonSigner as C, type ExactTonPayloadV2 as E, type FacilitatorTonSigner as F, type SignMessageParams as S, type TransactionConfirmation as T, type VerifyMessageParams as V, type WaitForTransactionParams as W, toFacilitatorTonSigner as a, type ExactTonPayload as b, type VerifyMessageResult as c, toClientTonSigner as t };

package/dist/esm/chunk-6LOUEHJT.mjs

@@ -0,0 +1,192 @@
+// src/constants.ts
+var TON_MAINNET_CAIP2 = "ton:mainnet";
+var TON_TESTNET_CAIP2 = "ton:testnet";
+var TON_NETWORKS = [TON_MAINNET_CAIP2, TON_TESTNET_CAIP2];
+var TON_MAINNET_ENDPOINT = "https://toncenter.com/api/v2/jsonRPC";
+var TON_TESTNET_ENDPOINT = "https://testnet.toncenter.com/api/v2/jsonRPC";
+var TON_MAINNET_V4_ENDPOINT = "https://mainnet-v4.tonhubapi.com";
+var TON_TESTNET_V4_ENDPOINT = "https://testnet-v4.tonhubapi.com";
+var NETWORK_ENDPOINTS = {
+  [TON_MAINNET_CAIP2]: TON_MAINNET_ENDPOINT,
+  [TON_TESTNET_CAIP2]: TON_TESTNET_ENDPOINT
+};
+var NETWORK_V4_ENDPOINTS = {
+  [TON_MAINNET_CAIP2]: TON_MAINNET_V4_ENDPOINT,
+  [TON_TESTNET_CAIP2]: TON_TESTNET_V4_ENDPOINT
+};
+var JETTON_TRANSFER_OP = 260734629;
+var JETTON_INTERNAL_TRANSFER_OP = 395134233;
+var JETTON_TRANSFER_NOTIFICATION_OP = 1935855772;
+var JETTON_BURN_OP = 1499400124;
+var DEFAULT_JETTON_TRANSFER_TON = 100000000n;
+var DEFAULT_FORWARD_TON = 1n;
+var MIN_JETTON_TRANSFER_TON = 50000000n;
+var MAX_JETTON_TRANSFER_TON = 500000000n;
+var SCHEME_EXACT = "exact";
+var DEFAULT_VALIDITY_DURATION = 3600;
+
+// src/utils.ts
+import { Address, beginCell } from "@ton/core";
+function normalizeNetwork(network) {
+  if (network.startsWith("ton:")) {
+    if (!TON_NETWORKS.includes(network)) {
+      throw new Error(`Unsupported TON network: ${network}`);
+    }
+    return network;
+  }
+  const mapping = {
+    ton: TON_MAINNET_CAIP2,
+    "ton-mainnet": TON_MAINNET_CAIP2,
+    mainnet: TON_MAINNET_CAIP2,
+    "ton-testnet": TON_TESTNET_CAIP2,
+    testnet: TON_TESTNET_CAIP2
+  };
+  const caip2 = mapping[network.toLowerCase()];
+  if (!caip2) {
+    throw new Error(`Unsupported TON network: ${network}`);
+  }
+  return caip2;
+}
+function getEndpoint(network) {
+  const caip2 = normalizeNetwork(network);
+  const endpoint = NETWORK_ENDPOINTS[caip2];
+  if (!endpoint) {
+    throw new Error(`No endpoint configured for network: ${network}`);
+  }
+  return endpoint;
+}
+function isTonNetwork(network) {
+  try {
+    normalizeNetwork(network);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateTonAddress(address) {
+  try {
+    Address.parse(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseTonAddress(address) {
+  return Address.parse(address);
+}
+function addressesEqual(addr1, addr2) {
+  try {
+    const a1 = Address.parse(addr1);
+    const a2 = Address.parse(addr2);
+    return a1.equals(a2);
+  } catch {
+    return false;
+  }
+}
+function formatAddress(address, options) {
+  const addr = typeof address === "string" ? Address.parse(address) : address;
+  return addr.toString({
+    bounceable: options?.bounceable ?? true,
+    testOnly: options?.testOnly ?? false
+  });
+}
+function convertToJettonAmount(decimalAmount, decimals) {
+  const amount = parseFloat(decimalAmount);
+  if (isNaN(amount)) {
+    throw new Error(`Invalid amount: ${decimalAmount}`);
+  }
+  const jettonAmount = Math.floor(amount * Math.pow(10, decimals));
+  return jettonAmount.toString();
+}
+function convertFromJettonAmount(jettonAmount, decimals) {
+  const amount = typeof jettonAmount === "string" ? BigInt(jettonAmount) : jettonAmount;
+  const divisor = BigInt(Math.pow(10, decimals));
+  const wholePart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  if (fractionalPart === 0n) {
+    return wholePart.toString();
+  }
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  return `${wholePart}.${fractionalStr}`.replace(/\.?0+$/, "");
+}
+function generateQueryId() {
+  const timestamp = BigInt(Date.now());
+  const random = BigInt(Math.floor(Math.random() * 1e6));
+  return timestamp * 1000000n + random;
+}
+function buildJettonTransferBody(params) {
+  const builder = beginCell().storeUint(JETTON_TRANSFER_OP, 32).storeUint(params.queryId, 64).storeCoins(params.amount).storeAddress(params.destination).storeAddress(params.responseDestination).storeBit(false);
+  builder.storeCoins(params.forwardAmount ?? 1n);
+  if (params.forwardPayload) {
+    builder.storeBit(true).storeRef(params.forwardPayload);
+  } else {
+    builder.storeBit(false);
+  }
+  return builder.endCell();
+}
+function parseJettonTransferBody(body) {
+  const slice = body.beginParse();
+  const op = slice.loadUint(32);
+  if (op !== JETTON_TRANSFER_OP) {
+    throw new Error(`Not a Jetton transfer message. Expected op ${JETTON_TRANSFER_OP}, got ${op}`);
+  }
+  const queryId = slice.loadUintBig(64);
+  const amount = slice.loadCoins();
+  const destination = slice.loadAddress();
+  const responseDestination = slice.loadAddress();
+  const hasCustomPayload = slice.loadBit();
+  if (hasCustomPayload) {
+    slice.loadRef();
+  }
+  const forwardAmount = slice.loadCoins();
+  const hasForwardPayload = slice.loadBit();
+  const forwardPayload = hasForwardPayload ? slice.loadRef() : void 0;
+  return {
+    op,
+    queryId,
+    amount,
+    destination,
+    responseDestination,
+    forwardAmount,
+    forwardPayload
+  };
+}
+function estimateJettonTransferGas(_params) {
+  return 100000000n;
+}
+
+export {
+  TON_MAINNET_CAIP2,
+  TON_TESTNET_CAIP2,
+  TON_NETWORKS,
+  TON_MAINNET_ENDPOINT,
+  TON_TESTNET_ENDPOINT,
+  TON_MAINNET_V4_ENDPOINT,
+  TON_TESTNET_V4_ENDPOINT,
+  NETWORK_ENDPOINTS,
+  NETWORK_V4_ENDPOINTS,
+  JETTON_TRANSFER_OP,
+  JETTON_INTERNAL_TRANSFER_OP,
+  JETTON_TRANSFER_NOTIFICATION_OP,
+  JETTON_BURN_OP,
+  DEFAULT_JETTON_TRANSFER_TON,
+  DEFAULT_FORWARD_TON,
+  MIN_JETTON_TRANSFER_TON,
+  MAX_JETTON_TRANSFER_TON,
+  SCHEME_EXACT,
+  DEFAULT_VALIDITY_DURATION,
+  normalizeNetwork,
+  getEndpoint,
+  isTonNetwork,
+  validateTonAddress,
+  parseTonAddress,
+  addressesEqual,
+  formatAddress,
+  convertToJettonAmount,
+  convertFromJettonAmount,
+  generateQueryId,
+  buildJettonTransferBody,
+  parseJettonTransferBody,
+  estimateJettonTransferGas
+};
+//# sourceMappingURL=chunk-6LOUEHJT.mjs.map

package/dist/esm/chunk-6LOUEHJT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/constants.ts","../../src/utils.ts"],"sourcesContent":["/**\n * TON Network Constants\n *\n * This module provides constants for TON blockchain integration including:\n * - CAIP-2 network identifiers\n * - RPC endpoints\n * - Jetton transfer operation codes\n * - Default gas amounts\n */\n\n/**\n * CAIP-2 Network Identifiers for TON\n * Using simple identifiers for mainnet/testnet\n */\nexport const TON_MAINNET_CAIP2 = \"ton:mainnet\";\nexport const TON_TESTNET_CAIP2 = \"ton:testnet\";\n\n/**\n * Supported TON networks\n */\nexport const TON_NETWORKS = [TON_MAINNET_CAIP2, TON_TESTNET_CAIP2] as const;\n\nexport type TonNetwork = (typeof TON_NETWORKS)[number];\n\n/**\n * Default RPC endpoints (TonCenter API v2)\n */\nexport const TON_MAINNET_ENDPOINT = \"https://toncenter.com/api/v2/jsonRPC\";\nexport const TON_TESTNET_ENDPOINT = \"https://testnet.toncenter.com/api/v2/jsonRPC\";\n\n/**\n * TON API v4 endpoints (for @ton/ton TonClient4)\n */\nexport const TON_MAINNET_V4_ENDPOINT = \"https://mainnet-v4.tonhubapi.com\";\nexport const TON_TESTNET_V4_ENDPOINT = \"https://testnet-v4.tonhubapi.com\";\n\n/**\n * Network endpoint mapping\n */\nexport const NETWORK_ENDPOINTS: Record<string, string> = {\n  [TON_MAINNET_CAIP2]: TON_MAINNET_ENDPOINT,\n  [TON_TESTNET_CAIP2]: TON_TESTNET_ENDPOINT,\n};\n\nexport const NETWORK_V4_ENDPOINTS: Record<string, string> = {\n  [TON_MAINNET_CAIP2]: TON_MAINNET_V4_ENDPOINT,\n  [TON_TESTNET_CAIP2]: TON_TESTNET_V4_ENDPOINT,\n};\n\n/**\n * Jetton Transfer Operation Codes (TEP-74)\n * @see https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md\n */\nexport const JETTON_TRANSFER_OP = 0x0f8a7ea5; // transfer\nexport const JETTON_INTERNAL_TRANSFER_OP = 0x178d4519; // internal_transfer\nexport const JETTON_TRANSFER_NOTIFICATION_OP = 0x7362d09c; // transfer_notification\nexport const JETTON_BURN_OP = 0x595f07bc; // burn\n\n/**\n * Default gas amounts for Jetton transfers\n * TON requires attaching TON for gas to internal messages\n */\nexport const DEFAULT_JETTON_TRANSFER_TON = 100_000_000n; // 0.1 TON for gas\nexport const DEFAULT_FORWARD_TON = 1n; // Minimal forward amount (notification)\nexport const MIN_JETTON_TRANSFER_TON = 50_000_000n; // 0.05 TON minimum\n\n/**\n * Maximum gas amounts to prevent excessive fees\n */\nexport const MAX_JETTON_TRANSFER_TON = 500_000_000n; // 0.5 TON maximum\n\n/**\n * Scheme identifier for exact payments\n */\nexport const SCHEME_EXACT = \"exact\";\n\n/**\n * Default timeout for payment validity (in seconds)\n */\nexport const DEFAULT_VALIDITY_DURATION = 3600; // 1 hour\n\n/**\n * Address format constants\n */\nexport const TON_ADDRESS_LENGTH = 48; // Friendly format length (base64url)\nexport const TON_RAW_ADDRESS_LENGTH = 66; // Raw format: workchain:hash (0:64hex)\n","/**\n * TON Utility Functions\n *\n * Helper functions for TON address handling, message building,\n * and network operations.\n */\n\nimport { Address, beginCell, Cell } from \"@ton/core\";\nimport type { Network } from \"@t402/core/types\";\nimport {\n  TON_MAINNET_CAIP2,\n  TON_TESTNET_CAIP2,\n  TON_NETWORKS,\n  NETWORK_ENDPOINTS,\n  JETTON_TRANSFER_OP,\n} from \"./constants.js\";\n\n/**\n * Normalize network identifier to CAIP-2 format\n *\n * @param network - Network identifier (may be legacy format)\n * @returns Normalized CAIP-2 network identifier\n * @throws Error if network is not supported\n */\nexport function normalizeNetwork(network: Network): Network {\n  // Already in CAIP-2 format\n  if (network.startsWith(\"ton:\")) {\n    if (!TON_NETWORKS.includes(network as (typeof TON_NETWORKS)[number])) {\n      throw new Error(`Unsupported TON network: ${network}`);\n    }\n    return network as Network;\n  }\n\n  // Handle legacy format conversions\n  const mapping: Record<string, Network> = {\n    ton: TON_MAINNET_CAIP2 as Network,\n    \"ton-mainnet\": TON_MAINNET_CAIP2 as Network,\n    mainnet: TON_MAINNET_CAIP2 as Network,\n    \"ton-testnet\": TON_TESTNET_CAIP2 as Network,\n    testnet: TON_TESTNET_CAIP2 as Network,\n  };\n\n  const caip2 = mapping[network.toLowerCase()];\n  if (!caip2) {\n    throw new Error(`Unsupported TON network: ${network}`);\n  }\n  return caip2;\n}\n\n/**\n * Get RPC endpoint for a network\n *\n * @param network - Network identifier\n * @returns RPC endpoint URL\n */\nexport function getEndpoint(network: Network): string {\n  const caip2 = normalizeNetwork(network);\n  const endpoint = NETWORK_ENDPOINTS[caip2];\n  if (!endpoint) {\n    throw new Error(`No endpoint configured for network: ${network}`);\n  }\n  return endpoint;\n}\n\n/**\n * Check if a network identifier is a supported TON network\n *\n * @param network - Network identifier to check\n * @returns true if supported\n */\nexport function isTonNetwork(network: string): boolean {\n  try {\n    normalizeNetwork(network as Network);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate TON address format\n *\n * @param address - Address to validate\n * @returns true if valid TON address\n */\nexport function validateTonAddress(address: string): boolean {\n  try {\n    Address.parse(address);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Parse TON address from string\n *\n * @param address - Address string (friendly or raw format)\n * @returns Parsed Address object\n * @throws Error if invalid format\n */\nexport function parseTonAddress(address: string): Address {\n  return Address.parse(address);\n}\n\n/**\n * Compare two TON addresses for equality\n * Handles different address formats (friendly, raw, bounceable/non-bounceable)\n *\n * @param addr1 - First address\n * @param addr2 - Second address\n * @returns true if addresses are equal\n */\nexport function addressesEqual(addr1: string, addr2: string): boolean {\n  try {\n    const a1 = Address.parse(addr1);\n    const a2 = Address.parse(addr2);\n    return a1.equals(a2);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Format address to friendly format\n *\n * @param address - Address to format\n * @param options - Formatting options\n * @returns Friendly format address string\n */\nexport function formatAddress(\n  address: string | Address,\n  options?: { bounceable?: boolean; testOnly?: boolean },\n): string {\n  const addr = typeof address === \"string\" ? Address.parse(address) : address;\n  return addr.toString({\n    bounceable: options?.bounceable ?? true,\n    testOnly: options?.testOnly ?? false,\n  });\n}\n\n/**\n * Convert decimal amount to smallest units (e.g., nano-Jettons)\n *\n * @param decimalAmount - Amount in decimal format (e.g., \"1.50\")\n * @param decimals - Number of decimal places\n * @returns Amount in smallest units as string\n */\nexport function convertToJettonAmount(decimalAmount: string, decimals: number): string {\n  const amount = parseFloat(decimalAmount);\n  if (isNaN(amount)) {\n    throw new Error(`Invalid amount: ${decimalAmount}`);\n  }\n  const jettonAmount = Math.floor(amount * Math.pow(10, decimals));\n  return jettonAmount.toString();\n}\n\n/**\n * Convert smallest units to decimal amount\n *\n * @param jettonAmount - Amount in smallest units\n * @param decimals - Number of decimal places\n * @returns Amount in decimal format as string\n */\nexport function convertFromJettonAmount(jettonAmount: string | bigint, decimals: number): string {\n  const amount = typeof jettonAmount === \"string\" ? BigInt(jettonAmount) : jettonAmount;\n  const divisor = BigInt(Math.pow(10, decimals));\n  const wholePart = amount / divisor;\n  const fractionalPart = amount % divisor;\n\n  if (fractionalPart === 0n) {\n    return wholePart.toString();\n  }\n\n  const fractionalStr = fractionalPart.toString().padStart(decimals, \"0\");\n  return `${wholePart}.${fractionalStr}`.replace(/\\.?0+$/, \"\");\n}\n\n/**\n * Generate a unique query ID for Jetton transfer\n * Uses timestamp + random component for uniqueness\n *\n * @returns BigInt query ID\n */\nexport function generateQueryId(): bigint {\n  const timestamp = BigInt(Date.now());\n  const random = BigInt(Math.floor(Math.random() * 1000000));\n  return timestamp * 1000000n + random;\n}\n\n/**\n * Build Jetton transfer message body (TEP-74)\n *\n * @param params - Transfer parameters\n * @returns Cell containing the transfer message\n */\nexport function buildJettonTransferBody(params: {\n  queryId: bigint;\n  amount: bigint;\n  destination: Address;\n  responseDestination: Address;\n  forwardAmount?: bigint;\n  forwardPayload?: Cell;\n}): Cell {\n  const builder = beginCell()\n    .storeUint(JETTON_TRANSFER_OP, 32) // op: transfer\n    .storeUint(params.queryId, 64) // query_id\n    .storeCoins(params.amount) // amount\n    .storeAddress(params.destination) // destination\n    .storeAddress(params.responseDestination) // response_destination\n    .storeBit(false); // no custom payload\n\n  // Forward amount (for notification)\n  builder.storeCoins(params.forwardAmount ?? 1n);\n\n  // Forward payload (optional)\n  if (params.forwardPayload) {\n    builder.storeBit(true).storeRef(params.forwardPayload);\n  } else {\n    builder.storeBit(false);\n  }\n\n  return builder.endCell();\n}\n\n/**\n * Parse Jetton transfer message from Cell\n *\n * @param body - Cell containing the message\n * @returns Parsed transfer parameters\n * @throws Error if not a valid Jetton transfer message\n */\nexport function parseJettonTransferBody(body: Cell): {\n  op: number;\n  queryId: bigint;\n  amount: bigint;\n  destination: Address;\n  responseDestination: Address;\n  forwardAmount: bigint;\n  forwardPayload?: Cell;\n} {\n  const slice = body.beginParse();\n\n  const op = slice.loadUint(32);\n  if (op !== JETTON_TRANSFER_OP) {\n    throw new Error(`Not a Jetton transfer message. Expected op ${JETTON_TRANSFER_OP}, got ${op}`);\n  }\n\n  const queryId = slice.loadUintBig(64);\n  const amount = slice.loadCoins();\n  const destination = slice.loadAddress();\n  const responseDestination = slice.loadAddress();\n\n  // Skip custom_payload bit\n  const hasCustomPayload = slice.loadBit();\n  if (hasCustomPayload) {\n    slice.loadRef(); // Skip custom payload\n  }\n\n  const forwardAmount = slice.loadCoins();\n\n  // Forward payload\n  const hasForwardPayload = slice.loadBit();\n  const forwardPayload = hasForwardPayload ? slice.loadRef() : undefined;\n\n  return {\n    op,\n    queryId,\n    amount,\n    destination,\n    responseDestination,\n    forwardAmount,\n    forwardPayload,\n  };\n}\n\n/**\n * Calculate estimated gas for Jetton transfer\n * Based on typical TON network fees\n *\n * @param params - Optional parameters for estimation\n * @returns Estimated gas in nanoTON\n */\nexport function estimateJettonTransferGas(_params?: {\n  hasForwardPayload?: boolean;\n}): bigint {\n  // Base cost for Jetton transfer (typical)\n  // Includes: external message, wallet internal message, Jetton wallet message\n  return 100_000_000n; // 0.1 TON (conservative estimate)\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-RST5PY7E.mjs

@@ -0,0 +1,85 @@
+import {
+  TON_MAINNET_CAIP2,
+  TON_TESTNET_CAIP2
+} from "./chunk-6LOUEHJT.mjs";
+
+// src/tokens.ts
+var USDT_ADDRESSES = {
+  // TON Mainnet - Official Tether USDT
+  [TON_MAINNET_CAIP2]: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
+  // TON Testnet - Test USDT (may vary)
+  [TON_TESTNET_CAIP2]: "kQBqSpvo4S87mX9tTc4FX3Sfqf4uSp3Tx-Fz4RBUfTRWBx"
+};
+var JETTON_REGISTRY = {
+  // TON Mainnet
+  [TON_MAINNET_CAIP2]: {
+    USDT: {
+      masterAddress: USDT_ADDRESSES[TON_MAINNET_CAIP2],
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 6,
+      priority: 1
+    }
+  },
+  // TON Testnet
+  [TON_TESTNET_CAIP2]: {
+    USDT: {
+      masterAddress: USDT_ADDRESSES[TON_TESTNET_CAIP2],
+      symbol: "USDT",
+      name: "Tether USD (Testnet)",
+      decimals: 6,
+      priority: 1
+    }
+  }
+};
+function getJettonConfig(network, symbol) {
+  return JETTON_REGISTRY[network]?.[symbol.toUpperCase()];
+}
+function getNetworkJettons(network) {
+  const jettons = JETTON_REGISTRY[network];
+  if (!jettons) return [];
+  return Object.values(jettons).sort((a, b) => a.priority - b.priority);
+}
+function getDefaultJetton(network) {
+  const jettons = getNetworkJettons(network);
+  return jettons[0];
+}
+function getJettonByAddress(network, address) {
+  const jettons = JETTON_REGISTRY[network];
+  if (!jettons) return void 0;
+  return Object.values(jettons).find(
+    (j) => j.masterAddress.toLowerCase() === address.toLowerCase()
+  );
+}
+function getNetworksForJetton(symbol) {
+  const networks = [];
+  for (const [network, jettons] of Object.entries(JETTON_REGISTRY)) {
+    if (jettons[symbol.toUpperCase()]) {
+      networks.push(network);
+    }
+  }
+  return networks;
+}
+function getUsdtNetworks() {
+  return getNetworksForJetton("USDT");
+}
+function isNetworkSupported(network) {
+  return network in JETTON_REGISTRY;
+}
+function getSupportedNetworks() {
+  return Object.keys(JETTON_REGISTRY);
+}
+
+export {
+  USDT_ADDRESSES,
+  JETTON_REGISTRY,
+  getJettonConfig,
+  getNetworkJettons,
+  getDefaultJetton,
+  getJettonByAddress,
+  getNetworksForJetton,
+  getUsdtNetworks,
+  isNetworkSupported,
+  getSupportedNetworks
+};
+//# sourceMappingURL=chunk-RST5PY7E.mjs.map

package/dist/esm/chunk-RST5PY7E.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tokens.ts"],"sourcesContent":["/**\n * TON Jetton Token Configuration\n *\n * This module provides comprehensive Jetton token definitions including:\n * - USDT (Tether USD on TON)\n * - Network-specific configurations\n * - Helper functions for token lookups\n */\n\nimport { TON_MAINNET_CAIP2, TON_TESTNET_CAIP2 } from \"./constants.js\";\n\n/**\n * Jetton token configuration\n */\nexport interface JettonConfig {\n  /** Jetton master contract address (friendly format) */\n  masterAddress: string;\n  /** Token symbol */\n  symbol: string;\n  /** Token name */\n  name: string;\n  /** Number of decimal places */\n  decimals: number;\n  /** Payment priority (lower = higher priority) */\n  priority: number;\n}\n\n/**\n * Network token registry mapping network -> symbol -> config\n */\nexport type NetworkJettonRegistry = Record<string, Record<string, JettonConfig>>;\n\n/**\n * USDT Jetton Master Contract Addresses by Network\n *\n * USDT on TON follows the TEP-74 Jetton standard.\n * @see https://docs.tether.to/tether-on-ton\n */\nexport const USDT_ADDRESSES: Record<string, string> = {\n  // TON Mainnet - Official Tether USDT\n  [TON_MAINNET_CAIP2]: \"EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs\",\n  // TON Testnet - Test USDT (may vary)\n  [TON_TESTNET_CAIP2]: \"kQBqSpvo4S87mX9tTc4FX3Sfqf4uSp3Tx-Fz4RBUfTRWBx\",\n};\n\n/**\n * Complete Jetton registry with all supported tokens per network\n */\nexport const JETTON_REGISTRY: NetworkJettonRegistry = {\n  // TON Mainnet\n  [TON_MAINNET_CAIP2]: {\n    USDT: {\n      masterAddress: USDT_ADDRESSES[TON_MAINNET_CAIP2],\n      symbol: \"USDT\",\n      name: \"Tether USD\",\n      decimals: 6,\n      priority: 1,\n    },\n  },\n\n  // TON Testnet\n  [TON_TESTNET_CAIP2]: {\n    USDT: {\n      masterAddress: USDT_ADDRESSES[TON_TESTNET_CAIP2],\n      symbol: \"USDT\",\n      name: \"Tether USD (Testnet)\",\n      decimals: 6,\n      priority: 1,\n    },\n  },\n};\n\n/**\n * Get Jetton configuration for a specific token on a network\n *\n * @param network - Network identifier (CAIP-2 format)\n * @param symbol - Token symbol (e.g., \"USDT\")\n * @returns Jetton configuration or undefined\n */\nexport function getJettonConfig(network: string, symbol: string): JettonConfig | undefined {\n  return JETTON_REGISTRY[network]?.[symbol.toUpperCase()];\n}\n\n/**\n * Get all Jettons available on a network\n *\n * @param network - Network identifier\n * @returns Array of Jetton configurations sorted by priority\n */\nexport function getNetworkJettons(network: string): JettonConfig[] {\n  const jettons = JETTON_REGISTRY[network];\n  if (!jettons) return [];\n  return Object.values(jettons).sort((a, b) => a.priority - b.priority);\n}\n\n/**\n * Get the default/preferred Jetton for a network\n * Prefers USDT based on priority\n *\n * @param network - Network identifier\n * @returns Default Jetton configuration or undefined\n */\nexport function getDefaultJetton(network: string): JettonConfig | undefined {\n  const jettons = getNetworkJettons(network);\n  return jettons[0]; // Already sorted by priority\n}\n\n/**\n * Get Jetton by master contract address on a network\n *\n * @param network - Network identifier\n * @param address - Jetton master contract address\n * @returns Jetton configuration or undefined\n */\nexport function getJettonByAddress(network: string, address: string): JettonConfig | undefined {\n  const jettons = JETTON_REGISTRY[network];\n  if (!jettons) return undefined;\n\n  // Normalize address comparison (case-insensitive for base64)\n  return Object.values(jettons).find(\n    (j) => j.masterAddress.toLowerCase() === address.toLowerCase(),\n  );\n}\n\n/**\n * Get all networks that support a specific Jetton\n *\n * @param symbol - Token symbol\n * @returns Array of network identifiers\n */\nexport function getNetworksForJetton(symbol: string): string[] {\n  const networks: string[] = [];\n  for (const [network, jettons] of Object.entries(JETTON_REGISTRY)) {\n    if (jettons[symbol.toUpperCase()]) {\n      networks.push(network);\n    }\n  }\n  return networks;\n}\n\n/**\n * Get USDT networks on TON\n *\n * @returns Array of networks supporting USDT\n */\nexport function getUsdtNetworks(): string[] {\n  return getNetworksForJetton(\"USDT\");\n}\n\n/**\n * Check if a network is supported\n *\n * @param network - Network identifier to check\n * @returns true if network has configured Jettons\n */\nexport function isNetworkSupported(network: string): boolean {\n  return network in JETTON_REGISTRY;\n}\n\n/**\n * Get all supported networks\n *\n * @returns Array of all supported network identifiers\n */\nexport function getSupportedNetworks(): string[] {\n  return Object.keys(JETTON_REGISTRY);\n}\n"],"mappings":";;;;;;AAsCO,IAAM,iBAAyC;AAAA;AAAA,EAEpD,CAAC,iBAAiB,GAAG;AAAA;AAAA,EAErB,CAAC,iBAAiB,GAAG;AACvB;AAKO,IAAM,kBAAyC;AAAA;AAAA,EAEpD,CAAC,iBAAiB,GAAG;AAAA,IACnB,MAAM;AAAA,MACJ,eAAe,eAAe,iBAAiB;AAAA,MAC/C,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,UAAU;AAAA,MACV,UAAU;AAAA,IACZ;AAAA,EACF;AAAA;AAAA,EAGA,CAAC,iBAAiB,GAAG;AAAA,IACnB,MAAM;AAAA,MACJ,eAAe,eAAe,iBAAiB;AAAA,MAC/C,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,UAAU;AAAA,MACV,UAAU;AAAA,IACZ;AAAA,EACF;AACF;AASO,SAAS,gBAAgB,SAAiB,QAA0C;AACzF,SAAO,gBAAgB,OAAO,IAAI,OAAO,YAAY,CAAC;AACxD;AAQO,SAAS,kBAAkB,SAAiC;AACjE,QAAM,UAAU,gBAAgB,OAAO;AACvC,MAAI,CAAC,QAAS,QAAO,CAAC;AACtB,SAAO,OAAO,OAAO,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;AACtE;AASO,SAAS,iBAAiB,SAA2C;AAC1E,QAAM,UAAU,kBAAkB,OAAO;AACzC,SAAO,QAAQ,CAAC;AAClB;AASO,SAAS,mBAAmB,SAAiB,SAA2C;AAC7F,QAAM,UAAU,gBAAgB,OAAO;AACvC,MAAI,CAAC,QAAS,QAAO;AAGrB,SAAO,OAAO,OAAO,OAAO,EAAE;AAAA,IAC5B,CAAC,MAAM,EAAE,cAAc,YAAY,MAAM,QAAQ,YAAY;AAAA,EAC/D;AACF;AAQO,SAAS,qBAAqB,QAA0B;AAC7D,QAAM,WAAqB,CAAC;AAC5B,aAAW,CAAC,SAAS,OAAO,KAAK,OAAO,QAAQ,eAAe,GAAG;AAChE,QAAI,QAAQ,OAAO,YAAY,CAAC,GAAG;AACjC,eAAS,KAAK,OAAO;AAAA,IACvB;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,kBAA4B;AAC1C,SAAO,qBAAqB,MAAM;AACpC;AAQO,SAAS,mBAAmB,SAA0B;AAC3D,SAAO,WAAW;AACpB;AAOO,SAAS,uBAAiC;AAC/C,SAAO,OAAO,KAAK,eAAe;AACpC;","names":[]}