@piprail/sdk 1.0.0

package/dist/tron-3UDH7KGF.cjs

@@ -0,0 +1,372 @@
+"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 _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
+
+
+
+
+
+
+
+
+var _chunkWQWNPAYQcjs = require('./chunk-WQWNPAYQ.cjs');
+
+// src/drivers/tron/index.ts
+var _tronweb = require('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 (!_optionalChain([built, 'access', _ => _.result, 'optionalAccess', _2 => _2.result])) {
+      throw new Error(
+        `Tron transfer build failed${_optionalChain([built, 'access', _3 => _3.result, 'optionalAccess', _4 => _4.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 || _optionalChain([broadcast, 'access', _5 => _5.transaction, 'optionalAccess', _6 => _6.txID])) {
+      return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _7 => _7.transaction, 'optionalAccess', _8 => _8.txID]))), () => ( signed.txID));
+    }
+    if (isTronAffordability(broadcast.code, broadcast.message)) {
+      throw new (0, _chunkWQWNPAYQcjs.InsufficientFundsError)(
+        `Tron payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for energy/bandwidth, or insufficient token balance.`
+      );
+    }
+    throw new Error(
+      `Tron broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
+    );
+  } catch (err) {
+    if (err instanceof _chunkWQWNPAYQcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunkWQWNPAYQcjs.toInsufficientFundsError.call(void 0, 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 (e) {
+    }
+  }
+  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 (e2) {
+    return txNotFound(txid);
+  }
+  if (!info || !info.id) return txNotFound(txid);
+  if (_optionalChain([info, 'access', _9 => _9.receipt, 'optionalAccess', _10 => _10.result]) !== "SUCCESS") {
+    return {
+      ok: false,
+      error: "tx_reverted",
+      detail: `Tron tx ${txid} did not succeed (receipt.result=${_nullishCoalesce(_optionalChain([info, 'access', _11 => _11.receipt, 'optionalAccess', _12 => _12.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(_nullishCoalesce(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 ((_nullishCoalesce(log.address, () => ( ""))).toLowerCase() !== tokenHex20) continue;
+    const topics = _nullishCoalesce(log.topics, () => ( []));
+    if (topics.length < 3) continue;
+    if ((_nullishCoalesce(topics[0], () => ( ""))).toLowerCase() !== TRANSFER_TOPIC) continue;
+    if (last20(topics[2]) !== payToHex20) continue;
+    try {
+      total += BigInt(`0x${log.data}`);
+      from = last20(topics[1]);
+    } catch (e3) {
+    }
+  }
+  return { total, from };
+}
+function last20(topic) {
+  return (_nullishCoalesce(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 (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
+    );
+  }
+  if ("walletClient" in wallet) {
+    throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+      `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
+    );
+  }
+  return wallet;
+}
+function resolveTronPrivateKey(config) {
+  if (!config.privateKey) {
+    throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.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 = _nullishCoalesce(opts.rpcUrl, () => ( TRON_MAINNET.defaultRpc));
+    return makeTronNetwork(TRON_MAINNET, rpcUrl);
+  }
+};
+function makeTronNetwork(preset, rpcUrl) {
+  const tronWeb = new (0, _tronweb.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 (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.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 };
+      }
+      _chunkWQWNPAYQcjs.rejectForeignToken.call(void 0, token, "tron", network);
+      if (!("address" in token)) {
+        throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.WrongFamilyError)(
+          `chain ${network} is Tron, but payTo "${payTo}" looks like an EVM address.`
+        );
+      }
+      if (!tronWeb.isAddress(payTo)) {
+        throw new (0, _chunkWQWNPAYQcjs.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 (0, _chunkWQWNPAYQcjs.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(_nullishCoalesce(info.blockNumber, () => ( 0))) };
+        } catch (e4) {
+        }
+        await _chunkCQREG5LEcjs.delay.call(void 0, 2500);
+      }
+      throw new (0, _chunkWQWNPAYQcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
+    },
+    async estimateCost(accept, opts) {
+      const ENERGY_PRICE = 420n;
+      const BANDWIDTH_SUN = 345000n;
+      if (_optionalChain([opts, 'optionalAccess', _13 => _13.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(_nullishCoalesce(r.energy_used, () => ( 0)));
+          if (energy > 0n) {
+            return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+              symbol: "TRX",
+              decimals: TRX_DECIMALS,
+              fee: energy * ENERGY_PRICE + BANDWIDTH_SUN,
+              basis: "estimated",
+              detail: `energy ${energy} @ ${ENERGY_PRICE} sun + bandwidth`
+            });
+          }
+        } catch (e5) {
+        }
+      }
+      return _chunkWQWNPAYQcjs.nativeCost.call(void 0, {
+        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;
+}
+
+
+exports.tronDriver = tronDriver;