@piprail/sdk 1.0.0

package/dist/ton-EFZKQAAK.js

@@ -0,0 +1,366 @@
+import {
+  delay
+} from "./chunk-FURB5RP7.js";
+import {
+  ConfirmationTimeoutError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-3TQJJ4SQ.js";
+
+// src/drivers/ton/index.ts
+import { Address as Address2 } from "@ton/core";
+import { JettonMaster, TonClient } from "@ton/ton";
+
+// src/drivers/ton/chains.ts
+var TON_DECIMALS = 9;
+var TON_MAINNET = {
+  caip2: "ton:-239",
+  defaultRpc: "https://toncenter.com/api/v2/jsonRPC",
+  tokens: {
+    // USD₮ (Tether) — native, dominant stablecoin on TON. Master + 6 decimals
+    // verified on-chain (tonapi + toncenter) before shipping.
+    USDT: {
+      master: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
+      decimals: 6,
+      symbol: "USDT"
+    }
+  }
+};
+
+// src/drivers/ton/pay.ts
+import { Address, beginCell, comment as commentCell, internal, toNano } from "@ton/core";
+import { SendMode } from "@ton/ton";
+var OP_JETTON_TRANSFER = 260734629;
+var JETTON_GAS = toNano("0.05");
+var FORWARD_TON = 1n;
+async function payTon(params) {
+  const { client, wallet, accept, senderJettonWallet } = params;
+  const opened = client.open(wallet.contract);
+  const seqno = await opened.getSeqno();
+  const cmt = commentCell(accept.extra.nonce);
+  const message = accept.asset === "native" ? internal({
+    to: Address.parse(accept.payTo),
+    value: BigInt(accept.amount),
+    bounce: false,
+    body: cmt
+  }) : internal({
+    to: senderJettonWallet,
+    value: JETTON_GAS,
+    bounce: true,
+    body: buildJettonTransfer(accept, wallet.contract.address, cmt)
+  });
+  await opened.sendTransfer({
+    seqno,
+    secretKey: wallet.keyPair.secretKey,
+    sendMode: SendMode.PAY_GAS_SEPARATELY | SendMode.IGNORE_ERRORS,
+    messages: [message]
+  });
+  await waitForSeqno(opened, seqno);
+}
+function buildJettonTransfer(accept, responseTo, forward) {
+  return beginCell().storeUint(OP_JETTON_TRANSFER, 32).storeUint(0n, 64).storeCoins(BigInt(accept.amount)).storeAddress(Address.parse(accept.payTo)).storeAddress(responseTo).storeBit(false).storeCoins(FORWARD_TON).storeBit(true).storeRef(forward).endCell();
+}
+async function waitForSeqno(opened, from, { tries = 30, intervalMs = 2e3 } = {}) {
+  for (let i = 0; i < tries; i += 1) {
+    await delay(intervalMs);
+    let current;
+    try {
+      current = await opened.getSeqno();
+    } catch {
+      continue;
+    }
+    if (current > from) return;
+  }
+  throw new ConfirmationTimeoutError(
+    `TON wallet seqno did not advance past ${from} \u2014 the payment may not have been accepted.`
+  );
+}
+
+// src/drivers/ton/verify.ts
+var OP_INTERNAL_TRANSFER = 395134233;
+var OP_TEXT_COMMENT = 0;
+async function verifyTon(params) {
+  const { client, watch, accept } = params;
+  const required = BigInt(accept.amount);
+  const nonce = accept.extra.nonce;
+  let txs;
+  try {
+    txs = await client.getTransactions(watch, { limit: 24, archival: true });
+  } catch {
+    return {
+      ok: false,
+      error: "tx_not_found",
+      detail: `Could not read the TON account for nonce ${nonce} (transient RPC failure) \u2014 retry.`
+    };
+  }
+  for (const tx of txs) {
+    const incoming = extractIncoming(tx);
+    if (!incoming || incoming.comment !== nonce) continue;
+    if (!txSucceeded(tx)) {
+      return { ok: false, error: "tx_reverted", detail: `TON payment for nonce ${nonce} failed on-chain.` };
+    }
+    if (incoming.amount < required) {
+      return { ok: false, error: "amount_too_low", detail: `Credited ${incoming.amount}, required ${required}.` };
+    }
+    const ageSeconds = Math.floor(Date.now() / 1e3) - tx.now;
+    if (ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+    return {
+      ok: true,
+      receipt: {
+        scheme: "onchain-proof",
+        success: true,
+        network: accept.network,
+        transaction: tx.hash().toString("hex"),
+        asset: accept.asset,
+        amount: accept.amount,
+        payer: incoming.payer,
+        payTo: accept.payTo,
+        verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  return notFound(nonce);
+}
+function extractIncoming(tx) {
+  const inMsg = tx.inMessage;
+  if (!inMsg || inMsg.info.type !== "internal" || inMsg.info.bounced) return null;
+  const jetton = parseInternalTransfer(inMsg.body);
+  if (jetton) {
+    return {
+      amount: jetton.amount,
+      payer: (jetton.from ?? inMsg.info.src).toString(),
+      comment: jetton.comment
+    };
+  }
+  return {
+    amount: inMsg.info.value.coins,
+    payer: inMsg.info.src.toString(),
+    comment: readComment(inMsg.body)
+  };
+}
+function txSucceeded(tx) {
+  const d = tx.description;
+  if (d.type !== "generic") return false;
+  if (d.aborted) return false;
+  if (d.computePhase.type === "vm" && !d.computePhase.success) return false;
+  return true;
+}
+function parseInternalTransfer(body) {
+  try {
+    const s = body.beginParse();
+    if (s.remainingBits < 32) return null;
+    if (s.loadUint(32) !== OP_INTERNAL_TRANSFER) return null;
+    s.loadUintBig(64);
+    const amount = s.loadCoins();
+    const from = s.loadMaybeAddress();
+    s.loadMaybeAddress();
+    s.loadCoins();
+    return { amount, from, comment: readForwardComment(s) };
+  } catch {
+    return null;
+  }
+}
+function readForwardComment(s) {
+  try {
+    const cs = s.loadBit() ? s.loadRef().beginParse() : s;
+    if (cs.remainingBits < 32) return void 0;
+    if (cs.loadUint(32) !== OP_TEXT_COMMENT) return void 0;
+    return cs.loadStringTail();
+  } catch {
+    return void 0;
+  }
+}
+function readComment(body) {
+  try {
+    const s = body.beginParse();
+    if (s.remainingBits < 32) return void 0;
+    if (s.loadUint(32) !== OP_TEXT_COMMENT) return void 0;
+    return s.loadStringTail();
+  } catch {
+    return void 0;
+  }
+}
+function notFound(nonce) {
+  return {
+    ok: false,
+    error: "transfer_not_found",
+    detail: `No matching TON transfer found for nonce ${nonce} (not yet settled, or wrong recipient/amount/token).`
+  };
+}
+
+// src/drivers/ton/wallet.ts
+import { mnemonicToWalletKey } from "@ton/crypto";
+import { WalletContractV4, WalletContractV5R1 } from "@ton/ton";
+function assertTonWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is TON; an EVM wallet can't be used \u2014 pass { mnemonic } (24 words) or { keyPair }.`
+    );
+  }
+  if (!("mnemonic" in wallet) && !("keyPair" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
+    );
+  }
+  return wallet;
+}
+async function resolveTonWallet(config) {
+  const version = config.version ?? "v4";
+  let keyPair;
+  if (config.mnemonic) {
+    const words = Array.isArray(config.mnemonic) ? config.mnemonic : config.mnemonic.trim().split(/\s+/);
+    keyPair = await mnemonicToWalletKey(words);
+  } else if (config.keyPair) {
+    keyPair = config.keyPair;
+  } else {
+    throw new WrongFamilyError("TON wallet needs { mnemonic } (24 words) or { keyPair }.");
+  }
+  const contract = version === "v5r1" ? WalletContractV5R1.create({ workchain: 0, publicKey: keyPair.publicKey }) : WalletContractV4.create({ workchain: 0, publicKey: keyPair.publicKey });
+  return { keyPair, contract };
+}
+
+// src/drivers/ton/index.ts
+var tonDriver = {
+  family: "ton",
+  resolve(opts) {
+    if (opts.chain !== "ton") return null;
+    const rpcUrl = opts.rpcUrl ?? TON_MAINNET.defaultRpc;
+    return makeTonNetwork(TON_MAINNET, rpcUrl);
+  }
+};
+function makeTonNetwork(preset, rpcUrl) {
+  const client = new TonClient({ endpoint: rpcUrl });
+  const network = preset.caip2;
+  const jwCache = /* @__PURE__ */ new Map();
+  function jettonWalletFor(master, owner) {
+    const key = `${master}:${owner}`;
+    let p = jwCache.get(key);
+    if (!p) {
+      p = client.open(JettonMaster.create(Address2.parse(master))).getWalletAddress(Address2.parse(owner));
+      jwCache.set(key, p);
+    }
+    return p;
+  }
+  function watchAccountFor(accept) {
+    return accept.asset === "native" ? Promise.resolve(Address2.parse(accept.payTo)) : jettonWalletFor(accept.asset, accept.payTo);
+  }
+  return {
+    family: "ton",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: TON_DECIMALS, symbol: "TON" };
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new UnknownTokenError(
+            `token "${token}" isn't built in for TON (known: ${known}). Note: native USDC doesn't exist on TON. Pass { master, decimals } for a custom jetton, or use 'native'.`
+          );
+        }
+        return { asset: info.master, decimals: info.decimals, symbol: info.symbol };
+      }
+      rejectForeignToken(token, "ton", network);
+      if (!("master" in token)) {
+        throw new WrongFamilyError(
+          `chain ${network} is TON; a custom token must be { master, decimals }.`
+        );
+      }
+      return {
+        asset: token.master,
+        decimals: token.decimals,
+        ...token.symbol ? { symbol: token.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: "TON", decimals: TON_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (info.master === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new WrongFamilyError(
+          `chain ${network} is TON, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      try {
+        Address2.parse(payTo);
+      } catch {
+        throw new WrongFamilyError(
+          `chain ${network} is TON, but payTo "${payTo}" is not a valid TON address.`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertTonWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      try {
+        const tw = await resolveTonWallet(wallet._native);
+        const senderJettonWallet = accept.asset === "native" ? void 0 : await jettonWalletFor(accept.asset, tw.contract.address.toString());
+        await payTon({ client, wallet: tw, accept, senderJettonWallet });
+        const watch = await watchAccountFor(accept);
+        return encodeRef(watch, accept.extra.nonce);
+      } catch (err) {
+        throw toInsufficientFundsError(err) ?? err;
+      }
+    },
+    async confirm(ref) {
+      const { watch, nonce } = decodeRef(ref);
+      const account = Address2.parse(watch);
+      for (let i = 0; i < 40; i += 1) {
+        await delay(2500);
+        let txs;
+        try {
+          txs = await client.getTransactions(account, { limit: 16, archival: true });
+        } catch {
+          continue;
+        }
+        for (const tx of txs) {
+          const inc = extractIncoming(tx);
+          if (inc && inc.comment === nonce) return { height: tx.lt.toString() };
+        }
+      }
+      throw new ConfirmationTimeoutError(`TON payment for nonce ${nonce} did not settle in time.`);
+    },
+    async estimateCost(accept) {
+      const fee = accept.asset === "native" ? 10000000n : 50000000n;
+      const detail = accept.asset === "native" ? "~0.01 TON network fee" : "~0.05 TON attached for the jetton transfer (leftover refunded)";
+      return nativeCost({ symbol: "TON", decimals: TON_DECIMALS, fee, basis: "heuristic", detail });
+    },
+    async verify(_ref, accept) {
+      const watch = await watchAccountFor(accept);
+      return verifyTon({ client, watch, accept });
+    }
+  };
+}
+function encodeRef(watch, nonce) {
+  return `ton:${watch.toString()}|${nonce}`;
+}
+function decodeRef(ref) {
+  const body = ref.startsWith("ton:") ? ref.slice(4) : ref;
+  const i = body.indexOf("|");
+  if (i < 0) throw new Error(`malformed TON proof ref: ${ref}`);
+  return { watch: body.slice(0, i), nonce: body.slice(i + 1) };
+}
+export {
+  tonDriver
+};