@piprail/sdk 1.14.0 → 1.15.1

package/dist/{ton-5DLKKOFE.cjs → ton-RNEFN25G.cjs}

@@ -8,7 +8,7 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunkFTKVCP6Kcjs = require('./chunk-FTKVCP6K.cjs');
+var _chunkPA6YD3HLcjs = require('./chunk-PA6YD3HL.cjs');
 
 // src/drivers/ton/index.ts
 var _core = require('@ton/core');
@@ -74,7 +74,7 @@ async function waitForSeqno(opened, from, { tries = 30, intervalMs = 2e3 } = {})
     }
     if (current > from) return;
   }
-  throw new (0, _chunkFTKVCP6Kcjs.ConfirmationTimeoutError)(
+  throw new (0, _chunkPA6YD3HLcjs.ConfirmationTimeoutError)(
     `TON wallet seqno did not advance past ${from} \u2014 the payment may not have been accepted.`
   );
 }
@@ -202,17 +202,17 @@ var _crypto = require('@ton/crypto');
 
 function assertTonWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
     );
   }
   if ("privateKey" in wallet || "walletClient" in wallet) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.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, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is TON; wallet must be { mnemonic } (24 words) or { keyPair }.`
     );
   }
@@ -227,7 +227,7 @@ async function resolveTonWallet(config) {
   } else if (config.keyPair) {
     keyPair = config.keyPair;
   } else {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)("TON wallet needs { mnemonic } (24 words) or { keyPair }.");
+    throw new (0, _chunkPA6YD3HLcjs.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 };
@@ -270,15 +270,15 @@ function makeTonNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkFTKVCP6Kcjs.UnknownTokenError)(
+          throw new (0, _chunkPA6YD3HLcjs.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 };
       }
-      _chunkFTKVCP6Kcjs.rejectForeignToken.call(void 0, token, "ton", network);
+      _chunkPA6YD3HLcjs.rejectForeignToken.call(void 0, token, "ton", network);
       if (!("master" in token)) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is TON; a custom token must be { master, decimals }.`
         );
       }
@@ -297,14 +297,14 @@ function makeTonNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is TON, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       try {
         _core.Address.parse(payTo);
       } catch (e6) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is TON, but payTo "${payTo}" is not a valid TON address.`
         );
       }
@@ -320,7 +320,7 @@ function makeTonNetwork(preset, rpcUrl) {
         const watch = await watchAccountFor(accept);
         return encodeRef(watch, accept.extra.nonce);
       } catch (err) {
-        throw _nullishCoalesce(_chunkFTKVCP6Kcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+        throw _nullishCoalesce(_chunkPA6YD3HLcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
       }
     },
     async confirm(ref) {
@@ -339,12 +339,12 @@ function makeTonNetwork(preset, rpcUrl) {
           if (inc && inc.comment === nonce) return { height: tx.lt.toString() };
         }
       }
-      throw new (0, _chunkFTKVCP6Kcjs.ConfirmationTimeoutError)(`TON payment for nonce ${nonce} did not settle in time.`);
+      throw new (0, _chunkPA6YD3HLcjs.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 _chunkFTKVCP6Kcjs.nativeCost.call(void 0, { symbol: "TON", decimals: TON_DECIMALS, fee, basis: "heuristic", detail });
+      return _chunkPA6YD3HLcjs.nativeCost.call(void 0, { symbol: "TON", decimals: TON_DECIMALS, fee, basis: "heuristic", detail });
     },
     async balanceOf(wallet, asset) {
       let owner;

package/dist/{tron-2N2GA62O.js → tron-DD3JDROV.js}

@@ -9,7 +9,7 @@ import {
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-H3A4KWLJ.js";
+} from "./chunk-ILPABTI2.js";
 
 // src/drivers/tron/index.ts
 import { TronWeb } from "tronweb";

package/dist/{tron-HHIT6WKY.cjs → tron-TKJHNFGM.cjs}

@@ -9,7 +9,7 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunkFTKVCP6Kcjs = require('./chunk-FTKVCP6K.cjs');
+var _chunkPA6YD3HLcjs = require('./chunk-PA6YD3HL.cjs');
 
 // src/drivers/tron/index.ts
 var _tronweb = require('tronweb');
@@ -61,7 +61,7 @@ async function payTron(params) {
       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, _chunkFTKVCP6Kcjs.InsufficientFundsError)(
+      throw new (0, _chunkPA6YD3HLcjs.InsufficientFundsError)(
         `Tron payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for energy/bandwidth, or insufficient token balance.`
       );
     }
@@ -69,8 +69,8 @@ async function payTron(params) {
       `Tron broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunkFTKVCP6Kcjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunkFTKVCP6Kcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunkPA6YD3HLcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunkPA6YD3HLcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 async function payTronNative(params) {
@@ -83,7 +83,7 @@ async function payTronNative(params) {
       return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _11 => _11.transaction, 'optionalAccess', _12 => _12.txID]))), () => ( signed.txID));
     }
     if (isTronAffordability(broadcast.code, broadcast.message)) {
-      throw new (0, _chunkFTKVCP6Kcjs.InsufficientFundsError)(
+      throw new (0, _chunkPA6YD3HLcjs.InsufficientFundsError)(
         `Tron TRX payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for the amount plus bandwidth (and the ~1 TRX account-creation fee if the recipient is new).`
       );
     }
@@ -91,8 +91,8 @@ async function payTronNative(params) {
       `Tron TRX broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunkFTKVCP6Kcjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunkFTKVCP6Kcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunkPA6YD3HLcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunkPA6YD3HLcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 function decodeMaybeHex(message) {
@@ -263,22 +263,22 @@ function txNotFound(txid) {
 // src/drivers/tron/wallet.ts
 function assertTronWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
     );
   }
   if ("walletClient" in wallet) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.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, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.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, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { privateKey } (32-byte hex).`
     );
   }
