@stablechain/sdk 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -9,7 +9,12 @@
 var _viem = require('viem');
 var _chains = require('viem/chains');
 
-// src/earn/reader.ts
+// src/earn/morpho.ts
+
+
+
+
+var _morphosdk = require('@morpho-org/morpho-sdk');
 
 
 
@@ -19,7 +24,6 @@ var _chains = require('viem/chains');
 
 
 
-var _morphosdk = require('@morpho-org/morpho-sdk');
 
 // src/errors.ts
 
@@ -39,7 +43,8 @@ var StableValidationError = class extends StableError {
 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.httpStatus !== void 0)
+      meta.push(`HTTP status: ${args.httpStatus}`);
     if (args.providerCode) meta.push(`Provider code: ${args.providerCode}`);
     super(args.shortMessage, {
       name: "StableQuoteError",
@@ -121,7 +126,11 @@ var HttpError = class extends Error {
 };
 function isRetryableError(err) {
   if (err instanceof HttpError) return err.retryable;
-  return err instanceof TypeError;
+  if (err instanceof TypeError) {
+    const msg = err.message.toLowerCase();
+    return !(msg.includes("cors") || msg.includes("blocked"));
+  }
+  return false;
 }
 async function retryWithBackoff(fn, isRetryable = isRetryableError, opts = {}) {
   const maxAttempts = _nullishCoalesce(opts.maxAttempts, () => ( 3));
@@ -142,550 +151,870 @@ async function retryWithBackoff(fn, isRetryable = isRetryableError, opts = {}) {
   throw lastErr;
 }
 
-// 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/earn/reader.ts
-var MORPHO_API_URL = "https://blue-api.morpho.org/graphql";
-var EarnReader = class {
+// src/earn/morpho.ts
+var MorphoService = class {
   constructor(config) {
-    if (!_optionalChain([config, 'access', _2 => _2.earn, 'optionalAccess', _3 => _3.vault])) {
-      throw new StableValidationError(
-        "earn.vault",
-        void 0,
-        "createStableReader: earn.vault is required"
-      );
-    }
-    if (!_viem.isAddress.call(void 0, config.address)) {
-      throw new StableValidationError(
-        "address",
-        config.address,
-        `createStableReader: invalid user address "${config.address}"`
-      );
-    }
-    if (!_viem.isAddress.call(void 0, config.earn.vault)) {
+    this.config = config;
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.chain = makeChain(config.chainId, config.rpc);
+    this.wc = _nullishCoalesce(config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
+      account: config.account,
+      chain: this.chain,
+      transport: _nullishCoalesce(config.transport, () => ( _viem.http.call(void 0, config.rpc)))
+    })));
+    const morphoWc = _optionalChain([this, 'access', _2 => _2.wc, 'access', _3 => _3.chain, 'optionalAccess', _4 => _4.id]) === config.chainId ? this.wc : _viem.createWalletClient.call(void 0, {
+      account: this.wc.account,
+      chain: this.chain,
+      transport: _viem.custom.call(void 0, {
+        request: this.wc.request.bind(this.wc)
+      })
+    });
+    this.morpho = new (0, _morphosdk.MorphoClient)(morphoWc, { supportSignature: true });
+    this.morphoNoSig = new (0, _morphosdk.MorphoClient)(morphoWc, { supportSignature: false });
+    this.pc = _viem.createPublicClient.call(void 0, {
+      chain: this.chain,
+      transport: _viem.http.call(void 0, config.rpc)
+    });
+  }
+  deposit(params) {
+    this._validateAmount(params.amount, "earn deposit");
+    if (params.depositBuffer !== void 0 && (params.depositBuffer <= 0 || params.depositBuffer > 1)) {
       throw new StableValidationError(
-        "earn.vault",
-        config.earn.vault,
-        `createStableReader: invalid vault address "${config.earn.vault}"`
+        "depositBuffer",
+        params.depositBuffer,
+        "earn deposit: depositBuffer must be > 0 and \u2264 1"
       );
     }
-    const network = _nullishCoalesce(config.network, () => ( "mainnet")) /* Mainnet */;
-    const viemChain = network === "mainnet" /* Mainnet */ ? _chains.stable : _chains.stableTestnet;
-    const rpc = (_nullishCoalesce(config.rpc, () => ( viemChain.rpcUrls.default.http[0]))).replace(/\/$/, "");
-    this.chainId = viemChain.id;
-    this.vaultAddr = config.earn.vault;
-    this.userAddr = config.address;
-    const chain = makeChain(viemChain.id, rpc);
-    this.pc = _viem.createPublicClient.call(void 0, { chain, transport: _viem.http.call(void 0, rpc) });
-    this.morpho = new (0, _morphosdk.MorphoClient)(this.pc);
+    return this._withIdempotency(
+      params.idempotencyKey,
+      () => this._deposit(params)
+    );
   }
-  async position() {
-    const vault = this.morpho.vaultV2(this.vaultAddr, this.chainId);
-    const [vaultData, shares] = await Promise.all([
-      vault.getData(),
-      this.pc.readContract({
-        address: this.vaultAddr,
-        abi: _viem.erc20Abi,
-        functionName: "balanceOf",
-        args: [this.userAddr]
-      })
-    ]);
-    const [tokenDecimals, shareDecimals] = await Promise.all([
-      this.pc.readContract({ address: vaultData.asset, abi: _viem.erc20Abi, functionName: "decimals" }),
-      this.pc.readContract({ address: this.vaultAddr, abi: _viem.erc20Abi, functionName: "decimals" })
-    ]);
-    const assetsRaw = vaultData.toAssets(shares);
-    return {
-      shares,
-      sharesFormatted: Number(_viem.formatUnits.call(void 0, shares, shareDecimals)),
-      shareDecimals,
-      assets: Number(_viem.formatUnits.call(void 0, assetsRaw, tokenDecimals)),
-      tokenDecimals,
-      assetAddress: vaultData.asset
+  async bulkDeposit(items, options = {}) {
+    const { idempotencyKey, stopOnError = false } = options;
+    const run = async () => {
+      const results = [];
+      for (const item of items) {
+        try {
+          const result = await this.deposit(item);
+          results.push({
+            status: "fulfilled",
+            txHash: result.txHash,
+            vault: item.vault,
+            idempotencyKey: item.idempotencyKey
+          });
+        } catch (err) {
+          const entry = {
+            status: "rejected",
+            error: String(err),
+            vault: item.vault,
+            idempotencyKey: item.idempotencyKey
+          };
+          results.push(entry);
+          if (stopOnError) {
+            const succeeded2 = results.filter(
+              (r) => r.status === "fulfilled"
+            ).length;
+            throw new StableBulkError({
+              shortMessage: "bulkDeposit halted on first failure",
+              results,
+              succeeded: succeeded2,
+              failed: results.length - succeeded2
+            });
+          }
+        }
+      }
+      const succeeded = results.filter(
+        (r) => r.status === "fulfilled"
+      ).length;
+      return {
+        results,
+        succeeded,
+        failed: results.length - succeeded,
+        idempotencyKey
+      };
     };
+    return this._withIdempotency(idempotencyKey, run);
   }
-  async getYield() {
-    return this._fetchYield();
-  }
-  async preview(params) {
-    const { amount, horizonDays } = params;
-    const apy = await this._fetchNetApy();
-    return {
-      projectedYield: amount * apy * (horizonDays / 365),
-      apy,
-      horizonDays
+  async bulkWithdraw(items, options = {}) {
+    const { idempotencyKey, stopOnError = false } = options;
+    const run = async () => {
+      const results = [];
+      for (const item of items) {
+        try {
+          const result = await this.withdraw(item);
+          results.push({
+            status: "fulfilled",
+            txHash: result.txHash,
+            idempotencyKey: item.idempotencyKey
+          });
+        } catch (err) {
+          const entry = {
+            status: "rejected",
+            error: String(err),
+            idempotencyKey: item.idempotencyKey
+          };
+          results.push(entry);
+          if (stopOnError) {
+            const succeeded2 = results.filter(
+              (r) => r.status === "fulfilled"
+            ).length;
+            throw new StableBulkError({
+              shortMessage: "bulkWithdraw halted on first failure",
+              results,
+              succeeded: succeeded2,
+              failed: results.length - succeeded2
+            });
+          }
+        }
+      }
+      const succeeded = results.filter(
+        (r) => r.status === "fulfilled"
+      ).length;
+      return {
+        results,
+        succeeded,
+        failed: results.length - succeeded,
+        idempotencyKey
+      };
     };
+    return this._withIdempotency(idempotencyKey, run);
   }
-  async withdrawability(params) {
-    const vault = this.morpho.vaultV2(this.vaultAddr, this.chainId);
-    const vaultData = await vault.getData();
-    const tokenDecimals = await _asyncNullishCoalesce(params.tokenDecimals, async () => ( await this.pc.readContract({
-      address: vaultData.asset,
-      abi: _viem.erc20Abi,
-      functionName: "decimals"
-    })));
-    const requestedRaw = _viem.parseUnits.call(void 0, String(params.amount), tokenDecimals);
-    const availableLiquidityRaw = vaultData.assetBalance;
-    return {
-      isInstant: requestedRaw <= availableLiquidityRaw,
-      availableLiquidity: Number(_viem.formatUnits.call(void 0, availableLiquidityRaw, tokenDecimals)),
-      tokenDecimals
-    };
+  withdraw(params) {
+    this._validateAmount(params.amount, "earn withdraw");
+    return this._withIdempotency(
+      params.idempotencyKey,
+      () => this._withdraw(params)
+    );
   }
-  async _fetchNetApy() {
-    const { apy } = await this._fetchYield();
-    return apy;
+  redeem(params) {
+    this._validateShares(params.shares, "earn redeem");
+    return this._withIdempotency(
+      params.idempotencyKey,
+      () => this._redeem(params)
+    );
   }
-  async _fetchYield() {
-    const query = `
-      query VaultYield($address: String!, $chainId: Int!) {
-        vaultV2ByAddress(address: $address, chainId: $chainId) {
-          netApy
-          netApyExcludingRewards
-          performanceFee
-          managementFee
-          rewards {
-            asset { symbol address }
-            supplyApr
-          }
-        }
-      }
-    `;
-    let body;
-    try {
-      body = await retryWithBackoff(
-        async () => {
-          const res = await fetch(MORPHO_API_URL, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              query,
-              variables: { address: this.vaultAddr, chainId: this.chainId }
-            })
-          });
-          if (!res.ok) {
-            const retryable = res.status === 429 || res.status >= 500;
-            throw new HttpError(
-              `earn: Morpho API returned ${res.status} \u2014 ${res.statusText}`,
-              res.status,
-              retryable
-            );
-          }
-          return res.json().catch(() => void 0);
-        },
-        (err) => err instanceof HttpError ? err.retryable : err instanceof TypeError
+  forceWithdraw(params) {
+    this._validateAmount(params.amount, "earn forceWithdraw");
+    return this._withIdempotency(
+      params.idempotencyKey,
+      () => this._forceWithdraw(params)
+    );
+  }
+  forceRedeem(params) {
+    this._validateShares(params.shares, "earn forceRedeem");
+    return this._withIdempotency(
+      params.idempotencyKey,
+      () => this._forceRedeem(params)
+    );
+  }
+  // ─── Calldata preparation (no signing) ───────────────────────────────────
+  async prepareDepositCalldata(params) {
+    this._validateAmount(params.amount, "prepareDepositCalldata");
+    if (params.depositBuffer !== void 0 && (params.depositBuffer <= 0 || params.depositBuffer > 1)) {
+      throw new StableValidationError(
+        "depositBuffer",
+        params.depositBuffer,
+        "prepareDepositCalldata: depositBuffer must be > 0 and \u2264 1"
       );
-    } catch (err) {
-      if (err instanceof TypeError || err instanceof HttpError) {
-        throw new StableNetworkError({
-          shortMessage: err instanceof HttpError ? `earn: Morpho API returned ${err.status} after retries` : `earn: failed to reach Morpho API after retries \u2014 ${String(err)}`,
-          url: MORPHO_API_URL,
-          cause: err
-        });
+    }
+    const { amount, tokenDecimals, slippageTolerance, depositBuffer } = params;
+    const from = this._requireFrom();
+    const vaultAddr = _nullishCoalesce(params.vault, () => ( this.config.vault));
+    const vault = this.morphoNoSig.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "prepareDepositCalldata")));
+    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
+    if (depositBuffer !== void 0) {
+      const bps = BigInt(Math.round(depositBuffer * 1e4));
+      const maxAllowed = vaultData.assetBalance * bps / 10000n;
+      if (assetsRaw > maxAllowed) {
+        const maxFormatted = Number(_viem.formatUnits.call(void 0, maxAllowed, decimals));
+        const idleFormatted = Number(_viem.formatUnits.call(void 0, vaultData.assetBalance, decimals));
+        throw new StableValidationError(
+          "amount",
+          amount,
+          `prepareDepositCalldata: amount ${amount} exceeds deposit buffer \u2014 max ${maxFormatted} (${depositBuffer * 100}% of ${idleFormatted} idle liquidity)`
+        );
       }
-      throw err;
     }
-    const vault = _optionalChain([body, 'optionalAccess', _4 => _4.data, 'optionalAccess', _5 => _5.vaultV2ByAddress]);
-    if (!vault || typeof vault.netApy !== "number") {
-      throw new StableValidationError(
-        "apy",
-        void 0,
-        "earn: vault not found in Morpho API or unexpected response shape"
-      );
+    const depositAction = vault.deposit({
+      amount: assetsRaw,
+      userAddress: from,
+      accrualVault: vaultData,
+      slippageTolerance: slippageTolerance !== void 0 ? _viem.parseUnits.call(void 0, String(slippageTolerance), 18) : void 0
+    });
+    const requirements = await depositAction.getRequirements();
+    const steps = [];
+    for (const req of requirements) {
+      if (_morphosdk.isRequirementApproval.call(void 0, req)) {
+        steps.push({ to: req.to, data: req.data, value: req.value });
+      }
     }
-    const rewards = vault.rewards.filter((r) => typeof r.supplyApr === "number" && r.supplyApr > 0).map((r) => ({ symbol: r.asset.symbol, address: r.asset.address, apr: r.supplyApr }));
-    return {
-      apy: vault.netApy,
-      native: _nullishCoalesce(vault.netApyExcludingRewards, () => ( 0)),
-      rewards,
-      performanceFee: vault.performanceFee,
-      managementFee: vault.managementFee
-    };
+    const tx = depositAction.buildTx(void 0);
+    steps.push({ to: tx.to, data: tx.data, value: tx.value });
+    return { steps, chainId: this.config.chainId };
   }
-};
-
-// src/services/lifi.ts
-
-
-
-
-
-
-
-
-
-
-// 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
+  async prepareWithdrawCalldata(params) {
+    this._validateAmount(params.amount, "prepareWithdrawCalldata");
+    const { amount, tokenDecimals } = params;
+    const from = this._requireFrom();
+    const vaultAddr = this.config.vault;
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "prepareWithdrawCalldata")));
+    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
+    const tx = vaultData.assetBalance >= assetsRaw ? vault.withdraw({ amount: assetsRaw, userAddress: from }).buildTx() : vault.forceWithdraw({
+      deallocations: this._buildAutoDeallocs(
+        vaultData.accrualAdapters,
+        assetsRaw - vaultData.assetBalance,
+        amount
+      ),
+      withdraw: { amount: assetsRaw },
+      userAddress: from
+    }).buildTx();
+    return { to: tx.to, data: tx.data, value: tx.value, chainId: this.config.chainId };
   }
-};
-
-// src/services/lifi.ts
-var LiFiService = class {
-  constructor(config) {
-    this.config = config;
+  async prepareRedeemCalldata(params) {
+    this._validateShares(params.shares, "prepareRedeemCalldata");
+    const { shares, shareDecimals } = params;
+    const from = this._requireFrom();
+    const vaultAddr = this.config.vault;
+    let decimals = shareDecimals;
+    if (decimals === void 0) {
+      try {
+        decimals = await this.pc.readContract({
+          address: vaultAddr,
+          abi: _viem.erc20Abi,
+          functionName: "decimals"
+        });
+      } catch (e2) {
+        throw new StableValidationError(
+          "shareDecimals",
+          void 0,
+          `prepareRedeemCalldata: could not fetch share decimals for vault "${vaultAddr}" \u2014 pass shareDecimals explicitly`
+        );
+      }
+    }
+    const sharesRaw = _viem.parseUnits.call(void 0, String(shares), decimals);
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const assetsEquivalent = vaultData.toAssets(sharesRaw);
+    const tx = vaultData.assetBalance >= assetsEquivalent ? vault.redeem({ shares: sharesRaw, userAddress: from }).buildTx() : vault.forceRedeem({
+      deallocations: this._buildAutoDeallocs(
+        vaultData.accrualAdapters,
+        assetsEquivalent - vaultData.assetBalance,
+        shares
+      ),
+      redeem: { shares: sharesRaw },
+      userAddress: from
+    }).buildTx();
+    return { to: tx.to, data: tx.data, value: tx.value, chainId: this.config.chainId };
   }
-  async quoteSwap(params) {
-    this._validateSwapParams(params);
-    const { fromToken, toToken, amount, fromDecimals = 6, toAddress } = params;
+  // ─── Private operations ──────────────────────────────────────────────────
+  async _deposit(params) {
+    const {
+      amount,
+      tokenDecimals,
+      slippageTolerance,
+      idempotencyKey,
+      depositBuffer
+    } = 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 vaultAddr = _nullishCoalesce(params.vault, () => ( this.config.vault));
+    await this._switchChain();
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "earn deposit")));
+    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
+    if (depositBuffer !== void 0) {
+      const bps = BigInt(Math.round(depositBuffer * 1e4));
+      const maxAllowed = vaultData.assetBalance * bps / 10000n;
+      if (assetsRaw > maxAllowed) {
+        const maxFormatted = Number(_viem.formatUnits.call(void 0, maxAllowed, decimals));
+        const idleFormatted = Number(
+          _viem.formatUnits.call(void 0, vaultData.assetBalance, decimals)
+        );
+        throw new StableValidationError(
+          "amount",
+          amount,
+          `earn deposit: amount ${amount} exceeds deposit buffer \u2014 max ${maxFormatted} (${depositBuffer * 100}% of ${idleFormatted} idle liquidity)`
+        );
+      }
+    }
+    const depositAction = vault.deposit({
+      amount: assetsRaw,
+      userAddress: from,
+      accrualVault: vaultData,
+      slippageTolerance: slippageTolerance !== void 0 ? (
+        // Morpho SDK expects slippage as a WAD-scaled fraction (1e18 = 100%)
+        _viem.parseUnits.call(void 0, String(slippageTolerance), 18)
+      ) : void 0
     });
-    const quote = await this._fetchQuote(qs);
-    return this._toSwapQuote(quote);
+    const requirements = await depositAction.getRequirements();
+    let sig;
+    for (const req of requirements) {
+      if (_morphosdk.isRequirementApproval.call(void 0, req)) {
+        const approveHash = await this._sendTx(
+          req.to,
+          req.data,
+          req.value,
+          from
+        );
+        const approveReceipt = await this.pc.waitForTransactionReceipt({
+          hash: approveHash
+        });
+        if (approveReceipt.status === "reverted") {
+          throw new StableTransactionError({
+            phase: "approve",
+            shortMessage: "earn deposit: token approval reverted on-chain",
+            txHash: approveReceipt.transactionHash,
+            chainId: this.config.chainId
+          });
+        }
+      } else if (_morphosdk.isRequirementSignature.call(void 0, req)) {
+        sig = await req.sign(this.wc, from);
+      }
+    }
+    const tx = depositAction.buildTx(sig);
+    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
+    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "earn deposit: vault deposit reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
+    }
+    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  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 _withdraw(params) {
+    const { amount, tokenDecimals, idempotencyKey } = params;
+    const from = this._requireFrom();
+    const vaultAddr = this.config.vault;
+    await this._switchChain();
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "earn withdraw")));
+    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
+    const tx = vaultData.assetBalance >= assetsRaw ? vault.withdraw({ amount: assetsRaw, userAddress: from }).buildTx() : vault.forceWithdraw({
+      deallocations: this._buildAutoDeallocs(
+        vaultData.accrualAdapters,
+        assetsRaw - vaultData.assetBalance,
+        amount
+      ),
+      withdraw: { amount: assetsRaw },
+      userAddress: from
+    }).buildTx();
+    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
+    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "earn withdraw: vault withdraw reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
+    }
+    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  async quoteBridge(params) {
-    this._validateBridgeParams(params);
-    const { fromChain, toChain, fromToken, toToken, amount, fromDecimals = 6, recipient } = params;
-    const from = _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _6 => _6.config, 'access', _7 => _7.walletClient, 'optionalAccess', _8 => _8.account, 'optionalAccess', _9 => _9.address]), () => ( _optionalChain([this, 'access', _10 => _10.config, 'access', _11 => _11.account, 'optionalAccess', _12 => _12.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 _redeem(params) {
+    const { shares, shareDecimals, idempotencyKey } = params;
+    const from = this._requireFrom();
+    const vaultAddr = this.config.vault;
+    await this._switchChain();
+    let decimals = shareDecimals;
+    if (decimals === void 0) {
+      try {
+        decimals = await this.pc.readContract({
+          address: vaultAddr,
+          abi: _viem.erc20Abi,
+          functionName: "decimals"
+        });
+      } catch (e3) {
+        throw new StableValidationError(
+          "shareDecimals",
+          void 0,
+          `earn redeem: could not fetch share decimals for vault "${vaultAddr}" \u2014 pass shareDecimals explicitly`
+        );
+      }
+    }
+    const sharesRaw = _viem.parseUnits.call(void 0, String(shares), decimals);
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    const vaultData = await vault.getData();
+    const assetsEquivalent = vaultData.toAssets(sharesRaw);
+    const tx = vaultData.assetBalance >= assetsEquivalent ? vault.redeem({ shares: sharesRaw, userAddress: from }).buildTx() : vault.forceRedeem({
+      deallocations: this._buildAutoDeallocs(
+        vaultData.accrualAdapters,
+        assetsEquivalent - vaultData.assetBalance,
+        shares
+      ),
+      redeem: { shares: sharesRaw },
+      userAddress: from
+    }).buildTx();
+    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
+    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "earn redeem: vault redeem reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
+    }
+    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  async bridge(params) {
-    this._validateBridgeParams(params);
-    const { fromChain, toChain, fromToken, toToken, amount, fromDecimals = 6, recipient } = params;
+  async _forceWithdraw(params) {
+    const { amount, tokenDecimals, deallocations, idempotencyKey } = 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}"`);
+    const vaultAddr = this.config.vault;
+    await this._switchChain();
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    let decimals = tokenDecimals;
+    if (decimals === void 0) {
+      const vaultData = await vault.getData();
+      decimals = await this._resolveDecimals(
+        vaultData.asset,
+        "earn forceWithdraw"
+      );
     }
-    if (!dst) {
-      throw new StableValidationError("toChain", toChain, `LI.FI bridge: unsupported destination chain "${toChain}"`);
+    const tx = vault.forceWithdraw({
+      deallocations: this._buildDeallocs(deallocations, decimals),
+      withdraw: { amount: _viem.parseUnits.call(void 0, String(amount), decimals) },
+      userAddress: from
+    }).buildTx();
+    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
+    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "earn forceWithdraw: vault forceWithdraw reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
     }
-    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);
+    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  _validateSwapParams({ fromToken, toToken, amount, toAddress }) {
-    if (!_viem.isAddress.call(void 0, fromToken)) {
-      throw new StableValidationError("fromToken", fromToken, `swap: invalid fromToken address "${fromToken}"`);
+  async _forceRedeem(params) {
+    const {
+      shares,
+      shareDecimals,
+      tokenDecimals,
+      deallocations,
+      idempotencyKey
+    } = params;
+    const from = this._requireFrom();
+    const vaultAddr = this.config.vault;
+    await this._switchChain();
+    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
+    let shareDec = shareDecimals;
+    if (shareDec === void 0) {
+      try {
+        shareDec = await this.pc.readContract({
+          address: vaultAddr,
+          abi: _viem.erc20Abi,
+          functionName: "decimals"
+        });
+      } catch (e4) {
+        throw new StableValidationError(
+          "shareDecimals",
+          void 0,
+          `earn forceRedeem: could not fetch share decimals for vault "${vaultAddr}" \u2014 pass shareDecimals explicitly`
+        );
+      }
     }
-    if (!_viem.isAddress.call(void 0, toToken)) {
-      throw new StableValidationError("toToken", toToken, `swap: invalid toToken address "${toToken}"`);
+    let assetDec = tokenDecimals;
+    if (assetDec === void 0) {
+      const vaultData = await vault.getData();
+      assetDec = await this._resolveDecimals(
+        vaultData.asset,
+        "earn forceRedeem"
+      );
     }
-    if (fromToken.toLowerCase() === toToken.toLowerCase()) {
-      throw new StableValidationError("toToken", toToken, "swap: fromToken and toToken must differ");
+    const tx = vault.forceRedeem({
+      deallocations: this._buildDeallocs(deallocations, assetDec),
+      redeem: { shares: _viem.parseUnits.call(void 0, String(shares), shareDec) },
+      userAddress: from
+    }).buildTx();
+    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
+    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new StableTransactionError({
+        phase: "receipt",
+        shortMessage: "earn forceRedeem: vault forceRedeem reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
     }
-    if (!Number.isFinite(amount) || amount <= 0) {
-      throw new StableValidationError("amount", amount, "swap: amount must be a finite positive number");
+    return { txHash: receipt.transactionHash, idempotencyKey };
+  }
+  // Automatically derives the minimum set of adapter deallocations needed to cover `deficit`
+  // when the vault has insufficient idle cash for a direct withdraw/redeem. Adds a 0.5%
+  // buffer to account for interest accrual between vaultData read and tx execution.
+  _buildAutoDeallocs(adapters, deficit, amount) {
+    const needed = deficit + deficit * 50n / 10000n;
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const result = [];
+    let remaining = needed;
+    for (const adapter of adapters) {
+      if (remaining === 0n) break;
+      remaining = this._pullFromAdapter(adapter, remaining, now, result);
     }
-    if (toAddress !== void 0 && !_viem.isAddress.call(void 0, toAddress)) {
-      throw new StableValidationError("toAddress", toAddress, `swap: invalid toAddress "${toAddress}"`);
+    if (remaining > 0n) {
+      throw new StableValidationError(
+        "amount",
+        amount,
+        "earn withdraw: insufficient adapter liquidity \u2014 reduce the amount or wait for market liquidity to free up"
+      );
     }
+    return result;
   }
-  _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}"`);
+  _pullFromAdapter(adapter, remaining, now, result) {
+    if (adapter.type !== "VaultV2MorphoMarketV1AdapterV2") {
+      const available = adapter.realAssets(now);
+      if (available === 0n) return remaining;
+      const pull = available < remaining ? available : remaining;
+      result.push({ adapter: adapter.address, amount: pull });
+      return remaining - pull;
     }
-    if (!_viem.isAddress.call(void 0, toToken)) {
-      throw new StableValidationError("toToken", toToken, `LI.FI bridge: invalid toToken address "${toToken}"`);
+    const a = adapter;
+    return this._pullFromV2Markets(adapter.address, a.markets, a.supplyShares, remaining, result);
+  }
+  _pullFromV2Markets(adapterAddress, markets, supplyShares, remaining, result) {
+    let rem = remaining;
+    for (const mkt of markets) {
+      if (rem === 0n) break;
+      const adapterShares = _nullishCoalesce(supplyShares[mkt.id], () => ( 0n));
+      const available = mkt.totalSupplyShares > 0n ? adapterShares * mkt.totalSupplyAssets / mkt.totalSupplyShares : 0n;
+      if (available === 0n) continue;
+      const pull = available < rem ? available : rem;
+      result.push({ adapter: adapterAddress, marketParams: mkt.params, amount: pull });
+      rem -= pull;
     }
-    if (!Number.isFinite(amount) || amount <= 0) {
-      throw new StableValidationError("amount", amount, "LI.FI bridge: amount must be a finite positive number");
+    return rem;
+  }
+  _buildDeallocs(deallocations, assetDecimals) {
+    return deallocations.map((d) => ({
+      adapter: d.adapter,
+      amount: _viem.parseUnits.call(void 0, String(d.amount), assetDecimals),
+      // MarketParams in the Morpho SDK has computed fields (id, liquidationIncentiveFactor)
+      // not present in our user-facing type; the plain object is structurally compatible for ABI encoding.
+      ...d.marketParams && {
+        marketParams: d.marketParams
+      }
+    }));
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────
+  _requireFrom() {
+    const from = _optionalChain([this, 'access', _5 => _5.wc, 'access', _6 => _6.account, 'optionalAccess', _7 => _7.address]);
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "earn: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
     }
-    if (recipient !== void 0 && !_viem.isAddress.call(void 0, recipient)) {
-      throw new StableValidationError("recipient", recipient, `LI.FI bridge: invalid recipient address "${recipient}"`);
+    return from;
+  }
+  async _switchChain() {
+    try {
+      await this.wc.switchChain({ id: this.config.chainId });
+    } catch (err) {
+      if (err.code === 4001) {
+        throw new StableTransactionError({
+          phase: "switch_chain",
+          shortMessage: `earn: wallet rejected switch to chain ${this.config.chainId}`,
+          chainId: this.config.chainId,
+          cause: err
+        });
+      }
     }
-    if (fromChain === toChain) {
-      throw new StableValidationError("toChain", toChain, "LI.FI bridge: fromChain and toChain must differ");
+  }
+  async _sendTx(to, data, value, from) {
+    try {
+      return await this.wc.sendTransaction({
+        to,
+        data,
+        value,
+        account: from,
+        chain: this.chain
+      });
+    } catch (err) {
+      throw new StableTransactionError({
+        phase: "send",
+        shortMessage: "earn: transaction send failed",
+        chainId: this.config.chainId,
+        cause: err
+      });
+    }
+  }
+  async _resolveDecimals(asset, op) {
+    try {
+      return await retryWithBackoff(
+        () => this.pc.readContract({
+          address: asset,
+          abi: _viem.erc20Abi,
+          functionName: "decimals"
+        })
+      );
+    } catch (e5) {
+      throw new StableValidationError(
+        "tokenDecimals",
+        void 0,
+        `${op}: could not fetch decimals for asset "${asset}" \u2014 pass tokenDecimals explicitly`
+      );
+    }
+  }
+  _withIdempotency(key, fn) {
+    if (!key) return fn();
+    const existing = this.inFlight.get(key);
+    if (existing) return existing;
+    const promise = fn().finally(() => this.inFlight.delete(key));
+    this.inFlight.set(key, promise);
+    return promise;
+  }
+  _validateAmount(amount, op) {
+    if (!Number.isFinite(amount) || amount <= 0) {
+      throw new StableValidationError(
+        "amount",
+        amount,
+        `${op}: amount must be a finite positive number`
+      );
     }
   }
-  _requireFrom() {
-    const from = _nullishCoalesce(_optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.walletClient, 'optionalAccess', _15 => _15.account, 'optionalAccess', _16 => _16.address]), () => ( _optionalChain([this, 'access', _17 => _17.config, 'access', _18 => _18.account, 'optionalAccess', _19 => _19.address])));
-    if (!from) {
+  _validateShares(shares, op) {
+    if (!Number.isFinite(shares) || shares <= 0) {
       throw new StableValidationError(
-        "signer",
-        void 0,
-        "LI.FI: requires a signer \u2014 set walletClient or account in StableConfig"
+        "shares",
+        shares,
+        `${op}: shares must be a finite positive number`
       );
     }
-    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
-      });
+};
+
+// src/earn/reader.ts
+
+
+
+
+
+
+
+
+
+
+
+// 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/earn/reader.ts
+var MORPHO_API_URL = "https://blue-api.morpho.org/graphql";
+var EarnReader = class {
+  constructor(config) {
+    if (!_optionalChain([config, 'access', _8 => _8.earn, 'optionalAccess', _9 => _9.vault])) {
+      throw new StableValidationError(
+        "earn.vault",
+        void 0,
+        "createStableReader: earn.vault is required"
+      );
     }
-  }
-  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 (!_viem.isAddress.call(void 0, config.address)) {
+      throw new StableValidationError(
+        "address",
+        config.address,
+        `createStableReader: invalid user address "${config.address}"`
+      );
     }
-    if (!isLiFiQuoteShape(body)) {
-      throw new StableQuoteError({
-        provider: "lifi",
-        shortMessage: "LI.FI: unexpected quote response shape",
-        httpStatus: res.status,
-        body
-      });
+    if (!_viem.isAddress.call(void 0, config.earn.vault)) {
+      throw new StableValidationError(
+        "earn.vault",
+        config.earn.vault,
+        `createStableReader: invalid vault address "${config.earn.vault}"`
+      );
     }
-    return body;
+    const network = _nullishCoalesce(config.network, () => ( "mainnet")) /* Mainnet */;
+    const viemChain = network === "mainnet" /* Mainnet */ ? _chains.stable : _chains.stableTestnet;
+    const rpc = (_nullishCoalesce(config.rpc, () => ( viemChain.rpcUrls.default.http[0]))).replace(
+      /\/$/,
+      ""
+    );
+    this.chainId = viemChain.id;
+    this.vaultAddr = config.earn.vault;
+    this.userAddr = config.address;
+    const chain = makeChain(viemChain.id, rpc);
+    this.pc = _viem.createPublicClient.call(void 0, { chain, transport: _viem.http.call(void 0, rpc) });
+    this.morpho = new (0, _morphosdk.MorphoClient)(this.pc);
   }
-  _toSwapQuote(quote) {
+  async position() {
+    const vault = this.morpho.vaultV2(this.vaultAddr, this.chainId);
+    const [vaultData, shares] = await Promise.all([
+      vault.getData(),
+      this.pc.readContract({
+        address: this.vaultAddr,
+        abi: _viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [this.userAddr]
+      })
+    ]);
+    const [tokenDecimals, shareDecimals] = await Promise.all([
+      this.pc.readContract({
+        address: vaultData.asset,
+        abi: _viem.erc20Abi,
+        functionName: "decimals"
+      }),
+      this.pc.readContract({
+        address: this.vaultAddr,
+        abi: _viem.erc20Abi,
+        functionName: "decimals"
+      })
+    ]);
+    const assetsRaw = vaultData.toAssets(shares);
     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
+      shares,
+      sharesFormatted: Number(_viem.formatUnits.call(void 0, shares, shareDecimals)),
+      shareDecimals,
+      assets: Number(_viem.formatUnits.call(void 0, assetsRaw, tokenDecimals)),
+      tokenDecimals,
+      assetAddress: vaultData.asset
     };
   }
-  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)))
+  async getYield() {
+    return this._fetchYield();
+  }
+  async preview(params) {
+    const { amount, horizonDays } = params;
+    const apy = await this._fetchNetApy();
+    return {
+      projectedYield: amount * ((1 + apy) ** (horizonDays / 365) - 1),
+      apy,
+      horizonDays
+    };
+  }
+  async withdrawability(params) {
+    const vault = this.morpho.vaultV2(this.vaultAddr, this.chainId);
+    const vaultData = await vault.getData();
+    const tokenDecimals = await _asyncNullishCoalesce(params.tokenDecimals, async () => ( await this.pc.readContract({
+      address: vaultData.asset,
+      abi: _viem.erc20Abi,
+      functionName: "decimals"
     })));
-    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
-      });
+    const requestedRaw = _viem.parseUnits.call(void 0, String(params.amount), tokenDecimals);
+    let availableLiquidityRaw = vaultData.assetBalance;
+    if (vaultData.accrualLiquidityAdapter != null) {
+      availableLiquidityRaw += vaultData.accrualLiquidityAdapter.maxWithdraw(
+        vaultData.liquidityData
+      ).value;
     }
-    return { txHash: hash, toAmount: quote.toAmount };
+    return {
+      isInstant: requestedRaw <= availableLiquidityRaw,
+      availableLiquidity: Number(
+        _viem.formatUnits.call(void 0, availableLiquidityRaw, tokenDecimals)
+      ),
+      tokenDecimals
+    };
   }
-  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;
+  async _fetchNetApy() {
+    const { apy } = await this._fetchYield();
+    return apy;
+  }
+  async _fetchYield() {
+    const query = `
+      query VaultYield($address: String!, $chainId: Int!) {
+        vaultV2ByAddress(address: $address, chainId: $chainId) {
+          avgNetApy
+          avgNetApyExcludingRewards
+          performanceFee
+          managementFee
+          rewards {
+            asset { symbol address }
+            supplyApr
+          }
+        }
+      }
+    `;
+    let body;
     try {
-      approveHash = await wc.writeContract({
-        address: tokenAddr,
-        abi: _viem.erc20Abi,
-        functionName: "approve",
-        args: [quote.approvalAddress, quote.fromAmount],
-        account: wc.account,
-        chain: srcChain
-      });
+      body = await retryWithBackoff(
+        async () => {
+          const res = await fetch(MORPHO_API_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              query,
+              variables: {
+                address: this.vaultAddr,
+                chainId: this.chainId
+              }
+            })
+          });
+          if (!res.ok) {
+            const retryable = res.status === 429 || res.status >= 500;
+            throw new HttpError(
+              `earn: Morpho API returned ${res.status} \u2014 ${res.statusText}`,
+              res.status,
+              retryable
+            );
+          }
+          return res.json().catch(() => void 0);
+        },
+        (err) => err instanceof HttpError ? err.retryable : err instanceof TypeError
+      );
     } catch (err) {
-      throw new StableTransactionError({
-        phase: "approve",
-        shortMessage: "LI.FI: token approve failed",
-        chainId: srcChainId,
-        cause: err
-      });
+      if (err instanceof TypeError || err instanceof HttpError) {
+        throw new StableNetworkError({
+          shortMessage: err instanceof HttpError ? `earn: Morpho API returned ${err.status} after retries` : `earn: failed to reach Morpho API after retries \u2014 ${String(
+            err
+          )}`,
+          url: MORPHO_API_URL,
+          cause: err
+        });
+      }
+      throw 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
-      });
+    const vault = _optionalChain([body, 'optionalAccess', _10 => _10.data, 'optionalAccess', _11 => _11.vaultV2ByAddress]);
+    if (!vault || typeof vault.avgNetApy !== "number") {
+      throw new StableValidationError(
+        "apy",
+        void 0,
+        "earn: vault not found in Morpho API or unexpected response shape"
+      );
     }
+    const rewards = vault.rewards.filter((r) => typeof r.supplyApr === "number" && r.supplyApr > 0).map((r) => ({
+      symbol: r.asset.symbol,
+      address: r.asset.address,
+      apr: r.supplyApr
+    }));
+    return {
+      apy: vault.avgNetApy,
+      native: _nullishCoalesce(vault.avgNetApyExcludingRewards, () => ( 0)),
+      rewards,
+      performanceFee: vault.performanceFee,
+      managementFee: vault.managementFee
+    };
   }
 };
-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/earn/morpho.ts
-
-
 
+// src/earn/merkl.ts
 
 
 
@@ -694,386 +1023,751 @@ function isLiFiQuoteShape(v) {
 
 
 
-
-
-
-var MorphoService = class {
+var MERKL_API_BASE_DEFAULT = "https://api.merkl.xyz";
+var DISTRIBUTOR_ADDRESS = "0x3Ef3D8bA38EBe18DB133cEc108f4D14CE00Dd9Ae";
+var DISTRIBUTOR_ABI = [
+  {
+    inputs: [
+      { name: "users", type: "address[]" },
+      { name: "tokens", type: "address[]" },
+      { name: "amounts", type: "uint256[]" },
+      { name: "proofs", type: "bytes32[][]" }
+    ],
+    name: "claim",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var MerklService = class {
   constructor(config) {
     this.config = config;
-    this.inFlight = /* @__PURE__ */ new Map();
-    this.chain = makeChain(config.chainId, config.rpc);
-    this.wc = _nullishCoalesce(config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
-      account: config.account,
-      chain: this.chain,
-      transport: _nullishCoalesce(config.transport, () => ( _viem.http.call(void 0, config.rpc)))
-    })));
-    const morphoWc = _optionalChain([this, 'access', _20 => _20.wc, 'access', _21 => _21.chain, 'optionalAccess', _22 => _22.id]) === config.chainId ? this.wc : _viem.createWalletClient.call(void 0, {
-      account: this.wc.account,
-      chain: this.chain,
-      transport: _viem.custom.call(void 0, { request: this.wc.request.bind(this.wc) })
-    });
-    this.morpho = new (0, _morphosdk.MorphoClient)(morphoWc, { supportSignature: true });
-    this.pc = _viem.createPublicClient.call(void 0, { chain: this.chain, transport: _viem.http.call(void 0, config.rpc) });
   }
-  deposit(params) {
-    this._validateAmount(params.amount, "earn deposit");
-    if (params.depositBuffer !== void 0 && (params.depositBuffer <= 0 || params.depositBuffer > 1)) {
-      throw new StableValidationError("depositBuffer", params.depositBuffer, "earn deposit: depositBuffer must be > 0 and \u2264 1");
+  async fetchRewards(address) {
+    if (!_viem.isAddress.call(void 0, address)) {
+      throw new StableValidationError(
+        "address",
+        address,
+        `merkl: invalid address "${address}"`
+      );
     }
-    return this._withIdempotency(params.idempotencyKey, () => this._deposit(params));
-  }
-  async bulkDeposit(items, options = {}) {
-    const { idempotencyKey, stopOnError = false } = options;
-    const run = async () => {
-      const results = [];
-      for (const item of items) {
-        try {
-          const result = await this.deposit(item);
-          results.push({ status: "fulfilled", txHash: result.txHash, vault: item.vault, idempotencyKey: item.idempotencyKey });
-        } catch (err) {
-          const entry = { status: "rejected", error: String(err), vault: item.vault, idempotencyKey: item.idempotencyKey };
-          results.push(entry);
-          if (stopOnError) {
-            const succeeded2 = results.filter((r) => r.status === "fulfilled").length;
-            throw new StableBulkError({
-              shortMessage: "bulkDeposit halted on first failure",
-              results,
-              succeeded: succeeded2,
-              failed: results.length - succeeded2
-            });
-          }
-        }
-      }
-      const succeeded = results.filter((r) => r.status === "fulfilled").length;
-      return { results, succeeded, failed: results.length - succeeded, idempotencyKey };
-    };
-    return this._withIdempotency(idempotencyKey, run);
-  }
-  async bulkWithdraw(items, options = {}) {
-    const { idempotencyKey, stopOnError = false } = options;
-    const run = async () => {
-      const results = [];
-      for (const item of items) {
-        try {
-          const result = await this.withdraw(item);
-          results.push({ status: "fulfilled", txHash: result.txHash, idempotencyKey: item.idempotencyKey });
-        } catch (err) {
-          const entry = { status: "rejected", error: String(err), idempotencyKey: item.idempotencyKey };
-          results.push(entry);
-          if (stopOnError) {
-            const succeeded2 = results.filter((r) => r.status === "fulfilled").length;
-            throw new StableBulkError({
-              shortMessage: "bulkWithdraw halted on first failure",
-              results,
-              succeeded: succeeded2,
-              failed: results.length - succeeded2
-            });
-          }
-        }
-      }
-      const succeeded = results.filter((r) => r.status === "fulfilled").length;
-      return { results, succeeded, failed: results.length - succeeded, idempotencyKey };
-    };
-    return this._withIdempotency(idempotencyKey, run);
-  }
-  withdraw(params) {
-    this._validateAmount(params.amount, "earn withdraw");
-    return this._withIdempotency(params.idempotencyKey, () => this._withdraw(params));
-  }
-  redeem(params) {
-    this._validateShares(params.shares, "earn redeem");
-    return this._withIdempotency(params.idempotencyKey, () => this._redeem(params));
+    const base = (_nullishCoalesce(this.config.merklApiBase, () => ( MERKL_API_BASE_DEFAULT))).replace(/\/$/, "");
+    const url = `${base}/v4/users/${address}/rewards?chainId=${this.config.chainId}`;
+    const data = await this._fetch(url);
+    return this._parseRewards(data);
   }
-  forceWithdraw(params) {
-    this._validateAmount(params.amount, "earn forceWithdraw");
-    return this._withIdempotency(params.idempotencyKey, () => this._forceWithdraw(params));
-  }
-  forceRedeem(params) {
-    this._validateShares(params.shares, "earn forceRedeem");
-    return this._withIdempotency(params.idempotencyKey, () => this._forceRedeem(params));
-  }
-  // ─── Private operations ──────────────────────────────────────────────────
-  async _deposit(params) {
-    const { amount, tokenDecimals, slippageTolerance, idempotencyKey, depositBuffer } = params;
-    const from = this._requireFrom();
-    const vaultAddr = _nullishCoalesce(params.vault, () => ( this.config.vault));
-    await this._switchChain();
-    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
-    const vaultData = await vault.getData();
-    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "earn deposit")));
-    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
-    if (depositBuffer !== void 0) {
-      const bps = BigInt(Math.round(depositBuffer * 1e4));
-      const maxAllowed = vaultData.assetBalance * bps / 10000n;
-      if (assetsRaw > maxAllowed) {
-        const maxFormatted = Number(_viem.formatUnits.call(void 0, maxAllowed, decimals));
-        const idleFormatted = Number(_viem.formatUnits.call(void 0, vaultData.assetBalance, decimals));
-        throw new StableValidationError(
-          "amount",
-          amount,
-          `earn deposit: amount ${amount} exceeds deposit buffer \u2014 max ${maxFormatted} (${depositBuffer * 100}% of ${idleFormatted} idle liquidity)`
-        );
-      }
-    }
-    const depositAction = vault.deposit({
-      amount: assetsRaw,
-      userAddress: from,
-      accrualVault: vaultData,
-      slippageTolerance: slippageTolerance !== void 0 ? _viem.parseUnits.call(void 0, String(slippageTolerance), 18) : void 0
-    });
-    const requirements = await depositAction.getRequirements();
-    let sig;
-    for (const req of requirements) {
-      if (_morphosdk.isRequirementApproval.call(void 0, req)) {
-        const approveHash = await this._sendTx(req.to, req.data, req.value, from);
-        const approveReceipt = await this.pc.waitForTransactionReceipt({ hash: approveHash });
-        if (approveReceipt.status === "reverted") {
-          throw new StableTransactionError({
-            phase: "approve",
-            shortMessage: "earn deposit: token approval reverted on-chain",
-            txHash: approveReceipt.transactionHash,
-            chainId: this.config.chainId
-          });
-        }
-      } else if (_morphosdk.isRequirementSignature.call(void 0, req)) {
-        sig = await req.sign(this.wc, from);
-      }
+  async claim() {
+    const address = this._requireFrom();
+    const { rewards } = await this.fetchRewards(address);
+    const claimable = rewards.filter(
+      (r) => r.rawAmount !== "0" && r.proofs.length > 0
+    );
+    if (claimable.length === 0) {
+      throw new StableValidationError(
+        "rewards",
+        [],
+        rewards.length > 0 ? "merkl: rewards are pending the next merkle tree update \u2014 try again in ~2 hours" : "merkl: no rewards to claim on this chain"
+      );
     }
-    const tx = depositAction.buildTx(sig);
-    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
-    const receipt = await this.pc.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
+    const chain = makeChain(this.config.chainId, this.config.rpc);
+    const wc = _nullishCoalesce(this.config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
+      account: this.config.account,
+      chain,
+      transport: _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, this.config.rpc)))
+    })));
+    try {
+      await wc.switchChain({ id: this.config.chainId });
+    } catch (err) {
       throw new StableTransactionError({
-        phase: "receipt",
-        shortMessage: "earn deposit: vault deposit reverted on-chain",
-        txHash: receipt.transactionHash,
-        chainId: this.config.chainId
+        phase: "switch_chain",
+        shortMessage: `merkl: wallet rejected or failed to switch to chain ${this.config.chainId}`,
+        chainId: this.config.chainId,
+        cause: err
       });
     }
