@stablechain/sdk 0.1.0 → 1.0.0

package/dist/index.cjs

@@ -9,6 +9,18 @@
 var _viem = require('viem');
 var _chains = require('viem/chains');
 
+// src/earn/reader.ts
+
+
+
+
+
+
+
+
+
+var _morphosdk = require('@morpho-org/morpho-sdk');
+
 // src/errors.ts
 
 var StableError = class extends _viem.BaseError {
@@ -67,6 +79,14 @@ var StableNetworkError = class extends StableError {
     this.url = args.url;
   }
 };
+var StableBulkError = class extends StableError {
+  constructor(args) {
+    super(args.shortMessage, { name: "StableBulkError" });
+    this.results = args.results;
+    this.succeeded = args.succeeded;
+    this.failed = args.failed;
+  }
+};
 function formatValue(v) {
   if (typeof v === "bigint") return `${v}n`;
   if (typeof v === "string") return JSON.stringify(v);
@@ -79,19 +99,6 @@ function formatValue(v) {
   }
 }
 
-// src/services/layerzero.ts
-
-
-
-
-
-
-
-
-
-
-
-
 // src/helpers/chain.ts
 
 function makeChain(id, rpc) {
@@ -103,6 +110,38 @@ function makeChain(id, rpc) {
   });
 }
 
+// src/helpers/retry.ts
+var HttpError = class extends Error {
+  constructor(message, status, retryable) {
+    super(message);
+    this.status = status;
+    this.retryable = retryable;
+    this.name = "HttpError";
+  }
+};
+function isRetryableError(err) {
+  if (err instanceof HttpError) return err.retryable;
+  return err instanceof TypeError;
+}
+async function retryWithBackoff(fn, isRetryable = isRetryableError, opts = {}) {
+  const maxAttempts = _nullishCoalesce(opts.maxAttempts, () => ( 3));
+  const base = _nullishCoalesce(opts.baseDelayMs, () => ( 250));
+  const max = _nullishCoalesce(opts.maxDelayMs, () => ( 4e3));
+  let lastErr;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt === maxAttempts - 1 || !isRetryable(err)) throw err;
+      const delay = Math.min(max, base * 2 ** attempt);
+      const jittered = delay * (0.75 + Math.random() * 0.5);
+      await new Promise((r) => setTimeout(r, jittered));
+    }
+  }
+  throw lastErr;
+}
+
 // src/types.ts
 var Chain = /* @__PURE__ */ ((Chain2) => {
   Chain2["Sepolia"] = "sepolia";
@@ -124,6 +163,156 @@ var Network = /* @__PURE__ */ ((Network2) => {
   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', _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)) {
+      throw new StableValidationError(
+        "earn.vault",
+        config.earn.vault,
+        `createStableReader: invalid vault address "${config.earn.vault}"`
+      );
+    }
+    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);
+  }
+  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 preview(params) {
+    const { amount, horizonDays } = params;
+    const apy = await this._fetchNetApy();
+    return {
+      projectedYield: amount * apy * (horizonDays / 365),
+      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"
+    })));
+    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
+    };
+  }
+  async _fetchNetApy() {
+    const query = `
+      query VaultNetApy($address: String!, $chainId: Int!) {
+        vaultV2ByAddress(address: $address, chainId: $chainId) {
+          netApy
+        }
+      }
+    `;
+    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 preview: 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) {
+      if (err instanceof TypeError || err instanceof HttpError) {
+        throw new StableNetworkError({
+          shortMessage: err instanceof HttpError ? `earn preview: Morpho API returned ${err.status} after retries` : `earn preview: failed to reach Morpho API after retries \u2014 ${String(err)}`,
+          url: MORPHO_API_URL,
+          cause: err
+        });
+      }
+      throw err;
+    }
+    const netApy = _optionalChain([body, 'optionalAccess', _4 => _4.data, 'optionalAccess', _5 => _5.vaultV2ByAddress, 'optionalAccess', _6 => _6.netApy]);
+    if (typeof netApy !== "number") {
+      throw new StableValidationError(
+        "apy",
+        void 0,
+        "earn preview: vault not found in Morpho API or unexpected response shape"
+      );
+    }
+    return netApy;
+  }
+};
+
+// src/services/lifi.ts
+
+
+
+
+
+
+
+
+
+
 // src/chains.ts
 var CHAIN_CONFIGS = {
   // ─── Testnet ──────────────────────────────────────────────────────────────
@@ -196,305 +385,6 @@ var CHAIN_CONFIGS = {
   }
 };
 
