@piprail/sdk 1.0.0

package/dist/sui-XV4YYSGV.cjs

@@ -0,0 +1,304 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/sui/index.ts
+var _jsonRpc = require('@mysten/sui/jsonRpc');
+var _utils = require('@mysten/sui/utils');
+
+// src/drivers/sui/chains.ts
+var SUI_DECIMALS = 9;
+var SUI_SYMBOL = "SUI";
+var SUI_NATIVE_COINTYPE = "0x2::sui::SUI";
+var SUI_MAINNET = {
+  caip2: "sui:mainnet",
+  defaultRpc: "https://fullnode.mainnet.sui.io:443",
+  tokens: {
+    // Circle USDC — coin type + 6 decimals verified live on mainnet
+    // (suix_getCoinMetadata) before shipping. No native USDT on Sui.
+    USDC: {
+      coinType: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+      decimals: 6,
+      symbol: "USDC"
+    }
+  }
+};
+
+// src/drivers/sui/pay.ts
+var _transactions = require('@mysten/sui/transactions');
+async function paySui(params) {
+  const { client, keypair, accept } = params;
+  const sender = keypair.getPublicKey().toSuiAddress();
+  const amount = BigInt(accept.amount);
+  try {
+    const tx = new (0, _transactions.Transaction)();
+    tx.setSender(sender);
+    if (accept.asset === "native") {
+      const [coin] = tx.splitCoins(tx.gas, [amount]);
+      tx.transferObjects([coin], accept.payTo);
+    } else {
+      const coins = await client.getCoins({ owner: sender, coinType: accept.asset });
+      if (!coins.data.length) {
+        throw new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+          `Sui wallet holds no ${accept.asset} coin objects to pay from.`
+        );
+      }
+      const ids = coins.data.map((c) => c.coinObjectId);
+      const primary = ids[0];
+      if (ids.length > 1) {
+        tx.mergeCoins(tx.object(primary), ids.slice(1).map((id) => tx.object(id)));
+      }
+      const [coin] = tx.splitCoins(tx.object(primary), [amount]);
+      tx.transferObjects([coin], accept.payTo);
+    }
+    const res = await client.signAndExecuteTransaction({
+      signer: keypair,
+      transaction: tx,
+      options: { showEffects: true }
+    });
+    return res.digest;
+  } catch (err) {
+    if (err instanceof _chunkWQWNPAYQcjs.InsufficientFundsError) throw err;
+    if (isSuiAffordability(err)) {
+      throw new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+        err instanceof Error ? err.message : "Insufficient SUI/coin balance for the payment.",
+        { cause: err }
+      );
+    }
+    throw _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+  }
+}
+function isSuiAffordability(err) {
+  const m = err instanceof Error ? err.message : String(err);
+  return /no valid gas|gas.*(balance|coin)|insufficient|balance is too low|GasBalanceTooLow/i.test(m);
+}
+
+// src/drivers/sui/verify.ts
+async function verifySui(params) {
+  const { reader, digest, accept } = params;
+  const required = BigInt(accept.amount);
+  const wantCoinType = accept.asset === "native" ? SUI_NATIVE_COINTYPE : accept.asset;
+  let tx;
+  try {
+    tx = await reader.getTransaction(digest);
+  } catch (e) {
+    return txNotFound(digest);
+  }
+  if (!tx) return txNotFound(digest);
+  if (tx.status !== "success") {
+    return { ok: false, error: "tx_reverted", detail: `Sui tx ${digest} did not succeed (status=${tx.status}).` };
+  }
+  if (typeof tx.timestampMs === "number") {
+    const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(tx.timestampMs / 1e3);
+    if (ageSeconds > accept.maxTimeoutSeconds) {
+      return {
+        ok: false,
+        error: "payment_expired",
+        detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+      };
+    }
+  }
+  let paid = 0n;
+  let payer = "";
+  for (const bc of tx.balanceChanges) {
+    if (bc.coinType !== wantCoinType) continue;
+    let v;
+    try {
+      v = BigInt(bc.amount);
+    } catch (e2) {
+      continue;
+    }
+    if (bc.owner === accept.payTo && v > 0n) paid += v;
+    else if (v < 0n && !payer) payer = bc.owner;
+  }
+  if (paid < required) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `No Sui transfer of >= ${required} (${wantCoinType}) to ${accept.payTo} in ${digest}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: digest,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function txNotFound(digest) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Sui tx ${digest} not found or not yet propagated \u2014 retry.`
+  };
+}
+
+// src/drivers/sui/wallet.ts
+var _ed25519 = require('@mysten/sui/keypairs/ed25519');
+function assertSuiWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Sui; wallet must be { privateKey } (suiprivkey1\u2026 ) or { keypair }.`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Sui; a viem { walletClient } can't be used \u2014 pass { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "seed" in wallet || "accountId" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Sui; that looks like another family's wallet \u2014 pass { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  if (!("privateKey" in wallet) && !("keypair" in wallet)) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Sui; wallet must be { privateKey } (suiprivkey1\u2026) or { keypair }.`
+    );
+  }
+  return wallet;
+}
+function resolveSuiKeypair(config) {
+  if (config.keypair) return config.keypair;
+  if (config.privateKey != null) {
+    try {
+      return _ed25519.Ed25519Keypair.fromSecretKey(config.privateKey);
+    } catch (cause) {
+      throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+        "Sui wallet { privateKey } is not a valid suiprivkey1\u2026 secret (or 32-byte key).",
+        { cause }
+      );
+    }
+  }
+  throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)("Sui wallet needs { privateKey } (suiprivkey1\u2026) or { keypair }.");
+}
+
+// src/drivers/sui/index.ts
+var suiDriver = {
+  family: "sui",
+  resolve(opts) {
+    if (opts.chain !== "sui") return null;
+    const rpcUrl = _nullishCoalesce(opts.rpcUrl, () => ( SUI_MAINNET.defaultRpc));
+    return makeSuiNetwork(SUI_MAINNET, rpcUrl);
+  }
+};
+function ownerAddress(owner) {
+  if (owner && typeof owner === "object" && "AddressOwner" in owner) {
+    return owner.AddressOwner;
+  }
+  return "";
+}
+function makeSuiNetwork(preset, rpcUrl) {
+  const client = new (0, _jsonRpc.SuiJsonRpcClient)({ url: rpcUrl, network: "mainnet" });
+  const network = preset.caip2;
+  const reader = {
+    async getTransaction(digest) {
+      const tx = await client.getTransactionBlock({
+        digest,
+        options: { showBalanceChanges: true, showEffects: true }
+      });
+      if (!tx) return null;
+      const balanceChanges = (_nullishCoalesce(tx.balanceChanges, () => ( []))).map((bc) => ({
+        owner: ownerAddress(bc.owner),
+        coinType: bc.coinType,
+        amount: bc.amount
+      }));
+      return {
+        status: _nullishCoalesce(_optionalChain([tx, 'access', _ => _.effects, 'optionalAccess', _2 => _2.status, 'optionalAccess', _3 => _3.status]), () => ( "unknown")),
+        timestampMs: tx.timestampMs != null ? Number(tx.timestampMs) : void 0,
+        balanceChanges
+      };
+    }
+  };
+  return {
+    family: "sui",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        return { asset: "native", decimals: SUI_DECIMALS, symbol: SUI_SYMBOL };
+      }
+      if (typeof token === "string") {
+        const info = preset.tokens[token.toUpperCase()];
+        if (!info) {
+          const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
+          throw new (0, _chunkWQWNPAYQcjs.UnknownTokenError)(
+            `token "${token}" isn't built in for Sui (known: ${known}). Note: no native USDT on Sui. Pass { coinType, decimals } for a custom coin, or use 'native'.`
+          );
+        }
+        return { asset: info.coinType, decimals: info.decimals, symbol: info.symbol };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "sui", network);
+      const t = token;
+      if (!t.coinType || typeof t.decimals !== "number") {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Sui; a custom token must be { coinType, decimals }.`
+        );
+      }
+      return {
+        asset: t.coinType,
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return { symbol: SUI_SYMBOL, decimals: SUI_DECIMALS };
+      for (const info of Object.values(preset.tokens)) {
+        if (info.coinType === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (!_utils.isValidSuiAddress.call(void 0, payTo)) {
+        throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Sui, but payTo "${payTo}" is not a valid Sui address (0x + 32 bytes).`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertSuiWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const keypair = resolveSuiKeypair(wallet._native);
+      return paySui({ client, keypair, accept });
+    },
+    async confirm(ref) {
+      try {
+        const tx = await client.waitForTransaction({ digest: ref, options: { showEffects: true } });
+        return { height: String(_nullishCoalesce(tx.checkpoint, () => ( "0"))) };
+      } catch (err) {
+        throw new (0, _chunkWQWNPAYQcjs.ConfirmationTimeoutError)(`Sui tx ${ref} did not finalize in time.`, { cause: err });
+      }
+    },
+    async estimateCost() {
+      return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+        symbol: SUI_SYMBOL,
+        decimals: SUI_DECIMALS,
+        fee: 3000000n,
+        // ~0.003 SUI
+        basis: "heuristic",
+        detail: "\u22480.003 SUI (computation + storage; storage is largely rebated on success)"
+      });
+    },
+    async verify(ref, accept) {
+      return verifySui({ reader, digest: ref, accept });
+    }
+  };
+}
+
+
+exports.suiDriver = suiDriver;