-    return { txHash: receipt.transactionHash, idempotencyKey };
-  }
-  async _withdraw(params) {
-    const { amount, tokenDecimals, idempotencyKey } = params;
-    const from = this._requireFrom();
-    const vaultAddr = this.config.vault;
-    await this._switchChain();
-    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
-    const vaultData = await vault.getData();
-    const decimals = await _asyncNullishCoalesce(tokenDecimals, async () => ( await this._resolveDecimals(vaultData.asset, "earn withdraw")));
-    const assetsRaw = _viem.parseUnits.call(void 0, String(amount), decimals);
-    const tx = vault.withdraw({ amount: assetsRaw, userAddress: from }).buildTx();
-    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
-    const receipt = await this.pc.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
+    const users = claimable.map(() => address);
+    const tokens = claimable.map(
+      (r) => r.token.address
+    );
+    const amounts = claimable.map((r) => BigInt(r.rawAmount));
+    const proofs = claimable.map((r) => r.proofs);
+    let hash;
+    try {
+      hash = await wc.writeContract({
+        address: DISTRIBUTOR_ADDRESS,
+        abi: DISTRIBUTOR_ABI,
+        functionName: "claim",
+        args: [users, tokens, amounts, proofs],
+        account: wc.account,
+        chain
+      });
+    } catch (err) {
       throw new StableTransactionError({
-        phase: "receipt",
-        shortMessage: "earn withdraw: vault withdraw reverted on-chain",
-        txHash: receipt.transactionHash,
-        chainId: this.config.chainId
+        phase: "send",
+        shortMessage: "merkl: claim transaction failed",
+        chainId: this.config.chainId,
+        cause: err
       });
     }
-    return { txHash: receipt.transactionHash, idempotencyKey };
-  }
-  async _redeem(params) {
-    const { shares, shareDecimals, idempotencyKey } = params;
-    const from = this._requireFrom();
-    const vaultAddr = this.config.vault;
-    await this._switchChain();
-    let decimals = shareDecimals;
-    if (decimals === void 0) {
-      try {
-        decimals = await this.pc.readContract({ address: vaultAddr, abi: _viem.erc20Abi, functionName: "decimals" });
-      } catch (e2) {
-        throw new StableValidationError(
-          "shareDecimals",
-          void 0,
-          `earn redeem: could not fetch share decimals for vault "${vaultAddr}" \u2014 pass shareDecimals explicitly`
-        );
-      }
-    }
-    const sharesRaw = _viem.parseUnits.call(void 0, String(shares), decimals);
-    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
-    const tx = vault.redeem({ shares: sharesRaw, userAddress: from }).buildTx();
-    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
-    const receipt = await this.pc.waitForTransactionReceipt({ hash });
+    const pc = _viem.createPublicClient.call(void 0, {
+      chain,
+      transport: _viem.http.call(void 0, this.config.rpc)
+    });
+    const receipt = await pc.waitForTransactionReceipt({ hash });
     if (receipt.status === "reverted") {
       throw new StableTransactionError({
         phase: "receipt",
-        shortMessage: "earn redeem: vault redeem reverted on-chain",
+        shortMessage: "merkl: claim transaction reverted on-chain",
         txHash: receipt.transactionHash,
         chainId: this.config.chainId
       });
     }
-    return { txHash: receipt.transactionHash, idempotencyKey };
+    return {
+      txHash: receipt.transactionHash,
+      tokenCount: claimable.length
+    };
   }
