@stablechain/sdk 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -126,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));
@@ -166,6 +170,7 @@ var MorphoService = class {
       })
     });
     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)
@@ -303,6 +308,109 @@ var MorphoService = class {
       () => 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"
+      );
+    }
+    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)`
+        );
+      }
+    }
+    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 tx = depositAction.buildTx(void 0);
+    steps.push({ to: tx.to, data: tx.data, value: tx.value });
+    return { steps, chainId: this.config.chainId };
+  }
+  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 };
+  }
+  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 };
+  }
   // ─── Private operations ──────────────────────────────────────────────────
   async _deposit(params) {
     const {
@@ -390,7 +498,15 @@ var MorphoService = class {
     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 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") {
@@ -416,7 +532,7 @@ var MorphoService = class {
           abi: _viem.erc20Abi,
           functionName: "decimals"
         });
-      } catch (e2) {
+      } catch (e3) {
         throw new StableValidationError(
           "shareDecimals",
           void 0,
@@ -426,7 +542,17 @@ var MorphoService = class {
     }
     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 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") {
@@ -490,7 +616,7 @@ var MorphoService = class {
           abi: _viem.erc20Abi,
           functionName: "decimals"
         });
-      } catch (e3) {
+      } catch (e4) {
         throw new StableValidationError(
           "shareDecimals",
           void 0,
@@ -523,6 +649,51 @@ var MorphoService = class {
     }
     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 (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;
+  }
+  _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;
+    }
+    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;
+    }
+    return rem;
+  }
   _buildDeallocs(deallocations, assetDecimals) {
     return deallocations.map((d) => ({
       adapter: d.adapter,
@@ -587,7 +758,7 @@ var MorphoService = class {
           functionName: "decimals"
         })
       );
-    } catch (e4) {
+    } catch (e5) {
       throw new StableValidationError(
         "tokenDecimals",
         void 0,
@@ -636,19 +807,19 @@ var MorphoService = class {
 
 
 // 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;
+var Chain = /* @__PURE__ */ ((Chain3) => {
+  Chain3["Sepolia"] = "sepolia";
+  Chain3["StableTestnet"] = "stable-testnet";
+  Chain3["Stable"] = "stable";
+  Chain3["Ethereum"] = "ethereum";
+  Chain3["Arbitrum"] = "arbitrum";
+  Chain3["Ink"] = "ink";
+  Chain3["Bera"] = "bera";
+  Chain3["MegaETH"] = "megaeth";
+  Chain3["Base"] = "base";
+  Chain3["BSC"] = "bsc";
+  Chain3["HyperEVM"] = "hyperevm";
+  return Chain3;
 })(Chain || {});
 var Network = /* @__PURE__ */ ((Network2) => {
   Network2["Mainnet"] = "mainnet";
@@ -843,6 +1014,233 @@ var EarnReader = class {
   }
 };
 
+// src/earn/merkl.ts
+
+
+
+
+
+
+
+
+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;
+  }
+  async fetchRewards(address) {
+    if (!_viem.isAddress.call(void 0, address)) {
+      throw new StableValidationError(
+        "address",
+        address,
+        `merkl: invalid address "${address}"`
+      );
+    }
+    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);
+  }
+  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 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: "switch_chain",
+        shortMessage: `merkl: wallet rejected or failed to switch to chain ${this.config.chainId}`,
+        chainId: this.config.chainId,
+        cause: err
+      });
+    }
+    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: "send",
+        shortMessage: "merkl: claim transaction failed",
+        chainId: this.config.chainId,
+        cause: err
+      });
+    }
+    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: "merkl: claim transaction reverted on-chain",
+        txHash: receipt.transactionHash,
+        chainId: this.config.chainId
+      });
+    }
+    return {
+      txHash: receipt.transactionHash,
+      tokenCount: claimable.length
+    };
+  }
+  async prepareClaimCalldata(address) {
+    if (!_viem.isAddress.call(void 0, address)) {
+      throw new StableValidationError(
+        "address",
+        address,
+        `merkl: invalid address "${address}"`
+      );
+    }
+    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
+      });
+    }
+  }
+  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
 
 
@@ -978,7 +1376,7 @@ var LiFiService = class {
       fromDecimals = 6,
       recipient
     } = params;
-    const from = _nullishCoalesce(_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]))), () => ( "0x0000000000000000000000000000000000000000"));
+    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)
@@ -1136,7 +1534,7 @@ var LiFiService = class {
     }
   }
   _requireFrom() {
-    const from = _nullishCoalesce(_optionalChain([this, 'access', _19 => _19.config, 'access', _20 => _20.walletClient, 'optionalAccess', _21 => _21.account, 'optionalAccess', _22 => _22.address]), () => ( _optionalChain([this, 'access', _23 => _23.config, '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",
@@ -1325,7 +1723,304 @@ 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/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, fromToken, toToken, amount, recipient }) {
+    const recipientAddr = _nullishCoalesce(recipient, () => ( "0x0000000000000000000000000000000000000000"));
+    this.validateBridgeParams({ fromChain, toChain, amount, recipient: recipientAddr }, "quoteBridge");
+    const { src, dst } = this.resolveChains(fromChain, toChain, fromToken, toToken);
+    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', _37 => _37.config, 'access', _38 => _38.walletClient, 'optionalAccess', _39 => _39.account, 'optionalAccess', _40 => _40.address]), () => ( _optionalChain([this, 'access', _41 => _41.config, 'access', _42 => _42.account, 'optionalAccess', _43 => _43.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, fromToken, toToken);
+    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', _44 => _44.nativeFee]) !== void 0 && _optionalChain([quote, 'optionalAccess', _45 => _45.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, fromToken, toToken) {
+    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}"`);
+    }
+    if (fromToken.toLowerCase() !== src.usdt.toLowerCase()) {
+      throw new StableValidationError(
+        "fromToken",
+        fromToken,
+        `USDT0 bridge only moves USDT0 \u2014 fromToken must be ${src.usdt} on "${fromChain}", got "${fromToken}". Use route "lifi" to bridge other tokens.`
+      );
+    }
+    if (toToken.toLowerCase() !== dst.usdt.toLowerCase()) {
+      throw new StableValidationError(
+        "toToken",
+        toToken,
+        `USDT0 bridge only moves USDT0 \u2014 toToken must be ${dst.usdt} on "${toChain}", got "${toToken}". Use route "lifi" to bridge other tokens.`
+      );
+    }
+    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/stable.ts
+function isUsdt0Route(fromChain, toChain, fromToken, toToken) {
+  const src = BRIDGE_CHAIN_CONFIGS[fromChain];
+  const dst = BRIDGE_CHAIN_CONFIGS[toChain];
+  return !!src && !!dst && !!src.oftAdapter && src.lzOutbound !== false && src.usdt.toLowerCase() === fromToken.toLowerCase() && dst.usdt.toLowerCase() === toToken.toLowerCase();
+}
+function selectBridge(params) {
+  const route = _nullishCoalesce(params.route, () => ( "auto"));
+  if (route === "usdt0") return "usdt0";
+  if (route === "lifi") return "lifi";
+  return isUsdt0Route(
+    params.fromChain,
+    params.toChain,
+    params.fromToken,
+    params.toToken
+  ) ? "usdt0" : "lifi";
+}
 function validateTransferParams({
   to,
   amount,
@@ -1369,7 +2064,7 @@ async function resolveTokenDecimals(publicClient, token, tokenDecimals) {
       abi: _viem.erc20Abi,
       functionName: "decimals"
     });
-  } catch (e5) {
+  } catch (e6) {
     throw new StableValidationError(
       "tokenDecimals",
       void 0,
@@ -1406,7 +2101,8 @@ 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(
@@ -1415,6 +2111,8 @@ function createStable({
   );
   const signerConfig = { account, transport, walletClient };
   const lifi = new LiFiService({ ...signerConfig, rpc, chainId: chain.id });
+  const lz = new LayerZeroService(signerConfig);
+  const merkl = new MerklService({ ...signerConfig, rpc, chainId: chain.id, merklApiBase });
   const morpho = earnConfig ? new MorphoService({
     ...signerConfig,
     rpc,
@@ -1431,10 +2129,21 @@ function createStable({
     }
     return morpho;
   }
+  function requireSignerAddress() {
+    const from = _nullishCoalesce(_optionalChain([walletClient, 'optionalAccess', _46 => _46.account, 'optionalAccess', _47 => _47.address]), () => ( _optionalChain([account, 'optionalAccess', _48 => _48.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', _49 => _49.account]), () => ( account)), () => ( from));
     const wc = _nullishCoalesce(walletClient, () => ( _viem.createWalletClient.call(void 0, {
       account: acc,
       chain,
@@ -1486,8 +2195,8 @@ function createStable({
   }
   return {
     transfer,
-    quoteBridge: (params) => lifi.quoteBridge(params),
-    bridge: (params) => lifi.bridge(params),
+    quoteBridge: (params) => selectBridge(params) === "usdt0" ? lz.quoteBridge(params) : lifi.quoteBridge(params),
+    bridge: (params) => selectBridge(params) === "usdt0" ? lz.bridge(params) : lifi.bridge(params),
     quoteSwap: (params) => lifi.quoteSwap(params),
     swap: (params) => lifi.swap(params),
     earn: {
@@ -1497,25 +2206,39 @@ 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";
+
 
 
 
@@ -1530,4 +2253,4 @@ var STABLE_VAULT_ADDRESS = "0x461eF73F640456138242398a39AB48a557A49293";
 
 
 
-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;
+exports.BRIDGE_CHAIN_CONFIGS = BRIDGE_CHAIN_CONFIGS; 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;