package/dist/ton-E5RLUPD2.cjs

@@ -0,0 +1,366 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/ton/index.ts
+var _core = require('@ton/core');
+var _ton = require('@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
+
+
+var OP_JETTON_TRANSFER = 260734629;
+var JETTON_GAS = _core.toNano.call(void 0, "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 = _core.comment.call(void 0, accept.extra.nonce);
+  const message = accept.asset === "native" ? _core.internal.call(void 0, {
+    to: _core.Address.parse(accept.payTo),
+    value: BigInt(accept.amount),
+    bounce: false,
+    body: cmt
+  }) : _core.internal.call(void 0, {
+    to: senderJettonWallet,
+    value: JETTON_GAS,
+    bounce: true,
+    body: buildJettonTransfer(accept, wallet.contract.address, cmt)
+  });
+  await opened.sendTransfer({
+    seqno,
+    secretKey: wallet.keyPair.secretKey,
+    sendMode: _ton.SendMode.PAY_GAS_SEPARATELY | _ton.SendMode.IGNORE_ERRORS,
+    messages: [message]
+  });
+  await waitForSeqno(opened, seqno);
+}
+function buildJettonTransfer(accept, responseTo, forward) {
+  return _core.beginCell.call(void 0, ).storeUint(OP_JETTON_TRANSFER, 32).storeUint(0n, 64).storeCoins(BigInt(accept.amount)).storeAddress(_core.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 _chunkCQREG5LEcjs.delay.call(void 0, intervalMs);
+    let current;
+    try {
+      current = await opened.getSeqno();
+    } catch (e) {
+      continue;
+    }
+    if (current > from) return;
+  }
+  throw new (0, _chunkWQWNPAYQcjs.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 (e2) {
+    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: (_nullishCoalesce(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 (e3) {
+    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 (e4) {
+    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 (e5) {
+    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
+var _crypto = require('@ton/crypto');
+
+function assertTonWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
+    );
+  }
+  if ("privateKey" in wallet || "walletClient" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
+    );
+  }
+  return wallet;
+}
+async function resolveTonWallet(config) {
+  const version = _nullishCoalesce(config.version, () => ( "v4"));
+  let keyPair;
+  if (config.mnemonic) {
+    const words = Array.isArray(config.mnemonic) ? config.mnemonic : config.mnemonic.trim().split(/\s+/);
+    keyPair = await _crypto.mnemonicToWalletKey.call(void 0, words);
+  } else if (config.keyPair) {
+    keyPair = config.keyPair;
+  } else {
+    throw new (0, _chunkWQWNPAYQcjs.WrongFamilyError)("TON wallet needs { mnemonic } (24 words) or { keyPair }.");
+  }
+  const contract = version === "v5r1" ? _ton.WalletContractV5R1.create({ workchain: 0, publicKey: keyPair.publicKey }) : _ton.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 = _nullishCoalesce(opts.rpcUrl, () => ( TON_MAINNET.defaultRpc));
+    return makeTonNetwork(TON_MAINNET, rpcUrl);
+  }
+};
+function makeTonNetwork(preset, rpcUrl) {
+  const client = new (0, _ton.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(_ton.JettonMaster.create(_core.Address.parse(master))).getWalletAddress(_core.Address.parse(owner));
+      jwCache.set(key, p);
+    }
+    return p;
+  }
+  function watchAccountFor(accept) {
+    return accept.asset === "native" ? Promise.resolve(_core.Address.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 (0, _chunkWQWNPAYQcjs.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 };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "ton", network);
+      if (!("master" in token)) {
+        throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is TON, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      try {
+        _core.Address.parse(payTo);
+      } catch (e6) {
+        throw new (0, _chunkWQWNPAYQcjs.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 _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+      }
+    },
+    async confirm(ref) {
+      const { watch, nonce } = decodeRef(ref);
+      const account = _core.Address.parse(watch);
+      for (let i = 0; i < 40; i += 1) {
+        await _chunkCQREG5LEcjs.delay.call(void 0, 2500);
+        let txs;
+        try {
+          txs = await client.getTransactions(account, { limit: 16, archival: true });
+        } catch (e7) {
+          continue;
+        }
+        for (const tx of txs) {
+          const inc = extractIncoming(tx);
+          if (inc && inc.comment === nonce) return { height: tx.lt.toString() };
+        }
+      }
+      throw new (0, _chunkWQWNPAYQcjs.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 _chunkWQWNPAYQcjs.nativeCost.call(void 0, { 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) };
+}
+
+
+exports.tonDriver = tonDriver;