@@ -286,11 +286,11 @@ function assertTronWallet(wallet, network) {
 }
 function resolveTronPrivateKey(config) {
   if (!config.privateKey) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)("Tron wallet needs { privateKey } (32-byte hex).");
+    throw new (0, _chunkPA6YD3HLcjs.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, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       "Tron wallet { privateKey } must be a 32-byte hex string (64 hex chars)."
     );
   }
@@ -340,21 +340,21 @@ function makeTronNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkFTKVCP6Kcjs.UnknownTokenError)(
+          throw new (0, _chunkPA6YD3HLcjs.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 };
       }
-      _chunkFTKVCP6Kcjs.rejectForeignToken.call(void 0, token, "tron", network);
+      _chunkPA6YD3HLcjs.rejectForeignToken.call(void 0, token, "tron", network);
       if (!("address" in token)) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.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, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is Tron, but token address "${t.address}" is not a valid Tron contract (T\u2026).`
         );
       }
@@ -373,12 +373,12 @@ function makeTronNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       if (!tronWeb.isAddress(payTo)) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" is not a valid Tron address (T\u2026).`
         );
       }
@@ -390,7 +390,7 @@ function makeTronNetwork(preset, rpcUrl) {
       const privateKey = resolveTronPrivateKey(wallet._native);
       const from = tronWeb.address.fromPrivateKey(privateKey);
       if (!from) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)("Tron wallet { privateKey } could not derive an address.");
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)("Tron wallet { privateKey } could not derive an address.");
       }
       if (accept.asset === "native") {
         return payTronNative({ client: tronWeb, from, privateKey, accept });
@@ -413,11 +413,11 @@ function makeTronNetwork(preset, rpcUrl) {
         }
         await _chunkCQREG5LEcjs.delay.call(void 0, 2500);
       }
