@piprail/sdk 1.0.0

package/dist/tron-243DT6PF.js

@@ -0,0 +1,372 @@
+import {
+  delay
+} from "./chunk-FURB5RP7.js";
+import {
+  ConfirmationTimeoutError,
+  InsufficientFundsError,
+  UnknownTokenError,
+  WrongFamilyError,
+  nativeCost,
+  rejectForeignToken,
+  toInsufficientFundsError
+} from "./chunk-3TQJJ4SQ.js";
+
+// src/drivers/tron/index.ts
+import { TronWeb } from "tronweb";
+
+// src/drivers/tron/chains.ts
+var TRX_DECIMALS = 6;
+var TRON_MAINNET = {
+  caip2: "tron:mainnet",
+  defaultRpc: "https://api.trongrid.io",
+  tokens: {
+    // USD₮ (Tether) — the dominant stablecoin on Tron. Contract + 6 decimals +
+    // symbol verified live on-chain (TronGrid triggerconstantcontract) before shipping.
+    USDT: {
+      address: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      decimals: 6,
+      symbol: "USDT"
+    }
+  }
+};
+
+// src/drivers/tron/pay.ts
+var TRANSFER_FN = "transfer(address,uint256)";
+var FEE_LIMIT = 1e8;
+async function payTron(params) {
+  const { client, from, privateKey, tokenAddress, accept, bind } = params;
+  try {
+    const built = await client.transactionBuilder.triggerSmartContract(
+      tokenAddress,
+      TRANSFER_FN,
+      { feeLimit: FEE_LIMIT },
+      [
+        { type: "address", value: accept.payTo },
+        { type: "uint256", value: accept.amount }
+      ],
+      from
+    );
+    if (!built.result?.result) {
+      throw new Error(
+        `Tron transfer build failed${built.result?.message ? `: ${decodeMaybeHex(built.result.message)}` : ""}.`
+      );
+    }
+    let unsigned = built.transaction;
+    if (bind === "memo") {
+      unsigned = await client.transactionBuilder.addUpdateData(unsigned, accept.extra.nonce, "utf8");
+    }
+    const signed = await client.trx.sign(unsigned, privateKey);
+    const broadcast = await client.trx.sendRawTransaction(signed);
+    if (broadcast.result === true || broadcast.txid || broadcast.transaction?.txID) {
+      return broadcast.txid ?? broadcast.transaction?.txID ?? signed.txID;
+    }
+    if (isTronAffordability(broadcast.code, broadcast.message)) {
+      throw new InsufficientFundsError(
+        `Tron payment rejected (${broadcast.code ?? "broadcast"}): not enough TRX for energy/bandwidth, or insufficient token balance.`
+      );
+    }
+    throw new Error(
+      `Tron broadcast failed: ${broadcast.code ?? ""} ${decodeMaybeHex(broadcast.message)}`.trim()
+    );
+  } catch (err) {
+    if (err instanceof InsufficientFundsError) throw err;
+    throw toInsufficientFundsError(err) ?? err;
+  }
+}
+function decodeMaybeHex(message) {
+  if (!message) return "";
+  if (/^[0-9a-fA-F]+$/.test(message) && message.length % 2 === 0) {
+    try {
+      const decoded = Buffer.from(message, "hex").toString("utf8");
+      if (/^[\x20-\x7e\s]+$/.test(decoded)) return decoded;
+    } catch {
+    }
+  }
+  return message;
+}
+function isTronAffordability(code, message) {
+  const decoded = decodeMaybeHex(message);
+  if (code && /BANDWIDTH_ERROR|CONTRACT_VALIDATE_ERROR/.test(code)) {
+    return /balance is not sufficient|insufficient|not enough|exceeds/i.test(decoded);
+  }
+  return /balance is not sufficient|insufficient (funds|balance|energy)|not enough/i.test(decoded);
+}
+
+// src/drivers/tron/verify.ts
+var TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+async function verifyTron(params) {
+  const { reader, accept, txid, tokenHex20, payToHex20, toBase58 } = params;
+  const required = BigInt(accept.amount);
+  let info;
+  try {
+    info = await reader.getTransactionInfo(txid);
+  } catch {
+    return txNotFound(txid);
+  }
+  if (!info || !info.id) return txNotFound(txid);
+  if (info.receipt?.result !== "SUCCESS") {
+    return {
+      ok: false,
+      error: "tx_reverted",
+      detail: `Tron tx ${txid} did not succeed (receipt.result=${info.receipt?.result ?? "none"}).`
+    };
+  }
+  const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(info.blockTimeStamp / 1e3);
+  if (Number.isFinite(ageSeconds) && ageSeconds > accept.maxTimeoutSeconds) {
+    return {
+      ok: false,
+      error: "payment_expired",
+      detail: `Payment is ${ageSeconds}s old; max allowed is ${accept.maxTimeoutSeconds}s.`
+    };
+  }
+  const { total, from } = sumTransfersTo(info.log ?? [], tokenHex20, payToHex20);
+  if (total < required) {
+    return {
+      ok: false,
+      error: "transfer_not_found",
+      detail: `No TRC-20 Transfer of >= ${required} (token ${accept.asset}) to ${accept.payTo} in ${txid}.`
+    };
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "onchain-proof",
+      success: true,
+      network: accept.network,
+      transaction: txid,
+      asset: accept.asset,
+      amount: accept.amount,
+      payer: from ? toBase58(from) : "",
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function sumTransfersTo(logs, tokenHex20, payToHex20) {
+  let total = 0n;
+  let from = null;
+  for (const log of logs) {
+    if ((log.address ?? "").toLowerCase() !== tokenHex20) continue;
+    const topics = log.topics ?? [];
+    if (topics.length < 3) continue;
+    if ((topics[0] ?? "").toLowerCase() !== TRANSFER_TOPIC) continue;
+    if (last20(topics[2]) !== payToHex20) continue;
+    try {
+      total += BigInt(`0x${log.data}`);
+      from = last20(topics[1]);
+    } catch {
+    }
+  }
+  return { total, from };
+}
+function last20(topic) {
+  return (topic ?? "").slice(-40).toLowerCase();
+}
+function txNotFound(txid) {
+  return {
+    ok: false,
+    error: "tx_not_found",
+    detail: `Tron tx ${txid} not found or not yet confirmed (solidified) \u2014 retry.`
+  };
+}
+
+// src/drivers/tron/wallet.ts
+function assertTronWallet(wallet, network) {
+  if (typeof wallet !== "object" || wallet === null) {
+    throw new WrongFamilyError(
+      `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Tron; a viem { walletClient } can't be used \u2014 pass { privateKey } (32-byte hex).`
+    );
+  }
+  if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "keypair" in wallet || "seed" in wallet) {
+    throw new WrongFamilyError(
+      `chain ${network} is Tron; that looks like a Solana/TON/Stellar/XRPL wallet \u2014 pass { privateKey } (32-byte hex).`
+    );
+  }
+  if (!("privateKey" in wallet)) {
+    throw new WrongFamilyError(
+      `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
+    );
+  }
+  return wallet;
+}
+function resolveTronPrivateKey(config) {
+  if (!config.privateKey) {
+    throw new WrongFamilyError("Tron wallet needs { privateKey } (32-byte hex).");
+  }
+  const hex = config.privateKey.replace(/^0x/i, "").toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(hex)) {
+    throw new WrongFamilyError(
+      "Tron wallet { privateKey } must be a 32-byte hex string (64 hex chars)."
+    );
+  }
+  return hex;
+}
+
+// src/drivers/tron/index.ts
+var tronDriver = {
+  family: "tron",
+  resolve(opts) {
+    if (opts.chain !== "tron") return null;
+    const rpcUrl = opts.rpcUrl ?? TRON_MAINNET.defaultRpc;
+    return makeTronNetwork(TRON_MAINNET, rpcUrl);
+  }
+};
+function makeTronNetwork(preset, rpcUrl) {
+  const tronWeb = new TronWeb({ fullHost: rpcUrl });
+  const network = preset.caip2;
+  function hex20(base58) {
+    return tronWeb.address.toHex(base58).replace(/^41/i, "").toLowerCase();
+  }
+  const reader = {
+    async getTransactionInfo(txid) {
+      const info = await tronWeb.trx.getTransactionInfo(txid);
+      if (!info || !info.id) return null;
+      return info;
+    }
+  };
+  return {
+    family: "tron",
+    network,
+    supports: (n) => n === network,
+    resolveToken(token) {
+      if (token === "native") {
+        throw new UnknownTokenError(
+          `Tron payments are TRC-20 only \u2014 native TRX isn't a built-in asset. Use 'USDT' or a custom { address, decimals }.`
+        );
+      }
+      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 Tron (known: ${known}). Note: native USDC doesn't exist on Tron. Pass { address, decimals } for a custom TRC-20.`
+          );
+        }
+        return { asset: info.address, decimals: info.decimals, symbol: info.symbol };
+      }
+      rejectForeignToken(token, "tron", network);
+      if (!("address" in token)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Tron; a custom token must be { address, decimals } (Base58 T\u2026 contract).`
+        );
+      }
+      const t = token;
+      if (t.address.startsWith("0x") || !tronWeb.isAddress(t.address)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Tron, but token address "${t.address}" is not a valid Tron contract (T\u2026).`
+        );
+      }
+      return {
+        asset: t.address,
+        decimals: t.decimals,
+        ...t.symbol ? { symbol: t.symbol } : {}
+      };
+    },
+    describeAsset(asset) {
+      if (asset === "native") return null;
+      for (const info of Object.values(preset.tokens)) {
+        if (info.address === asset) return { symbol: info.symbol, decimals: info.decimals };
+      }
+      return null;
+    },
+    assertValidPayTo(payTo) {
+      if (payTo.startsWith("0x")) {
+        throw new WrongFamilyError(
+          `chain ${network} is Tron, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!tronWeb.isAddress(payTo)) {
+        throw new WrongFamilyError(
+          `chain ${network} is Tron, but payTo "${payTo}" is not a valid Tron address (T\u2026).`
+        );
+      }
+    },
+    bindWallet(wallet) {
+      return { _native: assertTronWallet(wallet, network) };
+    },
+    async send(wallet, accept) {
+      const privateKey = resolveTronPrivateKey(wallet._native);
+      const from = tronWeb.address.fromPrivateKey(privateKey);
+      if (!from) {
+        throw new WrongFamilyError("Tron wallet { privateKey } could not derive an address.");
+      }
+      return payTron({
+        client: tronWeb,
+        from,
+        privateKey,
+        tokenAddress: accept.asset,
+        accept
+      });
+    },
+    async confirm(ref) {
+      const txid = stripTronPrefix(ref);
+      for (let i = 0; i < 30; i += 1) {
+        try {
+          const info = await reader.getTransactionInfo(txid);
+          if (info) return { height: String(info.blockNumber ?? 0) };
+        } catch {
+        }
+        await delay(2500);
+      }
+      throw new ConfirmationTimeoutError(`Tron tx ${txid} did not solidify in time.`);
+    },
+    async estimateCost(accept, opts) {
+      const ENERGY_PRICE = 420n;
+      const BANDWIDTH_SUN = 345000n;
+      if (opts?.from) {
+        try {
+          const r = await tronWeb.transactionBuilder.triggerConstantContract(
+            accept.asset,
+            "transfer(address,uint256)",
+            {},
+            [
+              { type: "address", value: accept.payTo },
+              { type: "uint256", value: accept.amount }
+            ],
+            opts.from
+          );
+          const energy = BigInt(r.energy_used ?? 0);
+          if (energy > 0n) {
+            return nativeCost({
+              symbol: "TRX",
+              decimals: TRX_DECIMALS,
+              fee: energy * ENERGY_PRICE + BANDWIDTH_SUN,
+              basis: "estimated",
+              detail: `energy ${energy} @ ${ENERGY_PRICE} sun + bandwidth`
+            });
+          }
+        } catch {
+        }
+      }
+      return nativeCost({
+        symbol: "TRX",
+        decimals: TRX_DECIMALS,
+        fee: 30000n * ENERGY_PRICE + BANDWIDTH_SUN,
+        basis: "heuristic",
+        detail: "~30k energy + bandwidth (sender not staked; pass { from } for a precise estimate)"
+      });
+    },
+    async verify(ref, accept) {
+      const txid = stripTronPrefix(ref);
+      return verifyTron({
+        reader,
+        accept,
+        txid,
+        tokenHex20: hex20(accept.asset),
+        payToHex20: hex20(accept.payTo),
+        toBase58: (h) => tronWeb.address.fromHex(`41${h}`)
+      });
+    }
+  };
+}
+function stripTronPrefix(ref) {
+  return ref.startsWith("tron:") ? ref.slice(5) : ref;
+}
+export {
+  tronDriver
+};