-// src/services/layerzero.ts
-var C = CHAIN_CONFIGS;
-var BRIDGE_CHAIN_CONFIGS = {
-  // ─── Testnet ───────────────────────────────────────────────────────────────
-  ["sepolia" /* Sepolia */]: { ...C["sepolia" /* Sepolia */], lzEid: 40161, oftAdapter: "0xc099cD946d5efCC35A99D64E808c1430cEf08126" },
-  ["stable-testnet" /* StableTestnet */]: { ...C["stable-testnet" /* StableTestnet */], lzEid: 40374, oftAdapter: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736" },
-  // ─── Mainnet ──────────────────────────────────────────────────────────────
-  ["stable" /* Stable */]: { ...C["stable" /* Stable */], lzEid: 30396, oftAdapter: "0xedaba024be4d87974d5aB11C6Dd586963CcCB027" },
-  ["ethereum" /* Ethereum */]: { ...C["ethereum" /* Ethereum */], lzEid: 30101, oftAdapter: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee" },
-  ["arbitrum" /* Arbitrum */]: { ...C["arbitrum" /* Arbitrum */], lzEid: 30110, oftAdapter: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92" },
-  ["ink" /* Ink */]: { ...C["ink" /* Ink */], lzEid: 30339, oftAdapter: "0x1cB6De532588fCA4a21B7209DE7C456AF8434A65" },
-  ["bera" /* Bera */]: { ...C["bera" /* Bera */], lzEid: 30362, oftAdapter: "0x3Dc96399109df5ceb2C226664A086140bD0379cB" },
-  ["megaeth" /* MegaETH */]: { ...C["megaeth" /* MegaETH */], lzEid: 30398, oftAdapter: "0x9151434b16b9763660705744891fa906f660ecc5" },
-  ["hyperevm" /* HyperEVM */]: { ...C["hyperevm" /* HyperEVM */], lzEid: 30367, oftAdapter: "0x904861a24F30EC96ea7CFC3bE9EA4B476d237e98" }
-};
-var OFT_ADAPTER_ABI = [
-  {
-    name: "quoteSend",
-    type: "function",
-    inputs: [
-      {
-        name: "_sendParam",
-        type: "tuple",
-        components: [
-          { name: "dstEid", type: "uint32" },
-          { name: "to", type: "bytes32" },
-          { name: "amountLD", type: "uint256" },
-          { name: "minAmountLD", type: "uint256" },
-          { name: "extraOptions", type: "bytes" },
-          { name: "composeMsg", type: "bytes" },
-          { name: "oftCmd", type: "bytes" }
-        ]
-      },
-      { name: "_payInLzToken", type: "bool" }
-    ],
-    outputs: [
-      {
-        name: "msgFee",
-        type: "tuple",
-        components: [
-          { name: "nativeFee", type: "uint256" },
-          { name: "lzTokenFee", type: "uint256" }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    name: "send",
-    type: "function",
-    inputs: [
-      {
-        name: "_sendParam",
-        type: "tuple",
-        components: [
-          { name: "dstEid", type: "uint32" },
-          { name: "to", type: "bytes32" },
-          { name: "amountLD", type: "uint256" },
-          { name: "minAmountLD", type: "uint256" },
-          { name: "extraOptions", type: "bytes" },
-          { name: "composeMsg", type: "bytes" },
-          { name: "oftCmd", type: "bytes" }
-        ]
-      },
-      {
-        name: "_fee",
-        type: "tuple",
-        components: [
-          { name: "nativeFee", type: "uint256" },
-          { name: "lzTokenFee", type: "uint256" }
-        ]
-      },
-      { name: "_refundAddress", type: "address" }
-    ],
-    outputs: [],
-    stateMutability: "payable"
-  }
-];
-function buildLzOptions(gasLimit = 0n) {
-  return _viem.concat.call(void 0, [
-    _viem.numberToHex.call(void 0, 3, { size: 2 }),
-    // TYPE_3 header
-    _viem.numberToHex.call(void 0, 1, { size: 1 }),
-    // Executor worker ID
-    _viem.numberToHex.call(void 0, 17, { size: 2 }),
-    // option payload length = 17 bytes
-    _viem.numberToHex.call(void 0, 1, { size: 1 }),
-    // LzReceive option type
-    _viem.numberToHex.call(void 0, gasLimit, { size: 16 })
-    // gas limit as uint128
-  ]);
-}
-var LayerZeroService = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async quoteBridge({ fromChain, toChain, amount, recipient }) {
-    const recipientAddr = _nullishCoalesce(recipient, () => ( "0x0000000000000000000000000000000000000000"));
-    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "quoteBridge");
-    const { src, dst } = this.resolveChains(fromChain, toChain);
-    const oftAdapter = src.oftAdapter;
-    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
-    try {
-      const { nativeFee, lzTokenFee } = await _viem.createPublicClient.call(void 0, {
-        chain: makeChain(src.id, src.rpc),
-        transport: _viem.http.call(void 0, src.rpc)
-      }).readContract({
-        address: oftAdapter,
-        abi: OFT_ADAPTER_ABI,
-        functionName: "quoteSend",
-        args: [this.buildSendParams(dst, amountLD, recipientAddr), false]
-      });
-      return { nativeFee, lzTokenFee, toAmount: amount };
-    } catch (err) {
-      throw new StableQuoteError({
-        provider: "layerzero",
-        shortMessage: "quoteBridge: quoteSend call failed",
-        cause: err
-      });
-    }
-  }
-  async bridge({ fromChain, toChain, fromToken, toToken, amount, recipient, quote }) {
-    const from = _nullishCoalesce(_optionalChain([this, 'access', _2 => _2.config, 'access', _3 => _3.walletClient, 'optionalAccess', _4 => _4.account, 'optionalAccess', _5 => _5.address]), () => ( _optionalChain([this, 'access', _6 => _6.config, 'access', _7 => _7.account, 'optionalAccess', _8 => _8.address])));
-    if (!from) {
-      throw new StableValidationError(
-        "signer",
-        void 0,
-        "bridge: requires a signer \u2014 set walletClient or account in StableConfig"
-      );
-    }
-    const recipientAddr = _nullishCoalesce(recipient, () => ( from));
-    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "bridge");
-    const { src, dst } = this.resolveChains(fromChain, toChain);
-    const oftAdapter = src.oftAdapter;
-    const srcChain = makeChain(src.id, src.rpc);
-    const wc = _nullishCoalesce(this.config.walletClient, () => ( _viem.createWalletClient.call(void 0, {
-      account: this.config.account,
-      chain: srcChain,
-      transport: _nullishCoalesce(this.config.transport, () => ( _viem.http.call(void 0, src.rpc)))
-    })));
-    const pc = _viem.createPublicClient.call(void 0, { chain: srcChain, transport: _viem.http.call(void 0, src.rpc) });
-    try {
-      await wc.switchChain({ id: src.id });
-    } catch (err) {
-      throw new StableTransactionError({
-        phase: "switch_chain",
-        shortMessage: `bridge: wallet rejected or failed to switch to chain ${src.id}`,
-        chainId: src.id,
-        cause: err
-      });
-    }
-    const amountLD = _viem.parseUnits.call(void 0, String(amount), src.decimals);
-    const sendParams = this.buildSendParams(dst, amountLD, recipientAddr);
-    const lzFee = _optionalChain([quote, 'optionalAccess', _9 => _9.nativeFee]) !== void 0 && _optionalChain([quote, 'optionalAccess', _10 => _10.lzTokenFee]) !== void 0 ? { nativeFee: quote.nativeFee, lzTokenFee: quote.lzTokenFee } : await this.quoteBridge({ fromChain, toChain, fromToken, toToken, amount, recipient: recipientAddr });
-    const { nativeFee = 0n, lzTokenFee = 0n } = lzFee;
-    const allowance = await pc.readContract({
-      address: src.usdt,
-      abi: _viem.erc20Abi,
-      functionName: "allowance",
-      args: [from, oftAdapter]
-    });
-    if (allowance < amountLD) {
-      let approveHash;
-      try {
-        approveHash = await wc.writeContract({
-          address: src.usdt,
-          abi: _viem.erc20Abi,
-          functionName: "approve",
-          args: [oftAdapter, amountLD],
-          account: wc.account,
-          chain: srcChain
-        });
-      } catch (err) {
-        throw new StableTransactionError({
-          phase: "approve",
-          shortMessage: "bridge: USDT0 approve failed",
-          chainId: src.id,
-          cause: err
-        });
-      }
-      const approveReceipt = await pc.waitForTransactionReceipt({ hash: approveHash });
-      if (approveReceipt.status === "reverted") {
-        throw new StableTransactionError({
-          phase: "approve",
-          shortMessage: "bridge: USDT0 approve reverted on-chain",
-          txHash: approveReceipt.transactionHash,
-          chainId: src.id
-        });
-      }
-    }
-    try {
-      const hash = await wc.writeContract({
-        address: oftAdapter,
-        abi: OFT_ADAPTER_ABI,
-        functionName: "send",
-        args: [sendParams, { nativeFee, lzTokenFee }, from],
-        value: nativeFee,
-        account: wc.account,
-        chain: srcChain
-      });
-      return { txHash: hash, toAmount: amount };
-    } catch (err) {
-      throw new StableTransactionError({
-        phase: "send",
-        shortMessage: "bridge: OFT send failed",
-        chainId: src.id,
-        cause: err
-      });
-    }
-  }
-  validateBridgeParams(params, method) {
-    if (!_viem.isAddress.call(void 0, params.recipient)) {
-      throw new StableValidationError(
-        "recipient",
-        params.recipient,
-        `${method}: invalid recipient address "${params.recipient}"`
-      );
-    }
-    if (!Number.isFinite(params.amount) || params.amount <= 0) {
-      throw new StableValidationError(
-        "amount",
-        params.amount,
-        `${method}: amount must be a finite positive number`
-      );
-    }
-    if (params.fromChain === params.toChain) {
-      throw new StableValidationError(
-        "toChain",
-        params.toChain,
-        `${method}: fromChain and toChain must differ`
-      );
-    }
-  }
-  resolveChains(fromChain, toChain) {
-    const src = BRIDGE_CHAIN_CONFIGS[fromChain];
-    const dst = BRIDGE_CHAIN_CONFIGS[toChain];
-    if (!src) throw new StableValidationError("fromChain", fromChain, `Unsupported source chain: "${fromChain}"`);
-    if (!dst) throw new StableValidationError("toChain", toChain, `Unsupported destination chain: "${toChain}"`);
-    if (!src.oftAdapter) {
-      throw new StableValidationError("fromChain", fromChain, `No OFT adapter configured for "${fromChain}"`);
-    }
-    return { src, dst };
-  }
-  buildSendParams(dst, amountLD, recipient) {
-    return {
-      dstEid: dst.lzEid,
-      to: _viem.padHex.call(void 0, recipient, { dir: "left", size: 32 }),
-      amountLD,
-      minAmountLD: amountLD,
-      extraOptions: buildLzOptions(),
-      composeMsg: "0x",
-      oftCmd: "0x"
-    };
-  }
-};
-
-// src/services/lifi.ts
-
-
-
-
-
-
-
-
-
-
-// src/helpers/retry.ts
-var HttpError = class extends Error {
-  constructor(message, status, retryable) {
-    super(message);
-    this.status = status;
-    this.retryable = retryable;
-    this.name = "HttpError";
-  }
-};
-function isRetryableError(err) {
-  if (err instanceof HttpError) return err.retryable;
-  return err instanceof TypeError;
-}
-async function retryWithBackoff(fn, isRetryable = isRetryableError, opts = {}) {
-  const maxAttempts = _nullishCoalesce(opts.maxAttempts, () => ( 3));
-  const base = _nullishCoalesce(opts.baseDelayMs, () => ( 250));
-  const max = _nullishCoalesce(opts.maxDelayMs, () => ( 4e3));
-  let lastErr;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (attempt === maxAttempts - 1 || !isRetryable(err)) throw err;
-      const delay = Math.min(max, base * 2 ** attempt);
-      const jittered = delay * (0.75 + Math.random() * 0.5);
-      await new Promise((r) => setTimeout(r, jittered));
-    }
-  }
-  throw lastErr;
-}
-
 // src/services/lifi.ts
 var LiFiService = class {
   constructor(config) {
@@ -526,7 +416,7 @@ var LiFiService = class {
   async quoteBridge(params) {
     this._validateBridgeParams(params);
     const { fromChain, toChain, fromToken, toToken, amount, fromDecimals = 6, recipient } = params;
-    const from = _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _11 => _11.config, 'access', _12 => _12.walletClient, 'optionalAccess', _13 => _13.account, 'optionalAccess', _14 => _14.address]), () => ( _optionalChain([this, 'access', _15 => _15.config, 'access', _16 => _16.account, 'optionalAccess', _17 => _17.address]))), () => ( "0x0000000000000000000000000000000000000000"));
+    const from = _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _7 => _7.config, 'access', _8 => _8.walletClient, 'optionalAccess', _9 => _9.account, 'optionalAccess', _10 => _10.address]), () => ( _optionalChain([this, 'access', _11 => _11.config, 'access', _12 => _12.account, 'optionalAccess', _13 => _13.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}"`);
@@ -603,7 +493,7 @@ var LiFiService = class {
     }
   }
   _requireFrom() {
-    const from = _nullishCoalesce(_optionalChain([this, 'access', _18 => _18.config, 'access', _19 => _19.walletClient, 'optionalAccess', _20 => _20.account, 'optionalAccess', _21 => _21.address]), () => ( _optionalChain([this, 'access', _22 => _22.config, 'access', _23 => _23.account, 'optionalAccess', _24 => _24.address])));
+    const from = _nullishCoalesce(_optionalChain([this, 'access', _14 => _14.config, 'access', _15 => _15.walletClient, 'optionalAccess', _16 => _16.account, 'optionalAccess', _17 => _17.address]), () => ( _optionalChain([this, 'access', _18 => _18.config, 'access', _19 => _19.account, 'optionalAccess', _20 => _20.address])));
     if (!from) {
       throw new StableValidationError(
         "signer",
@@ -771,12 +661,335 @@ function isLiFiQuoteShape(v) {
   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
+
+
+
+
+
+
+
+
+
+
+
+
+
+var MorphoService = 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', _21 => _21.wc, 'access', _22 => _22.chain, 'optionalAccess', _23 => _23.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");
+    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);
+  }
+  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));
+  }
+  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 } = 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);
+    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);
+      }
+    }
+    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 _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") {
+      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 _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 });
+    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 _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");
+    }
+    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
+      });
+    }
+    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`
+        );
+      }
+    }
+    let assetDec = tokenDecimals;
+    if (assetDec === void 0) {
+      const vaultData = await vault.getData();
+      assetDec = await this._resolveDecimals(vaultData.asset, "earn forceRedeem");
+    }
+    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
+      });
+    }
+    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 }
+    }));
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────
+  _requireFrom() {
+    const from = _optionalChain([this, 'access', _24 => _24.wc, 'access', _25 => _25.account, 'optionalAccess', _26 => _26.address]);
+    if (!from) {
+      throw new StableValidationError(
+        "signer",
+        void 0,
+        "earn: requires a signer \u2014 set walletClient or account in StableConfig"
+      );
+    }
+    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
+        });
+      }
+    }
+  }
+  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 (e4) {
+      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`);
+    }
+  }
+  _validateShares(shares, op) {
+    if (!Number.isFinite(shares) || shares <= 0) {
+      throw new StableValidationError("shares", shares, `${op}: shares must be a finite positive number`);
+    }
+  }
+};
+
 // src/stable.ts