-      throw new (0, _chunkFTKVCP6Kcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
+      throw new (0, _chunkPA6YD3HLcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
     },
     async estimateCost(accept, opts) {
       if (accept.asset === "native") {
-        return _chunkFTKVCP6Kcjs.nativeCost.call(void 0, {
+        return _chunkPA6YD3HLcjs.nativeCost.call(void 0, {
           symbol: "TRX",
           decimals: TRX_DECIMALS,
           fee: 1300000n,
@@ -441,7 +441,7 @@ function makeTronNetwork(preset, rpcUrl) {
           );
           const energy = BigInt(_nullishCoalesce(r.energy_used, () => ( 0)));
           if (energy > 0n) {
-            return _chunkFTKVCP6Kcjs.nativeCost.call(void 0, {
+            return _chunkPA6YD3HLcjs.nativeCost.call(void 0, {
               symbol: "TRX",
               decimals: TRX_DECIMALS,
               fee: energy * ENERGY_PRICE + BANDWIDTH_SUN,
@@ -452,7 +452,7 @@ function makeTronNetwork(preset, rpcUrl) {
         } catch (e8) {
         }
       }
-      return _chunkFTKVCP6Kcjs.nativeCost.call(void 0, {
+      return _chunkPA6YD3HLcjs.nativeCost.call(void 0, {
         symbol: "TRX",
         decimals: TRX_DECIMALS,
         fee: 30000n * ENERGY_PRICE + BANDWIDTH_SUN,

package/dist/{xrpl-2GZMDYW5.js → xrpl-GTUPP6SK.js}

@@ -12,7 +12,7 @@ import {
   parseUnits,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-H3A4KWLJ.js";
+} from "./chunk-ILPABTI2.js";
 
 // src/drivers/xrpl/index.ts
 import { isValidClassicAddress } from "xrpl";

package/dist/{xrpl-USEG4AHX.cjs → xrpl-XN2NBNGI.cjs}

@@ -12,7 +12,7 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunkFTKVCP6Kcjs = require('./chunk-FTKVCP6K.cjs');
+var _chunkPA6YD3HLcjs = require('./chunk-PA6YD3HL.cjs');
 
 // src/drivers/xrpl/index.ts
 var _xrpl = require('xrpl');
@@ -94,17 +94,17 @@ async function payXrpl(params) {
     const code = res.engine_result;
     if (code.startsWith("tes")) return _nullishCoalesce(_optionalChain([res, 'access', _ => _.tx_json, 'optionalAccess', _2 => _2.hash]), () => ( signed.hash));
     const recipientMsg = recipientNotReadyMessage(code);
-    if (recipientMsg) throw new (0, _chunkFTKVCP6Kcjs.RecipientNotReadyError)(recipientMsg, { cause: makeEngineError(res) });
+    if (recipientMsg) throw new (0, _chunkPA6YD3HLcjs.RecipientNotReadyError)(recipientMsg, { cause: makeEngineError(res) });
     if (isAffordabilityCode(code)) {
-      throw new (0, _chunkFTKVCP6Kcjs.InsufficientFundsError)(
+      throw new (0, _chunkPA6YD3HLcjs.InsufficientFundsError)(
         `XRPL payment rejected: the sender can't cover it \u2014 balance or the 1 XRP base reserve. (XRPL: ${code})`,
         { cause: makeEngineError(res) }
       );
     }
     throw makeEngineError(res);
   } catch (err) {
-    if (err instanceof _chunkFTKVCP6Kcjs.InsufficientFundsError || err instanceof _chunkFTKVCP6Kcjs.RecipientNotReadyError) throw err;
-    throw _nullishCoalesce(_chunkFTKVCP6Kcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunkPA6YD3HLcjs.InsufficientFundsError || err instanceof _chunkPA6YD3HLcjs.RecipientNotReadyError) throw err;
+    throw _nullishCoalesce(_chunkPA6YD3HLcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 function amountForAccept(accept) {
@@ -229,7 +229,7 @@ function deliveredBaseUnits(delivered, want, decimals) {
     return null;
   }
   try {
-    return _chunkFTKVCP6Kcjs.floorUnits.call(void 0, delivered.value, decimals);
+    return _chunkPA6YD3HLcjs.floorUnits.call(void 0, delivered.value, decimals);
   } catch (e3) {
     return null;
   }
@@ -253,22 +253,22 @@ function rpcFailed(nonce) {
 
 function assertXrplWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is XRPL; wallet must be { seed } (s\u2026 seed) or { wallet }.`
     );
   }
   if ("privateKey" in wallet || "walletClient" in wallet) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is XRPL; an EVM wallet can't be used \u2014 pass { seed } (s\u2026 seed) or { wallet }.`
     );
   }
   if ("secretKey" in wallet || "signer" in wallet || "mnemonic" in wallet || "keyPair" in wallet || "secret" in wallet || "keypair" in wallet) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is XRPL; that looks like a Solana/TON/Stellar wallet \u2014 pass { seed } (s\u2026 seed) or { wallet }.`
     );
   }
   if (!("seed" in wallet) && !("wallet" in wallet)) {
-    throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+    throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
       `chain ${network} is XRPL; wallet must be { seed } (s\u2026 seed) or { wallet }.`
     );
   }
@@ -278,11 +278,11 @@ function resolveXrplWallet(config) {
   if (config.wallet) return config.wallet;
   if (config.seed) {
     if (!_xrpl.isValidSecret.call(void 0, config.seed)) {
-      throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)("XRPL wallet { seed } is not a valid s\u2026 secret seed.");
+      throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)("XRPL wallet { seed } is not a valid s\u2026 secret seed.");
     }
     return _xrpl.Wallet.fromSeed(config.seed);
   }
-  throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)("XRPL wallet needs { seed } (s\u2026 seed) or { wallet }.");
+  throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)("XRPL wallet needs { seed } (s\u2026 seed) or { wallet }.");
 }
 
 // src/drivers/xrpl/index.ts
@@ -357,7 +357,7 @@ function makeXrplNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkFTKVCP6Kcjs.UnknownTokenError)(
+          throw new (0, _chunkPA6YD3HLcjs.UnknownTokenError)(
             `token "${token}" isn't built in for XRPL (known: ${known}). Pass { issuer, currencyHex, decimals } for a custom IOU, or use 'native'.`
           );
         }
@@ -367,10 +367,10 @@ function makeXrplNetwork(preset, rpcUrl) {
           symbol: info.symbol
         };
       }
-      _chunkFTKVCP6Kcjs.rejectForeignToken.call(void 0, token, "xrpl", network);
+      _chunkPA6YD3HLcjs.rejectForeignToken.call(void 0, token, "xrpl", network);
       const t = token;
       if (!t.issuer || !t.currencyHex || typeof t.decimals !== "number") {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is XRPL; a custom token must be { issuer, currencyHex, decimals }.`
         );
       }
@@ -391,12 +391,12 @@ function makeXrplNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is XRPL, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       if (!_xrpl.isValidClassicAddress.call(void 0, payTo)) {
-        throw new (0, _chunkFTKVCP6Kcjs.WrongFamilyError)(
+        throw new (0, _chunkPA6YD3HLcjs.WrongFamilyError)(
           `chain ${network} is XRPL, but payTo "${payTo}" is not a valid XRPL account (r\u2026).`
         );
       }
@@ -419,14 +419,14 @@ function makeXrplNetwork(preset, rpcUrl) {
         }
         await _chunkCQREG5LEcjs.delay.call(void 0, 1500);
       }
-      throw new (0, _chunkFTKVCP6Kcjs.ConfirmationTimeoutError)(`XRPL tx ${ref} not validated on-ledger in time.`);
+      throw new (0, _chunkPA6YD3HLcjs.ConfirmationTimeoutError)(`XRPL tx ${ref} not validated on-ledger in time.`);
     },
     async estimateCost() {
       try {
         const drops = await payClient.feeDrops();
         const n = Number(drops);
         const fee = BigInt(Number.isFinite(n) && n > 12 ? Math.ceil(n) : 12);
-        return _chunkFTKVCP6Kcjs.nativeCost.call(void 0, {
+        return _chunkPA6YD3HLcjs.nativeCost.call(void 0, {
           symbol: XRP_SYMBOL,
           decimals: XRP_DECIMALS,
           fee,
@@ -434,7 +434,7 @@ function makeXrplNetwork(preset, rpcUrl) {
           detail: `network fee ${fee} drops`
         });
       } catch (e5) {
-        return _chunkFTKVCP6Kcjs.nativeCost.call(void 0, {
+        return _chunkPA6YD3HLcjs.nativeCost.call(void 0, {
           symbol: XRP_SYMBOL,
           decimals: XRP_DECIMALS,
           fee: 12n,
@@ -471,7 +471,7 @@ function makeXrplNetwork(preset, rpcUrl) {
         const line = r.lines.find(
           (l) => l.currency.toUpperCase() === (_nullishCoalesce(currencyHex, () => ( ""))).toUpperCase() && l.account === issuer
         );
-        token = line ? _chunkFTKVCP6Kcjs.parseUnits.call(void 0, line.balance, XRP_DECIMALS) : 0n;
+        token = line ? _chunkPA6YD3HLcjs.parseUnits.call(void 0, line.balance, XRP_DECIMALS) : 0n;
       } catch (e) {
         token = isXrplActNotFound(e) ? 0n : null;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piprail/sdk",
-  "version": "1.14.0",
+  "version": "1.15.1",
   "description": "Accept x402 crypto payments across 29 chains — every major EVM chain plus Solana, TON, Tron, NEAR, Sui, Aptos, Algorand, Stellar & XRPL — in a couple of lines. No backend, no database, no fee; payments settle straight to your wallet.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -21,10 +21,6 @@
   "files": [
     "dist",
     "README.md",
-    "CHAINS.md",
-    "ERRORS.md",
-    "STANDARDS.md",
-    "DISCOVERY.md",
     "CHANGELOG.md",
     "LICENSE"
   ],

package/CHAINS.md

@@ -1,179 +0,0 @@
-# Chain support & per-chain setup
-
-PipRail works the same way on every chain — `requirePayment({ chain, token, amount, payTo })`
-to charge, `new PipRailClient({ chain, wallet }).fetch(url)` to pay. But the chains
-themselves differ, and a few have **setup steps you must do before a wallet can pay or
-receive**. This page is the exact list.
-
-**Most chains need nothing special.** The ones with caveats are **NEAR**, **TON**,
-**Stellar**, **XRPL**, **Tron**, and **Algorand** (USDC needs a one-time ASA opt-in) —
-read those sections before you ship them.
-
-## At a glance
-
-| Chain(s) | Pay in native coin? | Built-in stablecoins | Receiver needs setup? | Wallet input |
-|---|:--:|---|---|---|
-| **EVM** (Ethereum, Base, Arbitrum, Optimism, Polygon, BNB, Avalanche, Mantle, Sonic, Linea, Scroll, Celo, zkSync, Unichain, World Chain, Sei, Injective, HyperEVM, Monad, Kaia, + any EVM chain) | ✅ ETH/BNB/POL/… | USDC (all **except Kaia**) · USDT (all **except Base, World Chain, Sei, HyperEVM, Monad**) · **EURC** (Ethereum, Base, Avalanche) | No | `{ privateKey }` |
-| **Solana** | ✅ SOL | USDC · USDT | No (payer creates the recipient's token account) | `{ secretKey }` |
-| **Sui** | ✅ SUI | USDC (no USDT) | No | `{ privateKey }` (`suiprivkey1…`) |
-| **Aptos** | ✅ APT | USDC · USDT | No (primary FA store auto-creates) | `{ privateKey }` (`ed25519-priv-0x…`) |
-| **Algorand** | ✅ ALGO | **USDC only** (Tether deprecated USDT) | USDC: ⚠️ **ASA opt-in** · **native ALGO: none** | `{ mnemonic }` (25 words) |
-| **Stellar** | ✅ XLM | USDC · EURC | ⚠️ **Yes — trustline + funded account** | `{ secret }` (`S…`) |
-| **XRP Ledger** | ✅ XRP | USDC · RLUSD (no USDT) | ⚠️ **Yes — trustline + activated account** | `{ seed }` (`s…`) |
-| **TON** | ✅ TON | **USD₮ only** (no USDC) | No (payer's gas auto-deploys the jetton wallet) | `{ mnemonic }` (24 words) |
-| **Tron** | ✅ TRX | **USD₮ only** (no USDC) | No | `{ privateKey }` |
-| **NEAR** | ✅ NEAR | USDC · USDT | tokens: ⚠️ `storage_deposit` · **native NEAR: none** | `{ accountId, privateKey }` |
-
-> **`token: 'native'`** (paying in the chain's own coin) is accepted on **every family** —
-> EVM, Solana, Sui, Aptos, Algorand, Stellar, XRPL, TON, NEAR, **and Tron** (native TRX,
-> digest-bound). No exceptions. On NEAR, native is the **zero-setup** path: no `storage_deposit`,
-> and a transfer even creates a fresh recipient (the NEP-141 token path still needs
-> `storage_deposit`).
->
-> **Custom tokens** work everywhere with no allowlist: EVM `{ address, decimals }` ·
-> Solana `{ mint, decimals }` · Sui `{ coinType, decimals }` · Aptos `{ metadata, decimals }` ·
-> Algorand `{ assetId, decimals }` · TON `{ master, decimals }` ·
-> Tron `{ address, decimals }` · NEAR `{ contractId, decimals }` · Stellar
-> `{ issuer, code, decimals }` · XRPL `{ issuer, currencyHex, decimals }`.
-
-**Universal:** the public default RPC on every chain is rate-limited — **pass your own
-`rpcUrl`** in production (there's no separate API-key field; fold any key into the URL).
-
----
-
-## Chains with no caveats
-
-### EVM — Ethereum, Base, Arbitrum, Optimism, Polygon, BNB, Avalanche, …
-- **Pay in:** native coin (`'native'`), `'USDC'`, `'USDT'`, `'EURC'` (where issued), or a custom `{ address, decimals }`.
-- **USDT gap:** built in on every preset **except Base, World Chain, Sei, HyperEVM, and Monad** (USDC only there). **Kaia** is the inverse — **USD₮ only** (no Circle-native USDC on Kaia).
-- **EURC:** Circle's euro stablecoin is built in on **Ethereum, Base, and Avalanche** (EIP-3009, 6-dp, addresses verified on-chain). Its EIP-712 domain name differs per deployment (`"Euro Coin"` on Ethereum/Avalanche, `"EURC"` on Base) — the SDK reads it on-chain, so `exact` payments are correct everywhere. Like USDC, it's `exact`-payable.
-- **Decimals:** on **BNB Chain**, Binance-Peg USDC/USDT are **18 decimals**, not 6 (the SDK handles it; don't hardcode 6).
-- **Stablecoin provenance — issuer-native vs bridged (every shipped address verified on-chain 2026-06-08, incl. bridge markers).** Every address is the correct, canonical, 1:1-redeemable dollar token on its chain; what varies is *who issues it*. You request it as `'USDC'` / `'USDT'` either way — provenance matters only if you specifically require issuer-native settlement.
-  - **USDC** is **Circle-native** on every preset **except** **BNB** (Binance-Peg, 18-dp), **Mantle** (OP canonical-bridge), and **Scroll** (Bridged-USDC-Standard) — the last two are backed 1:1 by Circle USDC on Ethereum but are **not** Circle-issued on that chain (absent from Circle's native-USDC list).
-  - **USDT** is **Tether-native** on **Ethereum, Avalanche, Celo, Kaia** (EVM) and **Solana, Tron, TON, NEAR, Aptos** (non-EVM). Everywhere else it's bridged: **USDT0** (LayerZero omnichain, on-chain `symbol()` = `USD₮0`) on **Arbitrum, Polygon, Unichain**; a **canonical-bridge** token (chain-minted, backed by Tether's Ethereum USDT — not Tether-issued) on **Optimism, zkSync, Sonic, Linea, Injective, Mantle, Scroll**; and **Binance-Peg** (18-dp) on **BNB**. The on-chain `symbol()` may read `USDT`, `USD₮`, `USDt`, or `USD₮0`; all resolve via `token: 'USDT'`.
-- **Receiver setup:** none — any `0x…` address receives ERC-20 or native immediately.
-- **Any other EVM chain:** pass a viem `Chain` or `{ id, rpcUrl }` + `token: { address, decimals }`.
-
-### Solana
-- **Pay in:** `'native'` (SOL), `'USDC'`, `'USDT'`, or `{ mint, decimals }`.
-- **Receiver setup:** none — the payer's transaction idempotently creates the recipient's token account and pays its ~0.00204 SOL rent. **Pass the recipient's wallet address as `payTo`, not a token-account address.**
-- **Payer:** needs SOL for gas + a funded source token account for the SPL token.
-
-### Sui
-- **Pay in:** `'native'` (SUI), `'USDC'`, or `{ coinType, decimals }`. **No built-in USDT** (only Wormhole-bridged exists — supply it as a custom coin if needed).
-- **Receiver setup:** none — any `0x…` (32-byte) Sui address receives immediately.
-- **Payer:** needs SUI for gas even when paying USDC, and must already hold a coin object of the asset.
-
----
-
-## ⚠️ Chains with caveats — read before shipping
-
-### NEAR — native is zero-setup; tokens need `storage_deposit`
-- **Native NEAR works and is the easy path.** `token: 'native'` pays in NEAR (24dp) via
-  digest-binding (like EVM/Solana/Sui) — **no `storage_deposit`, no receiver setup**, and a
-  transfer even **creates a fresh implicit recipient**. Use it when price volatility is fine
-  and you want zero setup. *(NEAR is the volatile gas coin; for stable pricing pay in a token.)*
-- **Tokens (USDC/USDT/custom NEP-141) need `storage_deposit` (NEP-145).** Before an account
-  can *receive* a token, it must be storage-registered on **that exact token contract** — a
-  one-time ~0.00125 NEAR call, **per account per token** (else the payer's `ft_transfer`
-  panics). Both the **merchant (`payTo`)** and the **payer** must be registered on the token.
-  Pay in a token via `'USDC'`, `'USDT'`, or a custom `{ contractId, decimals }`.
-- **Wallet:** `{ accountId, privateKey }` — NEAR needs *both* an account id and an `ed25519:…` secret key (not just a private key).
-- **Implicit accounts** (64-hex) don't exist until funded with NEAR — fund the account first (a native payment to one *creates* it).
-- **Built-in USDC is Circle's native contract** (`17208628…36133a1`), **not** the bridged `…factory.bridge.near` (USDC.e). Don't confuse them.
-- **Do not route through NEAR Intents/solvers** — that re-introduces a third-party facilitator. PipRail uses plain transfers + local receipt verification on purpose.
-
-### TON — USD₮ (or native TON), and you need an API-keyed RPC
-- **Built-in token is USD₮ only** — **native USDC does not exist on TON** (Circle doesn't issue it; `token: 'USDC'` throws). Pay in `'USDT'`, `'native'` (Toncoin), or a custom jetton `{ master, decimals }`.
-- **An RPC API key is effectively required.** The default keyless toncenter endpoint is rate-limited (~1 req/s) and will stall `confirm()`/`verify()` (they poll + read archival history). Use a keyed, archival-capable endpoint and **put the key in the URL**:
-  ```ts
-  requirePayment({ chain: 'ton', token: 'USDT', amount: '0.05', payTo,
-    rpcUrl: 'https://toncenter.com/api/v2/jsonRPC?api_key=YOUR_KEY' })
-  ```
-  (Free keys: message **@tonapibot** on Telegram, or sign up at toncenter.com.)
-- **Receiver setup:** none — the payer's attached gas (~0.05 TON, leftover refunded) auto-deploys the merchant's jetton wallet on first receipt. The payer needs Toncoin for gas even when paying USD₮.
-- **Async settlement:** value crosses contracts, so a credit can take seconds to appear; the proof is a locator (`ton:<jetton-wallet>|<nonce>`), not a tx hash, and the nonce rides in the transfer comment to bind it.
-- **Wallet:** a 24-word `{ mnemonic }` (or `{ keyPair }`), wallet version `v4` (default) or `v5r1` — must match the version your funded address was created with.
-
-### Tron — USD₮ (or native TRX), and gas is real money
-- **Pay in:** `'USDT'` (built in), **`'native'` (TRX, digest-bound)**, or a custom TRC-20 `{ address, decimals }`. **No built-in USDC** (Circle discontinued native USDC on Tron). USD₮ is the default (TRX is volatile gas); native TRX is there for completeness — a plain TransferContract, verified by txid + recency + single-use.
-- **Gas is expensive and paid in TRX.** A USD₮ transfer burns Energy (~30k unstaked ≈ several TRX). The payer must hold **TRX as well as USDT**. Use `client.estimateCost(url)` to budget payment + TRX gas. (Tip for tiny test sends: rent energy from a service like TronZap/feee.io for ~1–2 TRX instead of burning ~27.) A first **native** TRX payment to a brand-new recipient also pays Tron's ~1 TRX account-creation fee (sender side).
-- **Finality is slow-ish:** verification waits for the tx to solidify (~19 blocks, ~57s); until then it reads as `tx_not_found` and is retried.
-- **Wallet:** `{ privateKey }` (32-byte hex, same format as EVM); addresses are Base58 `T…`.
-
-### Algorand — USDC needs a one-time ASA opt-in (native ALGO doesn't)
-- **Pay in:** `'native'` (ALGO, the zero-setup path), `'USDC'`, or a custom ASA `{ assetId, decimals }`. **USDC only for the stablecoin** — Tether deprecated/froze USDT on Algorand (2025-09-01), so it's not built in (pass it as a custom ASA if you must).
-- **Receiving USDC needs an ASA opt-in.** Before an account can *receive* USDC (ASA `31566704`) — or any ASA — it must **opt into that asset** once: a 0-amount asset-transfer to itself, which raises its minimum balance by 0.1 ALGO (locked, recoverable). No opt-in → the payment fails and PipRail returns `RECIPIENT_NOT_READY`. **Native ALGO needs no opt-in.** The payer is implicitly opted-in if it already holds USDC. The one-time opt-in is plain `algosdk` (PipRail stays a payments SDK, not a wallet manager):
-  ```ts
-  import algosdk from 'algosdk'
-  const algod = new algosdk.Algodv2('', 'https://mainnet-api.algonode.cloud', '')
-  const sp = await algod.getTransactionParams().do()
-  const optIn = algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject({
-    sender: account.addr, receiver: account.addr, amount: 0, assetIndex: 31566704, suggestedParams: sp,
-  })
-  await algod.sendRawTransaction(optIn.signTxn(account.sk)).do() // one-time, per account per ASA
-  ```
-- **Fast + cheap:** ~3s single-step finality, flat 0.001 ALGO min fee. The challenge nonce rides in the transaction's **note field** (Template A), so the proof is bound to its challenge; verify reads the merchant account's inbound transfers via the indexer.
-- **x402:** Algorand's `exact` scheme is part of the official x402 standard, but the incumbent on-chain path uses a hosted **facilitator** — PipRail is the **backendless, no-facilitator** option (payer broadcasts, merchant verifies locally).
-- **Wallet:** `{ mnemonic }` (a 25-word Algorand recovery phrase) or `{ account }` (an algosdk `{ addr, sk }`).
-- **Endpoints:** `rpcUrl` overrides the **algod** endpoint (submit/params); the verify-side **indexer** uses the public AlgoNode default (override needs are rare; the public indexer is production-grade for the inbound-transfer read).
-
-### Stellar — the receiver needs a trustline + a funded account
-- **Pay in:** `'native'` (XLM), `'USDC'`, `'EURC'`, or a custom `{ issuer, code, decimals }`.
-- **Receiving an issued asset needs a one-time TRUSTLINE.** The merchant (`payTo`) must (1) **exist** on-chain (funded above the ~1 XLM base reserve) and (2) hold a **trustline** (`changeTrust`) for that exact `code+issuer` *before* it can receive. No trustline → the payment fails. Each trustline locks **+0.5 XLM** of reserve. The **payer** likewise needs its own trustline to hold/send the asset.
-- **Accounts must exist:** this driver sends a payment, it does **not** create accounts — both ends must already be funded above reserve.
-- **Reserves are locked, not spent** — recoverable.
-- **Wallet:** `{ secret }` (an `S…` Ed25519 seed) or `{ keypair }`.
-
-### XRP Ledger — the receiver needs activation + a trustline
-- **Pay in:** `'native'` (XRP), `'USDC'`, `'RLUSD'`, or a custom `{ issuer, currencyHex, decimals }`. **No built-in USDT** on XRPL.
-- **Receiving an IOU needs activation + a TRUSTLINE.** The merchant (`payTo`) must be an **activated** account (holding the ~1 XRP base reserve) **and** hold a **trustline** to the issuer's currency before its first IOU payment — otherwise it fails. Native XRP needs no trustline. The payer must be activated + trustlined too.
-- **Reserves locked, not spent** (~1 XRP base + an owner reserve per trustline) — recoverable.
-- **RLUSD** requires a DestinationTag; the SDK sets a nonce-derived one automatically.
-- **Wallet:** `{ seed }` (an `s…` family seed) or `{ wallet }`.
-
----
-
-## Errors you'll see — and what they actually mean
-
-A payment that "won't go through" is almost always a **chain requirement**, not an SDK bug.
-PipRail maps every such case to a typed error (stable `.code`) with a plain-language fix, and
-**echoes the raw chain code** in the message + keeps the original on `err.cause`. The two you'll
-meet in practice:
-
-**`INSUFFICIENT_FUNDS`** — the **payer** can't cover it → fund the payer (token, native gas, or
-the chain's reserve).
-
-**`RECIPIENT_NOT_READY`** — the **recipient** (`payTo`) isn't set up to receive on this chain yet.
-Fix the *recipient*, not the payer:
-
-| You see (raw → mapped) | Chain | What it means | Fix |
-|---|---|---|---|
-| `tecNO_DST_INSUF_XRP` / `tecNO_DST` | XRPL | the `payTo` account isn't activated (an XRPL account needs ≥1 XRP base reserve to exist) | send the recipient ≥1 XRP to activate it |
-| `tecNO_LINE` / `tecPATH_DRY` | XRPL | recipient has no trustline for the IOU (USDC/RLUSD) | add the trustline on the recipient |
-| `tecDST_TAG_NEEDED` | XRPL | recipient requires a DestinationTag (PipRail sets one automatically) | — |
-| `op_no_destination` | Stellar | the `payTo` account doesn't exist | create it with ≥1 XLM (base reserve) |
-| `op_no_trust` | Stellar | recipient has no trustline for the asset | add the trustline (+0.5 XLM reserve) |
-| `… is not registered` | NEAR | recipient isn't `storage_deposit`-registered on the token | call `storage_deposit` once (~0.00125 NEAR) |
-| `must optin` / `asset … missing from <payTo>` | Algorand | recipient hasn't opted into the USDC ASA | opt the recipient into the ASA once (0-amount self-transfer, +0.1 ALGO min balance) |
-
-Everything else (EVM, Solana, Sui, Tron, native TON/NEAR) needs no recipient setup, so you'll
-only ever see `INSUFFICIENT_FUNDS` there if the payer is short. Full taxonomy: **[ERRORS.md](./ERRORS.md)**.
-
----
-
-## How the proof is bound (for the security-curious)
-
-Every chain proves the *same* facts locally (succeeded · recent · moved ≥ amount of the
-right asset to `payTo`), but binds the proof to your challenge differently:
-
-- **Memo-bound** (the challenge nonce is written on-chain): **NEAR tokens** (ft_transfer
-  memo), **TON** (transfer comment), **Stellar** (`MEMO_HASH = sha256(nonce)`), **XRPL**
-  (Memo + a derived DestinationTag), **Algorand** (the transaction's note field — native ALGO
-  and USDC alike).
-- **Digest-bound** (no on-chain nonce; the proof is the tx id, made single-use by the gate
-  + a recency window): **EVM**, **Solana**, **Sui**, **Aptos**, **Tron**, and **native NEAR**. For
-  these, a persistent `isUsed`/`markUsed` store + a tight `maxTimeoutSeconds` are
-  load-bearing in multi-instance deployments (the default used-set is single-process).
-
-(So NEAR uses *both*: its NEP-141 token path is memo-bound, while native NEAR is digest-bound.)