-  async _forceWithdraw(params) {
-    const { amount, tokenDecimals, deallocations, idempotencyKey } = params;
-    const from = this._requireFrom();
-    const vaultAddr = this.config.vault;
-    await this._switchChain();
-    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
-    let decimals = tokenDecimals;
-    if (decimals === void 0) {
-      const vaultData = await vault.getData();
-      decimals = await this._resolveDecimals(vaultData.asset, "earn forceWithdraw");
+  async prepareClaimCalldata(address) {
+    if (!_viem.isAddress.call(void 0, address)) {
+      throw new StableValidationError(
+        "address",
+        address,
+        `merkl: invalid address "${address}"`
+      );
     }
-    const tx = vault.forceWithdraw({
-      deallocations: this._buildDeallocs(deallocations, decimals),
-      withdraw: { amount: _viem.parseUnits.call(void 0, String(amount), decimals) },
-      userAddress: from
-    }).buildTx();
-    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
-    const receipt = await this.pc.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new StableTransactionError({
-        phase: "receipt",
-        shortMessage: "earn forceWithdraw: vault forceWithdraw reverted on-chain",
-        txHash: receipt.transactionHash,
-        chainId: this.config.chainId
+    const { rewards } = await this.fetchRewards(address);
+    const claimable = rewards.filter(
+      (r) => r.rawAmount !== "0" && r.proofs.length > 0
+    );
+    if (claimable.length === 0) {
+      throw new StableValidationError(
+        "rewards",
+        [],
+        rewards.length > 0 ? "merkl: rewards are pending the next merkle tree update \u2014 try again in ~2 hours" : "merkl: no rewards to claim on this chain"
+      );
+    }
+    const users = claimable.map(() => address);
+    const tokens = claimable.map((r) => r.token.address);
+    const amounts = claimable.map((r) => BigInt(r.rawAmount));
+    const proofs = claimable.map((r) => r.proofs);
+    const data = _viem.encodeFunctionData.call(void 0, {
+      abi: DISTRIBUTOR_ABI,
+      functionName: "claim",
+      args: [users, tokens, amounts, proofs]
+    });
+    return {
+      to: DISTRIBUTOR_ADDRESS,
+      data,
+      chainId: this.config.chainId,
+      rewards: claimable
+    };
+  }
+  _requireFrom() {
+    const from = _nullishCoalesce(_optionalChain([this, 'access', _12 => _12.config, 'access', _13 => _13.walletClient, 'optionalAccess', _14 => _14.account, 'optionalAccess', _15 => _15.address]), () => ( _optionalChain([this, 'access', _16 => _16.config, 'access', _17 => _17.account, 'optionalAccess', _18 => _18.address])));
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "merkl.claim: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
+    }
+    return from;
+  }
+  _parseRewards(data) {
+    const { chainId } = this.config;
+    const rewards = [];
+    const entries = Array.isArray(data) ? data : [data];
+    for (const entry of entries) {
+      if (_optionalChain([entry, 'optionalAccess', _19 => _19.chain, 'optionalAccess', _20 => _20.id]) !== chainId) continue;
+      for (const reward of _nullishCoalesce(entry.rewards, () => ( []))) {
+        const parsed = this._parseReward(reward);
+        if (parsed) rewards.push(parsed);
+      }
+    }
+    return { chainId, rewards };
+  }
+  _parseReward(reward) {
+    if (!_optionalChain([reward, 'optionalAccess', _21 => _21.token, 'optionalAccess', _22 => _22.address])) return null;
+    const net = BigInt(_nullishCoalesce(reward.amount, () => ( "0"))) - BigInt(_nullishCoalesce(reward.claimed, () => ( "0")));
+    if (net <= 0n) return null;
+    const rawAmount = net.toString();
+    const decimals = _nullishCoalesce(reward.token.decimals, () => ( 18));
+    return {
+      token: {
+        address: reward.token.address,
+        symbol: _nullishCoalesce(reward.token.symbol, () => ( "")),
+        decimals
+      },
+      rawAmount,
+      amount: Number(_viem.formatUnits.call(void 0, BigInt(rawAmount), decimals)),
+      proofs: _nullishCoalesce(reward.proofs, () => ( []))
+    };
+  }
+  async _fetch(url) {
+    try {
+      return await retryWithBackoff(() => this._fetchOnce(url));
+    } catch (err) {
+      if (err instanceof StableNetworkError) throw err;
+      if (err instanceof HttpError) {
+        throw new StableNetworkError({
+          shortMessage: `merkl: request failed \u2014 ${err.message}`,
+          url,
+          cause: err
+        });
+      }
+      throw new StableNetworkError({
+        shortMessage: "merkl: request failed before reaching the server",
+        url,
+        cause: err
       });
     }
-    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  async _forceRedeem(params) {
-    const { shares, shareDecimals, tokenDecimals, deallocations, idempotencyKey } = params;
-    const from = this._requireFrom();
-    const vaultAddr = this.config.vault;
-    await this._switchChain();
-    const vault = this.morpho.vaultV2(vaultAddr, this.config.chainId);
-    let shareDec = shareDecimals;
-    if (shareDec === void 0) {
-      try {
-        shareDec = await this.pc.readContract({ address: vaultAddr, abi: _viem.erc20Abi, functionName: "decimals" });
-      } catch (e3) {
-        throw new StableValidationError(
-          "shareDecimals",
-          void 0,
-          `earn forceRedeem: could not fetch share decimals for vault "${vaultAddr}" \u2014 pass shareDecimals explicitly`
+  async _fetchOnce(url) {
+    const res = await fetch(url);
+    if (!res.ok) {
+      if (res.status === 429 || res.status >= 500) {
+        throw new HttpError(
+          `merkl: ${res.statusText}`,
+          res.status,
+          true
         );
       }
+      throw new StableNetworkError({
+        shortMessage: `merkl: API error ${res.status} ${res.statusText}`,
+        url
+      });
+    }
+    return res.json();
+  }
+};
+
+// src/services/lifi.ts
+
+
+
+
+
+
+
+
+
+
+// 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/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', _23 => _23.config, 'access', _24 => _24.walletClient, 'optionalAccess', _25 => _25.account, 'optionalAccess', _26 => _26.address]), () => ( _optionalChain([this, 'access', _27 => _27.config, 'access', _28 => _28.account, 'optionalAccess', _29 => _29.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"
+      );
     }
-    let assetDec = tokenDecimals;
-    if (assetDec === void 0) {
-      const vaultData = await vault.getData();
-      assetDec = await this._resolveDecimals(vaultData.asset, "earn forceRedeem");
+    if (!Number.isFinite(amount) || amount <= 0) {
+      throw new StableValidationError(
+        "amount",
+        amount,
+        "swap: amount must be a finite positive number"
+      );
     }
-    const tx = vault.forceRedeem({
-      deallocations: this._buildDeallocs(deallocations, assetDec),
-      redeem: { shares: _viem.parseUnits.call(void 0, String(shares), shareDec) },
-      userAddress: from
-    }).buildTx();
-    const hash = await this._sendTx(tx.to, tx.data, tx.value, from);
-    const receipt = await this.pc.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new StableTransactionError({
-        phase: "receipt",
-        shortMessage: "earn forceRedeem: vault forceRedeem reverted on-chain",
-        txHash: receipt.transactionHash,
-        chainId: this.config.chainId
-      });
+    if (toAddress !== void 0 && !_viem.isAddress.call(void 0, toAddress)) {
+      throw new StableValidationError(
+        "toAddress",
+        toAddress,
+        `swap: invalid toAddress "${toAddress}"`
+      );
     }
-    return { txHash: receipt.transactionHash, idempotencyKey };
   }
-  _buildDeallocs(deallocations, assetDecimals) {
-    return deallocations.map((d) => ({
-      adapter: d.adapter,
-      amount: _viem.parseUnits.call(void 0, String(d.amount), assetDecimals),
-      // MarketParams in the Morpho SDK has computed fields (id, liquidationIncentiveFactor)
-      // not present in our user-facing type; the plain object is structurally compatible for ABI encoding.
-      ...d.marketParams && { marketParams: d.marketParams }
-    }));
+  _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"
+      );
+    }
   }
-  // ─── Helpers ─────────────────────────────────────────────────────────────
   _requireFrom() {
-    const from = _optionalChain([this, 'access', _23 => _23.wc, 'access', _24 => _24.account, 'optionalAccess', _25 => _25.address]);
+    const from = _nullishCoalesce(_optionalChain([this, 'access', _30 => _30.config, 'access', _31 => _31.walletClient, 'optionalAccess', _32 => _32.account, 'optionalAccess', _33 => _33.address]), () => ( _optionalChain([this, 'access', _34 => _34.config, 'access', _35 => _35.account, 'optionalAccess', _36 => _36.address])));
     if (!from) {
       throw new StableValidationError(
         "signer",
         void 0,
-        "earn: requires a signer \u2014 set walletClient or account in StableConfig"
+        "LI.FI: requires a signer \u2014 set walletClient or account in StableConfig"
       );
     }
     return from;
   }
-  async _switchChain() {
+  async _fetchQuote(qs) {
+    const url = `https://li.quest/v1/quote?${qs}`;
     try {
-      await this.wc.switchChain({ id: this.config.chainId });
+      return await retryWithBackoff(() => this._fetchQuoteOnce(url));
     } catch (err) {
-      if (err.code === 4001) {
-        throw new StableTransactionError({
-          phase: "switch_chain",
-          shortMessage: `earn: wallet rejected switch to chain ${this.config.chainId}`,
-          chainId: this.config.chainId,
+      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 _sendTx(to, data, value, from) {
+  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 {
-      return await this.wc.sendTransaction({ to, data, value, account: from, chain: this.chain });
+      await wc.switchChain({ id: srcChainId });
     } catch (err) {
       throw new StableTransactionError({
-        phase: "send",
-        shortMessage: "earn: transaction send failed",
-        chainId: this.config.chainId,
+        phase: "switch_chain",
+        shortMessage: `LI.FI: wallet rejected or failed to switch to chain ${srcChainId}`,
+        chainId: srcChainId,
         cause: err
       });
     }
-  }
-  async _resolveDecimals(asset, op) {
+    await this._ensureApproval(
+      wc,
+      srcChain,
+      srcRpc,
+      srcChainId,
+      from,
+      quote
+    );
+    let hash;
     try {
-      return await retryWithBackoff(
-        () => this.pc.readContract({ address: asset, abi: _viem.erc20Abi, functionName: "decimals" })
-      );
-    } catch (e4) {
-      throw new StableValidationError(
-        "tokenDecimals",
-        void 0,
-        `${op}: could not fetch decimals for asset "${asset}" \u2014 pass tokenDecimals explicitly`
-      );
+      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 };
   }
-  _withIdempotency(key, fn) {
-    if (!key) return fn();
-    const existing = this.inFlight.get(key);
-    if (existing) return existing;
-    const promise = fn().finally(() => this.inFlight.delete(key));
-    this.inFlight.set(key, promise);
-    return promise;
-  }
-  _validateAmount(amount, op) {
-    if (!Number.isFinite(amount) || amount <= 0) {
-      throw new StableValidationError("amount", amount, `${op}: amount must be a finite positive number`);
+  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
+      });
     }
-  }
-  _validateShares(shares, op) {
-    if (!Number.isFinite(shares) || shares <= 0) {
-      throw new StableValidationError("shares", shares, `${op}: shares must be a finite positive number`);
+    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 validateTransferParams({ to, amount, token, tokenDecimals }) {
+function validateTransferParams({
+  to,
+  amount,
+  token,
+  tokenDecimals
+}) {
   if (!_viem.isAddress.call(void 0, to)) {
-    throw new StableValidationError("to", to, `transfer: invalid recipient address "${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");
+    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}"`);
+    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");
+    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 (e5) {
+    return await publicClient.readContract({
+      address: token,
+      abi: _viem.erc20Abi,
+      functionName: "decimals"
+    });
+  } catch (e6) {
     throw new StableValidationError(
       "tokenDecimals",
       void 0,
@@ -1090,7 +1784,11 @@ async function executeTokenTransfer(wc, publicClient, token, to, amount, tokenDe
       `transfer: no contract found at "${token}" on chain ${chain.id} \u2014 check the address and network`
     );
   }
-  const decimals = await resolveTokenDecimals(publicClient, token, tokenDecimals);
+  const decimals = await resolveTokenDecimals(
+    publicClient,
+    token,
+    tokenDecimals
+  );
   return wc.writeContract({
     address: token,
     abi: _viem.erc20Abi,
@@ -1106,13 +1804,23 @@ function createStable({
   account,
   transport,
   walletClient,
-  earn: earnConfig
+  earn: earnConfig,
+  merklApiBase
 }) {
   const chain = network === "mainnet" /* Mainnet */ ? _chains.stable : _chains.stableTestnet;
-  const rpc = (_nullishCoalesce(rpcOverride, () => ( chain.rpcUrls.default.http[0]))).replace(/\/$/, "");
+  const rpc = (_nullishCoalesce(rpcOverride, () => ( chain.rpcUrls.default.http[0]))).replace(
+    /\/$/,
+    ""
+  );
   const signerConfig = { account, transport, walletClient };
   const lifi = new LiFiService({ ...signerConfig, rpc, chainId: chain.id });
-  const morpho = earnConfig ? new MorphoService({ ...signerConfig, rpc, chainId: chain.id, vault: earnConfig.vault }) : null;
+  const merkl = new MerklService({ ...signerConfig, rpc, chainId: chain.id, merklApiBase });
+  const morpho = earnConfig ? new MorphoService({
+    ...signerConfig,
+    rpc,
+    chainId: chain.id,
+    vault: earnConfig.vault
+  }) : null;
   function requireEarn() {
     if (!morpho) {
       throw new StableValidationError(
@@ -1123,10 +1831,21 @@ function createStable({
     }
     return morpho;
   }
+  function requireSignerAddress() {
+    const from = _nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _37 => _37.account, 'optionalAccess', _38 => _38.address]), () => ( _optionalChain([account, 'optionalAccess', _39 => _39.address])));
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "stable.rewards.*: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
+    }
+    return from;
+  }
   async function transfer(params) {
     validateTransferParams(params);
     const { from, to, amount, token, tokenDecimals } = params;
-    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _26 => _26.account]), () => ( account)), () => ( from));
+    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _40 => _40.account]), () => ( account)), () => ( from));
     const wc = _nullishCoalesce(walletClient, () => ( _viem.createWalletClient.call(void 0, {
       account: acc,
       chain,
@@ -1142,8 +1861,29 @@ function createStable({
         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 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
+    ) : (
+      // Native transfer on Stable mainnet/testnet. Native USDT0 uses 18 decimals
+      // on both networks, matching standard EVM native-token decimals.
+      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({
@@ -1168,25 +1908,38 @@ function createStable({
       bulkWithdraw: (items, options) => requireEarn().bulkWithdraw(items, options),
       redeem: (params) => requireEarn().redeem(params),
       forceWithdraw: (params) => requireEarn().forceWithdraw(params),
-      forceRedeem: (params) => requireEarn().forceRedeem(params)
+      forceRedeem: (params) => requireEarn().forceRedeem(params),
+      prepareDepositCalldata: (params) => requireEarn().prepareDepositCalldata(params),
+      prepareWithdrawCalldata: (params) => requireEarn().prepareWithdrawCalldata(params),
+      prepareRedeemCalldata: (params) => requireEarn().prepareRedeemCalldata(params),
+      incentiveRewards: {
+        fetch: () => merkl.fetchRewards(requireSignerAddress()),
+        claim: () => merkl.claim()
+      }
     }
   };
 }
 function createStableReader(config) {
   const reader = new EarnReader(config);
+  const chain = config.network === "testnet" /* Testnet */ ? _chains.stableTestnet : _chains.stable;
+  const rpc = (_nullishCoalesce(config.rpc, () => ( chain.rpcUrls.default.http[0]))).replace(/\/$/, "");
+  const merkl = new MerklService({ chainId: chain.id, rpc, merklApiBase: config.merklApiBase });
   return {
     earn: {
       getYield: () => reader.getYield(),
       position: () => reader.position(),
       preview: (params) => reader.preview(params),
-      withdrawability: (params) => reader.withdrawability(params)
+      withdrawability: (params) => reader.withdrawability(params),
+      incentiveRewards: {
+        fetch: () => merkl.fetchRewards(config.address)
+      }
     }
   };
 }
 
 // src/constants.ts
 var STABLE_USDT_ADDRESS = "0x779ded0c9e1022225f8e0630b35a9b54be713736";
-var STABLE_VAULT_ADDRESS = "0x461eF73F640456138242398a39AB48a557A49293";
+var STABLE_VAULT_ADDRESS = "0xb7Df8db22A5DBBFA9ebeb94b3910aec6a4f05c08";