-function isUsdt0Route(fromChain, toChain, fromToken, toToken) {
-  const src = BRIDGE_CHAIN_CONFIGS[fromChain];
-  const dst = BRIDGE_CHAIN_CONFIGS[toChain];
-  return !!src && !!dst && src.lzOutbound !== false && src.usdt.toLowerCase() === fromToken.toLowerCase() && dst.usdt.toLowerCase() === toToken.toLowerCase();
-}
 function validateTransferParams({ to, amount, token, tokenDecimals }) {
   if (!_viem.isAddress.call(void 0, to)) {
     throw new StableValidationError("to", to, `transfer: invalid recipient address "${to}"`);
@@ -795,7 +1008,7 @@ async function resolveTokenDecimals(publicClient, token, tokenDecimals) {
   if (tokenDecimals !== void 0) return tokenDecimals;
   try {
     return await publicClient.readContract({ address: token, abi: _viem.erc20Abi, functionName: "decimals" });
-  } catch (e2) {
+  } catch (e5) {
     throw new StableValidationError(
       "tokenDecimals",
       void 0,
@@ -827,17 +1040,28 @@ function createStable({
   rpc: rpcOverride,
   account,
   transport,
-  walletClient
+  walletClient,
+  earn: earnConfig
 }) {
   const chain = network === "mainnet" /* Mainnet */ ? _chains.stable : _chains.stableTestnet;
   const rpc = (_nullishCoalesce(rpcOverride, () => ( chain.rpcUrls.default.http[0]))).replace(/\/$/, "");
   const signerConfig = { account, transport, walletClient };
-  const lz = new LayerZeroService(signerConfig);
   const lifi = new LiFiService({ ...signerConfig, rpc, chainId: chain.id });
+  const morpho = earnConfig ? new MorphoService({ ...signerConfig, rpc, chainId: chain.id, vault: earnConfig.vault }) : null;
+  function requireEarn() {
+    if (!morpho) {
+      throw new StableValidationError(
+        "earn",
+        void 0,
+        "stable.earn.*: pass earn: { vault: '0x...' } to createStable() to enable earn operations"
+      );
+    }
+    return morpho;
+  }
   async function transfer(params) {
     validateTransferParams(params);
     const { from, to, amount, token, tokenDecimals } = params;
-    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _25 => _25.account]), () => ( account)), () => ( from));
+    const acc = _nullishCoalesce(_nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _27 => _27.account]), () => ( account)), () => ( from));
     const wc = _nullishCoalesce(walletClient, () => ( _viem.createWalletClient.call(void 0, {
       account: acc,
       chain,
@@ -866,21 +1090,41 @@ function createStable({
     }
     return { txHash: receipt.transactionHash };
   }
-  function quoteBridge(params) {
-    return isUsdt0Route(params.fromChain, params.toChain, params.fromToken, params.toToken) ? lz.quoteBridge(params) : lifi.quoteBridge(params);
-  }
-  function bridge(params) {
-    return isUsdt0Route(params.fromChain, params.toChain, params.fromToken, params.toToken) ? lz.bridge(params) : lifi.bridge(params);
-  }
   return {
     transfer,
-    quoteBridge,
-    bridge,
+    quoteBridge: (params) => lifi.quoteBridge(params),
+    bridge: (params) => lifi.bridge(params),
     quoteSwap: (params) => lifi.quoteSwap(params),
-    swap: (params) => lifi.swap(params)
+    swap: (params) => lifi.swap(params),
+    earn: {
+      deposit: (params) => requireEarn().deposit(params),
+      bulkDeposit: (items, options) => requireEarn().bulkDeposit(items, options),
+      withdraw: (params) => requireEarn().withdraw(params),
+      redeem: (params) => requireEarn().redeem(params),
+      forceWithdraw: (params) => requireEarn().forceWithdraw(params),
+      forceRedeem: (params) => requireEarn().forceRedeem(params)
+    }
+  };
+}
+function createStableReader(config) {
+  const reader = new EarnReader(config);
+  return {
+    earn: {
+      position: () => reader.position(),
+      preview: (params) => reader.preview(params),
+      withdrawability: (params) => reader.withdrawability(params)
+    }
   };
 }
 
+// src/constants.ts
+var STABLE_USDT_ADDRESS = "0x779ded0c9e1022225f8e0630b35a9b54be713736";
+var STABLE_VAULT_ADDRESS = "0x461eF73F640456138242398a39AB48a557A49293";
+
+
+
+
+
 
 
 
@@ -890,4 +1134,4 @@ function createStable({
 
 
 
-exports.CHAIN_CONFIGS = CHAIN_CONFIGS; exports.Chain = Chain; exports.Network = Network; exports.StableError = StableError; exports.StableNetworkError = StableNetworkError; exports.StableQuoteError = StableQuoteError; exports.StableTransactionError = StableTransactionError; exports.StableValidationError = StableValidationError; exports.createStable = createStable;
+exports.CHAIN_CONFIGS = CHAIN_CONFIGS; exports.Chain = Chain; exports.Network = Network; exports.STABLE_USDT_ADDRESS = STABLE_USDT_ADDRESS; exports.STABLE_VAULT_ADDRESS = STABLE_VAULT_ADDRESS; exports.StableBulkError = StableBulkError; exports.StableError = StableError; exports.StableNetworkError = StableNetworkError; exports.StableQuoteError = StableQuoteError; exports.StableTransactionError = StableTransactionError; exports.StableValidationError = StableValidationError; exports.createStable = createStable; exports.createStableReader = createStableReader;