@stablechain/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,893 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; }// src/stable.ts
+
+
+
+
+
+
+
+var _viem = require('viem');
+var _chains = require('viem/chains');
+
+// src/errors.ts
+
+var StableError = class extends _viem.BaseError {
+};
+var StableValidationError = class extends StableError {
+  constructor(field, value, reason, opts) {
+    super(reason, {
+      name: "StableValidationError",
+      cause: _optionalChain([opts, 'optionalAccess', _ => _.cause]),
+      metaMessages: [`Field: ${field}`, `Value: ${formatValue(value)}`]
+    });
+    this.field = field;
+    this.value = value;
+  }
+};
+var StableQuoteError = class extends StableError {
+  constructor(args) {
+    const meta = [`Provider: ${args.provider}`];
+    if (args.httpStatus !== void 0) meta.push(`HTTP status: ${args.httpStatus}`);
+    if (args.providerCode) meta.push(`Provider code: ${args.providerCode}`);
+    super(args.shortMessage, {
+      name: "StableQuoteError",
+      cause: args.cause,
+      metaMessages: meta
+    });
+    this.provider = args.provider;
+    this.httpStatus = args.httpStatus;
+    this.providerCode = args.providerCode;
+    this.body = args.body;
+  }
+};
+var StableTransactionError = class extends StableError {
+  constructor(args) {
+    const meta = [`Phase: ${args.phase}`];
+    if (args.chainId !== void 0) meta.push(`Chain ID: ${args.chainId}`);
+    if (args.txHash) meta.push(`Tx hash: ${args.txHash}`);
+    if (args.revertReason) meta.push(`Revert reason: ${args.revertReason}`);
+    super(args.shortMessage, {
+      name: "StableTransactionError",
+      cause: args.cause,
+      metaMessages: meta
+    });
+    this.phase = args.phase;
+    this.txHash = args.txHash;
+    this.chainId = args.chainId;
+    this.revertReason = args.revertReason;
+  }
+};
+var StableNetworkError = class extends StableError {
+  constructor(args) {
+    super(args.shortMessage, {
+      name: "StableNetworkError",
+      cause: args.cause,
+      metaMessages: args.url ? [`URL: ${args.url}`] : void 0
+    });
+    this.url = args.url;
+  }
+};
+function formatValue(v) {
+  if (typeof v === "bigint") return `${v}n`;
+  if (typeof v === "string") return JSON.stringify(v);
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  try {
+    return JSON.stringify(v);
+  } catch (e) {
+    return String(v);
+  }
+}
+
+// src/services/layerzero.ts
+
+
+
+
+
+
+
+
+
+
+
+
+// src/helpers/chain.ts
+
+function makeChain(id, rpc) {
+  return _viem.defineChain.call(void 0, {
+    id,
+    name: "chain",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+}
+
+// src/types.ts
+var Chain = /* @__PURE__ */ ((Chain2) => {
+  Chain2["Sepolia"] = "sepolia";
+  Chain2["StableTestnet"] = "stable-testnet";
+  Chain2["Stable"] = "stable";
+  Chain2["Ethereum"] = "ethereum";
+  Chain2["Arbitrum"] = "arbitrum";
+  Chain2["Ink"] = "ink";
+  Chain2["Bera"] = "bera";
+  Chain2["MegaETH"] = "megaeth";
+  Chain2["Base"] = "base";
+  Chain2["BSC"] = "bsc";
+  Chain2["HyperEVM"] = "hyperevm";
+  return Chain2;
+})(Chain || {});
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["Mainnet"] = "mainnet";
+  Network2["Testnet"] = "testnet";
+  return Network2;
+})(Network || {});
+
+// src/chains.ts
+var CHAIN_CONFIGS = {
+  // ─── Testnet ──────────────────────────────────────────────────────────────
+  ["sepolia" /* Sepolia */]: {
+    id: 11155111,
+    rpc: "https://ethereum-sepolia-rpc.publicnode.com",
+    usdt: "0xc4DCC311c028e341fd8602D8eB89c5de94625927",
+    decimals: 18
+  },
+  ["stable-testnet" /* StableTestnet */]: {
+    id: 2201,
+    rpc: "https://rpc.testnet.stable.xyz",
+    usdt: "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9",
+    decimals: 6
+  },
+  // ─── Mainnet ──────────────────────────────────────────────────────────────
+  ["stable" /* Stable */]: {
+    id: 988,
+    rpc: "https://rpc.stable.xyz",
+    usdt: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    decimals: 6
+  },
+  ["ethereum" /* Ethereum */]: {
+    id: 1,
+    rpc: "https://ethereum-rpc.publicnode.com",
+    usdt: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+    decimals: 6
+  },
+  ["arbitrum" /* Arbitrum */]: {
+    id: 42161,
+    rpc: "https://arbitrum-one-rpc.publicnode.com",
+    usdt: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92",
+    decimals: 6
+  },
+  ["ink" /* Ink */]: {
+    id: 57073,
+    rpc: "https://rpc-gel.inkonchain.com",
+    usdt: "0x0200C29006150606B650577BBE7B6248F58470c1",
+    decimals: 6
+  },
+  ["bera" /* Bera */]: {
+    id: 80094,
+    rpc: "https://rpc.berachain.com",
+    usdt: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    decimals: 6
+  },
+  ["megaeth" /* MegaETH */]: {
+    id: 4326,
+    rpc: "https://carrot.megaeth.com",
+    usdt: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+    decimals: 6
+  },
+  ["base" /* Base */]: {
+    id: 8453,
+    rpc: "https://mainnet.base.org",
+    usdt: "0x102d758f688a4C1C5a80b116bD945d4455460282",
+    decimals: 6
+  },
+  ["bsc" /* BSC */]: {
+    id: 56,
+    rpc: "https://bsc-rpc.publicnode.com",
+    usdt: "0x55d398326f99059fF775485246999027B3197955",
+    decimals: 18
+  },
+  ["hyperevm" /* HyperEVM */]: {
+    id: 999,
+    rpc: "https://rpc.hyperliquid.xyz/evm",
+    usdt: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+    decimals: 6
+  }
+};
+
+// src/services/layerzero.ts
+var C = CHAIN_CONFIGS;
+var BRIDGE_CHAIN_CONFIGS = {
+  // ─── Testnet ───────────────────────────────────────────────────────────────
+  ["sepolia" /* Sepolia */]: { ...C["sepolia" /* Sepolia */], lzEid: 40161, oftAdapter: "0xc099cD946d5efCC35A99D64E808c1430cEf08126" },
+  ["stable-testnet" /* StableTestnet */]: { ...C["stable-testnet" /* StableTestnet */], lzEid: 40374, oftAdapter: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736" },
+  // ─── Mainnet ──────────────────────────────────────────────────────────────
+  ["stable" /* Stable */]: { ...C["stable" /* Stable */], lzEid: 30396, oftAdapter: "0xedaba024be4d87974d5aB11C6Dd586963CcCB027" },
+  ["ethereum" /* Ethereum */]: { ...C["ethereum" /* Ethereum */], lzEid: 30101, oftAdapter: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee" },
+  ["arbitrum" /* Arbitrum */]: { ...C["arbitrum" /* Arbitrum */], lzEid: 30110, oftAdapter: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92" },
+  ["ink" /* Ink */]: { ...C["ink" /* Ink */], lzEid: 30339, oftAdapter: "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65" },
+  ["bera" /* Bera */]: { ...C["bera" /* Bera */], lzEid: 30362, oftAdapter: "0x3Dc96399109df5ceb2C226664A086140bD0379cB" },
+  ["megaeth" /* MegaETH */]: { ...C["megaeth" /* MegaETH */], lzEid: 30398, oftAdapter: "0x9151434b16b9763660705744891fa906f660ecc5" },
+  ["hyperevm" /* HyperEVM */]: { ...C["hyperevm" /* HyperEVM */], lzEid: 30367, oftAdapter: "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98" }
+};
+var OFT_ADAPTER_ABI = [
+  {
+    name: "quoteSend",
+    type: "function",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      { name: "_payInLzToken", type: "bool" }
+    ],
+    outputs: [
+      {
+        name: "msgFee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    name: "send",
+    type: "function",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      {
+        name: "_fee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      },
+      { name: "_refundAddress", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  }
+];
+function buildLzOptions(gasLimit = 0n) {
+  return _viem.concat.call(void 0, [
+    _viem.numberToHex.call(void 0, 3, { size: 2 }),
+    // TYPE_3 header
+    _viem.numberToHex.call(void 0, 1, { size: 1 }),
+    // Executor worker ID
+    _viem.numberToHex.call(void 0, 17, { size: 2 }),
+    // option payload length = 17 bytes
+    _viem.numberToHex.call(void 0, 1, { size: 1 }),
+    // LzReceive option type
+    _viem.numberToHex.call(void 0, gasLimit, { size: 16 })
+    // gas limit as uint128
+  ]);
+}
+var LayerZeroService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async quoteBridge({ fromChain, toChain, amount, recipient }) {
+    const recipientAddr = _nullishCoalesce(recipient, () => ( "0x0000000000000000000000000000000000000000"));
+    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "quoteBridge");
+    const { src, dst } = this.resolveChains(fromChain, toChain);
+    const oftAdapter = src.oftAdapter;
+    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
+    try {
+      const { nativeFee, lzTokenFee } = await _viem.createPublicClient.call(void 0, {
+        chain: makeChain(src.id, src.rpc),
+        transport: _viem.http.call(void 0, src.rpc)
+      }).readContract({
+        address: oftAdapter,
+        abi: OFT_ADAPTER_ABI,
+        functionName: "quoteSend",
+        args: [this.buildSendParams(dst, amountLD, recipientAddr), false]
+      });
+      return { nativeFee, lzTokenFee, toAmount: amount };
+    } catch (err) {
+      throw new StableQuoteError({
+        provider: "layerzero",
+        shortMessage: "quoteBridge: quoteSend call failed",
+        cause: err
+      });
+    }
+  }
+  async bridge({ fromChain, toChain, fromToken, toToken, amount, recipient, quote }) {
+    const from = _nullishCoalesce(_optionalChain([this, 'access', _2 => _2.config, 'access', _3 => _3.walletClient, 'optionalAccess', _4 => _4.account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([this, 'access', _6 => _6.config, 'access', _7 => _7.account, 'optionalAccess', _8 => _8.address])));
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "bridge: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
+    }
+    const recipientAddr = _nullishCoalesce(recipient, () => ( from));
+    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "bridge");
+    const { src, dst } = this.resolveChains(fromChain, toChain);
+    const oftAdapter = src.oftAdapter;
+    const srcChain = makeChain(src.id, src.rpc);
+    const wc = _nullishCoalesce(this.config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
+      account: this.config.account,
+      chain: srcChain,
+      transport: _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, src.rpc)))
+    })));
+    const pc = _viem.createPublicClient.call(void 0, { chain: srcChain, transport: _viem.http.call(void 0, src.rpc) });
+    try {
+      await wc.switchChain({ id: src.id });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "switch_chain",
+        shortMessage: `bridge: wallet rejected or failed to switch to chain ${src.id}`,
+        chainId: src.id,
+        cause: err
+      });
+    }
+    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
+    const sendParams = this.buildSendParams(dst, amountLD, recipientAddr);
+    const lzFee = _optionalChain([quote, 'optionalAccess', _9 => _9.nativeFee]) !== void 0 && _optionalChain([quote, 'optionalAccess', _10 => _10.lzTokenFee]) !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee } : await this.quoteBridge({ fromChain, toChain, fromToken, toToken, amount, recipient: recipientAddr });
+    const { nativeFee = 0n, lzTokenFee = 0n } = lzFee;
+    const allowance = await pc.readContract({
+      address: src.usdt,
+      abi: _viem.erc20Abi,
+      functionName: "allowance",
+      args: [from, oftAdapter]
+    });
+    if (allowance < amountLD) {
+      let approveHash;
+      try {
+        approveHash = await wc.writeContract({
+          address: src.usdt,
+          abi: _viem.erc20Abi,
+          functionName: "approve",
+          args: [oftAdapter, amountLD],
+          account: wc.account,
+          chain: srcChain
+        });
+      } catch (err) {
+        throw new StableTransactionError({
+          phase: "approve",
+          shortMessage: "bridge: USDT0 approve failed",
+          chainId: src.id,
+          cause: err
+        });
+      }
+      const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
+      if (approveReceipt.status === "reverted") {
+        throw new StableTransactionError({
+          phase: "approve",
+          shortMessage: "bridge: USDT0 approve reverted on-chain",
+          txHash: approveReceipt.transactionHash,
+          chainId: src.id
+        });
+      }
+    }
+    try {
+      const hash = await wc.writeContract({
+        address: oftAdapter,
+        abi: OFT_ADAPTER_ABI,
+        functionName: "send",
+        args: [sendParams, { nativeFee, lzTokenFee }, from],
+        value: nativeFee,
+        account: wc.account,
+        chain: srcChain
+      });
+      return { txHash: hash, toAmount: amount };
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "send",
+        shortMessage: "bridge: OFT send failed",
+        chainId: src.id,
+        cause: err
+      });
+    }
+  }
+  validateBridgeParams(params, method) {
+    if (!_viem.isAddress.call(void 0, params.recipient)) {
+      throw new StableValidationError(
+        "recipient",
+        params.recipient,
+        `${method}: invalid recipient address "${params.recipient}"`
+      );
+    }
+    if (!Number.isFinite(params.amount) || params.amount <= 0) {
+      throw new StableValidationError(
+        "amount",
+        params.amount,
+        `${method}: amount must be a finite positive number`
+      );
+    }
+    if (params.fromChain === params.toChain) {
+      throw new StableValidationError(
+        "toChain",
+        params.toChain,
+        `${method}: fromChain and toChain must differ`
+      );
+    }
+  }
+  resolveChains(fromChain, toChain) {
+    const src = BRIDGE_CHAIN_CONFIGS[fromChain];
+    const dst = BRIDGE_CHAIN_CONFIGS[toChain];
+    if (!src) throw new StableValidationError("fromChain", fromChain, `Unsupported source chain: "${fromChain}"`);
+    if (!dst) throw new StableValidationError("toChain", toChain, `Unsupported destination chain: "${toChain}"`);
+    if (!src.oftAdapter) {
+      throw new StableValidationError("fromChain", fromChain, `No OFT adapter configured for "${fromChain}"`);
+    }
+    return { src, dst };
+  }
+  buildSendParams(dst, amountLD, recipient) {
+    return {
+      dstEid: dst.lzEid,
+      to: _viem.padHex.call(void 0, recipient, { dir: "left", size: 32 }),
+      amountLD,
+      minAmountLD: amountLD,
+      extraOptions: buildLzOptions(),
+      composeMsg: "0x",
+      oftCmd: "0x"
+    };
+  }
+};
+
+// src/services/lifi.ts
+
+
+
+
+
+
+
+
+
+
+// src/helpers/retry.ts
+var HttpError = class extends Error {
+  constructor(message, status, retryable) {
+    super(message);
+    this.status = status;
+    this.retryable = retryable;
+    this.name = "HttpError";
+  }
+};
+function isRetryableError(err) {
+  if (err instanceof HttpError) return err.retryable;
+  return err instanceof TypeError;
+}
+async function retryWithBackoff(fn, isRetryable = isRetryableError, opts = {}) {
+  const maxAttempts = _nullishCoalesce(opts.maxAttempts, () => ( 3));
+  const base = _nullishCoalesce(opts.baseDelayMs, () => ( 250));
+  const max = _nullishCoalesce(opts.maxDelayMs, () => ( 4e3));
+  let lastErr;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt === maxAttempts - 1 || !isRetryable(err)) throw err;
+      const delay = Math.min(max, base * 2 ** attempt);
+      const jittered = delay * (0.75 + Math.random() * 0.5);
+      await new Promise((r) => setTimeout(r, jittered));
+    }
+  }
+  throw lastErr;
+}
+
+// src/services/lifi.ts
+var LiFiService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async quoteSwap(params) {
+    this._validateSwapParams(params);
+    const { fromToken, toToken, amount, fromDecimals = 6, toAddress } = params;
+    const from = this._requireFrom();
+    const chain = this.config.chainId.toString();
+    const fromAmountRaw = _viem.parseUnits.call(void 0, String(amount), fromDecimals).toString();
+    const qs = new URLSearchParams({
+      fromChain: chain,
+      toChain: chain,
+      fromToken,
+      toToken,
+      fromAmount: fromAmountRaw,
+      fromAddress: from,
+      ...toAddress && { toAddress }
+    });
+    const quote = await this._fetchQuote(qs);
+    return this._toSwapQuote(quote);
+  }
+  async swap(params) {
+    this._validateSwapParams(params);
+    const quote = await _asyncNullishCoalesce(params.quote, async () => ( await this.quoteSwap(params)));
+    return this._executeSwapQuote(quote, this.config.rpc, this.config.chainId);
+  }
+  async quoteBridge(params) {
+    this._validateBridgeParams(params);
+    const { fromChain, toChain, fromToken, toToken, amount, fromDecimals = 6, recipient } = params;
+    const from = _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _11 => _11.config, 'access', _12 => _12.walletClient, 'optionalAccess', _13 => _13.account, 'optionalAccess', _14 => _14.address]), () => ( _optionalChain([this, 'access', _15 => _15.config, 'access', _16 => _16.account, 'optionalAccess', _17 => _17.address]))), () => ( "0x0000000000000000000000000000000000000000"));
+    const src = CHAIN_CONFIGS[fromChain];
+    const dst = CHAIN_CONFIGS[toChain];
+    if (!src) throw new StableValidationError("fromChain", fromChain, `LI.FI bridge: unsupported source chain "${fromChain}"`);
+    if (!dst) throw new StableValidationError("toChain", toChain, `LI.FI bridge: unsupported destination chain "${toChain}"`);
+    const qs = new URLSearchParams({
+      fromChain: src.id.toString(),
+      toChain: dst.id.toString(),
+      fromToken,
+      toToken,
+      fromAmount: _viem.parseUnits.call(void 0, String(amount), fromDecimals).toString(),
+      fromAddress: from,
+      ...recipient && { toAddress: recipient }
+    });
+    const quote = this._toSwapQuote(await this._fetchQuote(qs));
+    return { toAmount: quote.toAmount };
+  }
+  async bridge(params) {
+    this._validateBridgeParams(params);
+    const { fromChain, toChain, fromToken, toToken, amount, fromDecimals = 6, recipient } = params;
+    const from = this._requireFrom();
+    const src = CHAIN_CONFIGS[fromChain];
+    const dst = CHAIN_CONFIGS[toChain];
+    if (!src) {
+      throw new StableValidationError("fromChain", fromChain, `LI.FI bridge: unsupported source chain "${fromChain}"`);
+    }
+    if (!dst) {
+      throw new StableValidationError("toChain", toChain, `LI.FI bridge: unsupported destination chain "${toChain}"`);
+    }
+    const fromAmountRaw = _viem.parseUnits.call(void 0, String(amount), fromDecimals).toString();
+    const qs = new URLSearchParams({
+      fromChain: src.id.toString(),
+      toChain: dst.id.toString(),
+      fromToken,
+      toToken,
+      fromAmount: fromAmountRaw,
+      fromAddress: from,
+      ...recipient && { toAddress: recipient }
+    });
+    const quote = this._toSwapQuote(await this._fetchQuote(qs));
+    return this._executeSwapQuote(quote, src.rpc, src.id);
+  }
+  _validateSwapParams({ fromToken, toToken, amount, toAddress }) {
+    if (!_viem.isAddress.call(void 0, fromToken)) {
+      throw new StableValidationError("fromToken", fromToken, `swap: invalid fromToken address "${fromToken}"`);
+    }
+    if (!_viem.isAddress.call(void 0, toToken)) {
+      throw new StableValidationError("toToken", toToken, `swap: invalid toToken address "${toToken}"`);
+    }
+    if (fromToken.toLowerCase() === toToken.toLowerCase()) {
+      throw new StableValidationError("toToken", toToken, "swap: fromToken and toToken must differ");
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+      throw new StableValidationError("amount", amount, "swap: amount must be a finite positive number");
+    }
+    if (toAddress !== void 0 && !_viem.isAddress.call(void 0, toAddress)) {
+      throw new StableValidationError("toAddress", toAddress, `swap: invalid toAddress "${toAddress}"`);
+    }
+  }
+  _validateBridgeParams({ fromChain, toChain, fromToken, toToken, amount, recipient }) {
+    if (!_viem.isAddress.call(void 0, fromToken)) {
+      throw new StableValidationError("fromToken", fromToken, `LI.FI bridge: invalid fromToken address "${fromToken}"`);
+    }
+    if (!_viem.isAddress.call(void 0, toToken)) {
+      throw new StableValidationError("toToken", toToken, `LI.FI bridge: invalid toToken address "${toToken}"`);
+    }
+    if (!Number.isFinite(amount) || amount <= 0) {
+      throw new StableValidationError("amount", amount, "LI.FI bridge: amount must be a finite positive number");
+    }
+    if (recipient !== void 0 && !_viem.isAddress.call(void 0, recipient)) {
+      throw new StableValidationError("recipient", recipient, `LI.FI bridge: invalid recipient address "${recipient}"`);
+    }
+    if (fromChain === toChain) {
+      throw new StableValidationError("toChain", toChain, "LI.FI bridge: fromChain and toChain must differ");
+    }
+  }
+  _requireFrom() {
+    const from = _nullishCoalesce(_optionalChain([this, 'access', _18 => _18.config, 'access', _19 => _19.walletClient, 'optionalAccess', _20 => _20.account, 'optionalAccess', _21 => _21.address]), () => ( _optionalChain([this, 'access', _22 => _22.config, 'access', _23 => _23.account, 'optionalAccess', _24 => _24.address])));
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "LI.FI: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
+    }
+    return from;
+  }
+  async _fetchQuote(qs) {
+    const url = `https://li.quest/v1/quote?${qs}`;
+    try {
+      return await retryWithBackoff(() => this._fetchQuoteOnce(url));
+    } catch (err) {
+      if (err instanceof StableQuoteError) throw err;
+      if (err instanceof HttpError) {
+        throw new StableQuoteError({
+          provider: "lifi",
+          shortMessage: err.message,
+          httpStatus: err.status,
+          cause: err
+        });
+      }
+      throw new StableNetworkError({
+        shortMessage: "LI.FI: quote request failed before reaching the server",
+        url,
+        cause: err
+      });
+    }
+  }
+  async _fetchQuoteOnce(url) {
+    const res = await fetch(url);
+    const body = await res.json().catch(() => void 0);
+    if (!res.ok) {
+      const providerMessage = isObject(body) && typeof body.message === "string" ? body.message : void 0;
+      const providerCode = isObject(body) && typeof body.code === "string" ? body.code : void 0;
+      if (res.status === 429 || res.status >= 500) {
+        throw new HttpError(`LI.FI: ${_nullishCoalesce(providerMessage, () => ( res.statusText))}`, res.status, true);
+      }
+      throw new StableQuoteError({
+        provider: "lifi",
+        shortMessage: `LI.FI: ${_nullishCoalesce(providerMessage, () => ( res.statusText))}`,
+        httpStatus: res.status,
+        providerCode,
+        body
+      });
+    }
+    if (!isLiFiQuoteShape(body)) {
+      throw new StableQuoteError({
+        provider: "lifi",
+        shortMessage: "LI.FI: unexpected quote response shape",
+        httpStatus: res.status,
+        body
+      });
+    }
+    return body;
+  }
+  _toSwapQuote(quote) {
+    return {
+      toAmount: Number(_viem.formatUnits.call(void 0, BigInt(quote.estimate.toAmount), quote.action.toToken.decimals)),
+      fromAmount: BigInt(quote.estimate.fromAmount),
+      fromToken: quote.action.fromToken.address,
+      approvalAddress: quote.estimate.approvalAddress,
+      transactionRequest: quote.transactionRequest
+    };
+  }
+  async _executeSwapQuote(quote, srcRpc, expectedChainId) {
+    const from = this._requireFrom();
+    const { transactionRequest } = quote;
+    const srcChainId = transactionRequest.chainId;
+    if (srcChainId !== expectedChainId) {
+      throw new StableQuoteError({
+        provider: "lifi",
+        shortMessage: `LI.FI: returned tx for chain ${srcChainId} but expected ${expectedChainId}`,
+        providerCode: "chain_mismatch",
+        body: quote
+      });
+    }
+    const srcChain = makeChain(srcChainId, srcRpc);
+    const wc = _nullishCoalesce(this.config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
+      account: this.config.account,
+      chain: srcChain,
+      transport: _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, srcRpc)))
+    })));
+    try {
+      await wc.switchChain({ id: srcChainId });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "switch_chain",
+        shortMessage: `LI.FI: wallet rejected or failed to switch to chain ${srcChainId}`,
+        chainId: srcChainId,
+        cause: err
+      });
+    }
+    await this._ensureApproval(wc, srcChain, srcRpc, srcChainId, from, quote);
+    let hash;
+    try {
+      hash = await wc.sendTransaction({
+        to: transactionRequest.to,
+        data: transactionRequest.data,
+        value: transactionRequest.value && transactionRequest.value !== "0x" ? BigInt(transactionRequest.value) : 0n,
+        gas: transactionRequest.gasLimit ? BigInt(transactionRequest.gasLimit) : void 0,
+        account: wc.account,
+        chain: srcChain
+      });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "send",
+        shortMessage: "LI.FI: swap/bridge transaction failed",
+        chainId: srcChainId,
+        cause: err
+      });
+    }
+    return { txHash: hash, toAmount: quote.toAmount };
+  }
+  async _ensureApproval(wc, srcChain, srcRpc, srcChainId, from, quote) {
+    const tokenAddr = quote.fromToken;
+    const isNative = tokenAddr.toLowerCase() === "0x0000000000000000000000000000000000000000" || tokenAddr.toLowerCase() === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+    if (isNative || !quote.approvalAddress) return;
+    const pc = _viem.createPublicClient.call(void 0, { chain: srcChain, transport: _viem.http.call(void 0, srcRpc) });
+    const allowance = await pc.readContract({
+      address: tokenAddr,
+      abi: _viem.erc20Abi,
+      functionName: "allowance",
+      args: [from, quote.approvalAddress]
+    });
+    if (allowance >= quote.fromAmount) return;
+    let approveHash;
+    try {
+      approveHash = await wc.writeContract({
+        address: tokenAddr,
+        abi: _viem.erc20Abi,
+        functionName: "approve",
+        args: [quote.approvalAddress, quote.fromAmount],
+        account: wc.account,
+        chain: srcChain
+      });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "approve",
+        shortMessage: "LI.FI: token approve failed",
+        chainId: srcChainId,
+        cause: err
+      });
+    }
+    const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
+    if (approveReceipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "approve",
+        shortMessage: "LI.FI: token approve reverted on-chain",
+        txHash: approveReceipt.transactionHash,
+        chainId: srcChainId
+      });
+    }
+  }
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function isLiFiQuoteShape(v) {
+  if (!isObject(v)) return false;
+  const tx = v.transactionRequest;
+  const est = v.estimate;
+  const act = v.action;
+  return isObject(tx) && typeof tx.to === "string" && typeof tx.data === "string" && typeof tx.chainId === "number" && isObject(est) && typeof est.fromAmount === "string" && typeof est.toAmount === "string" && isObject(act) && isObject(act.fromToken) && isObject(act.toToken);
+}
+
+// src/stable.ts
+function isUsdt0Route(fromChain, toChain, fromToken, toToken) {
+  const src = BRIDGE_CHAIN_CONFIGS[fromChain];
+  const dst = BRIDGE_CHAIN_CONFIGS[toChain];
+  return !!src && !!dst && src.lzOutbound !== false && src.usdt.toLowerCase() === fromToken.toLowerCase() && dst.usdt.toLowerCase() === toToken.toLowerCase();
+}
+function validateTransferParams({ to, amount, token, tokenDecimals }) {
+  if (!_viem.isAddress.call(void 0, to)) {
+    throw new StableValidationError("to", to, `transfer: invalid recipient address "${to}"`);
+  }
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new StableValidationError("amount", amount, "transfer: amount must be a finite positive number");
+  }
+  if (token !== void 0 && !_viem.isAddress.call(void 0, token)) {
+    throw new StableValidationError("token", token, `transfer: invalid token address "${token}"`);
+  }
+  if (tokenDecimals !== void 0 && (!Number.isInteger(tokenDecimals) || tokenDecimals < 0 || tokenDecimals > 77)) {
+    throw new StableValidationError("tokenDecimals", tokenDecimals, "transfer: tokenDecimals must be an integer between 0 and 77");
+  }
+}
+async function resolveTokenDecimals(publicClient, token, tokenDecimals) {
+  if (tokenDecimals !== void 0) return tokenDecimals;
+  try {
+    return await publicClient.readContract({ address: token, abi: _viem.erc20Abi, functionName: "decimals" });
+  } catch (e2) {
+    throw new StableValidationError(
+      "tokenDecimals",
+      void 0,
+      `transfer: could not fetch decimals for token "${token}" \u2014 pass tokenDecimals explicitly`
+    );
+  }
+}
+async function executeTokenTransfer(wc, publicClient, token, to, amount, tokenDecimals, acc, chain) {
+  const code = await publicClient.getCode({ address: token });
+  if (!code || code === "0x") {
+    throw new StableValidationError(
+      "token",
+      token,
+      `transfer: no contract found at "${token}" on chain ${chain.id} \u2014 check the address and network`
+    );
+  }
+  const decimals = await resolveTokenDecimals(publicClient, token, tokenDecimals);
+  return wc.writeContract({
+    address: token,
+    abi: _viem.erc20Abi,
+    functionName: "transfer",
+    args: [to, _viem.parseUnits.call(void 0, String(amount), decimals)],
+    account: acc,
+    chain
+  });
+}
+function createStable({
+  network = "mainnet" /* Mainnet */,
+  rpc: rpcOverride,
+  account,
+  transport,
+  walletClient
+}) {
+  const chain = network === "mainnet" /* Mainnet */ ? _chains.stable : _chains.stableTestnet;
+  const rpc = (_nullishCoalesce(rpcOverride, () => ( chain.rpcUrls.default.http[0]))).replace(/\/$/, "");
+  const signerConfig = { account, transport, walletClient };
+  const lz = new LayerZeroService(signerConfig);
+  const lifi = new LiFiService({ ...signerConfig, rpc, chainId: chain.id });
+  async function transfer(params) {
+    validateTransferParams(params);
+    const { from, to, amount, token, tokenDecimals } = params;
+    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _25 => _25.account]), () => ( account)), () => ( from));
+    const wc = _nullishCoalesce(walletClient, () => ( _viem.createWalletClient.call(void 0, {
+      account: acc,
+      chain,
+      transport: _nullishCoalesce(transport, () => ( _viem.http.call(void 0, rpc)))
+    })));
+    try {
+      await wc.switchChain({ id: chain.id });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "switch_chain",
+        shortMessage: `transfer: wallet rejected or failed to switch to chain ${chain.id}`,
+        chainId: chain.id,
+        cause: err
+      });
+    }
+    const publicClient = _viem.createPublicClient.call(void 0, { chain, transport: _viem.http.call(void 0, rpc) });
+    const hash = token !== void 0 ? await executeTokenTransfer(wc, publicClient, token, to, amount, tokenDecimals, acc, chain) : await wc.sendTransaction({ account: acc, chain, to, value: _viem.parseUnits.call(void 0, String(amount), 18) });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "transfer: transaction reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: chain.id
+      });
+    }
+    return { txHash: receipt.transactionHash };
+  }
+  function quoteBridge(params) {
+    return isUsdt0Route(params.fromChain, params.toChain, params.fromToken, params.toToken) ? lz.quoteBridge(params) : lifi.quoteBridge(params);
+  }
+  function bridge(params) {
+    return isUsdt0Route(params.fromChain, params.toChain, params.fromToken, params.toToken) ? lz.bridge(params) : lifi.bridge(params);
+  }
+  return {
+    transfer,
+    quoteBridge,
+    bridge,
+    quoteSwap: (params) => lifi.quoteSwap(params),
+    swap: (params) => lifi.swap(params)
+  };
+}
+
+
+
+
+
+
+
+
+
+
+exports.CHAIN_CONFIGS = CHAIN_CONFIGS; exports.Chain = Chain; exports.Network = Network; exports.StableError = StableError; exports.StableNetworkError = StableNetworkError; exports.StableQuoteError = StableQuoteError; exports.StableTransactionError = StableTransactionError; exports.StableValidationError = StableValidationError; exports.createStable = createStable;