@agentlayer.tech/wallet 0.1.44 → 0.1.48

package/wdk-evm-wallet/src/wdk_evm_wallet.js

@@ -1,7 +1,9 @@
 import crypto from "node:crypto";
 
 import { Contract, Interface } from "ethers";
+import { isRequirementApproval, isRequirementAuthorization } from "@morpho-org/morpho-sdk";
 import WDK from "@tetherto/wdk";
+import MorphoProtocolEvm from "@morpho-org/wdk-protocol-lending-morpho-evm";
 import { AaveV3Base, AaveV3Ethereum } from "@bgd-labs/aave-address-book";
 import AaveProtocolEvm from "@tetherto/wdk-protocol-lending-aave-evm";
 import VeloraProtocolEvm from "@tetherto/wdk-protocol-swap-velora-evm";
@@ -71,9 +73,13 @@ const LIDO_WITHDRAWAL_QUEUE_ABI = [
   "function getWithdrawalStatus(uint256[] _requestIds) view returns ((uint256 amountOfStETH,uint256 amountOfShares,address owner,uint256 timestamp,bool isFinalized,bool isClaimed)[] statuses)",
   "function claimWithdrawal(uint256 _requestId)",
 ];
+const MORPHO_AUTHORIZATION_ABI = [
+  "function setAuthorization(address authorized, bool isAuthorized)",
+];
 const LIDO_WSTETH_INTERFACE = new Interface(LIDO_WSTETH_ABI);
 const LIDO_REFERRAL_STAKER_INTERFACE = new Interface(LIDO_REFERRAL_STAKER_ABI);
 const LIDO_WITHDRAWAL_QUEUE_INTERFACE = new Interface(LIDO_WITHDRAWAL_QUEUE_ABI);
+const MORPHO_AUTHORIZATION_INTERFACE = new Interface(MORPHO_AUTHORIZATION_ABI);
 const LIFI_CHAIN_IDS_BY_NETWORK = {
   ethereum: "1",
   base: "8453",
@@ -88,6 +94,346 @@ const LIFI_CHAIN_ALIASES = {
   sol: "1151111081099710",
   solana: "1151111081099710",
 };
+const MORPHO_DEFAULT_LIST_LIMIT = 100;
+const MORPHO_MAX_LIST_LIMIT = 500;
+const MORPHO_VAULT_LIST_QUERY = `
+  query MorphoVaultV2List($first: Int!, $where: VaultV2sFilters, $orderBy: VaultV2OrderBy, $orderDirection: OrderDirection) {
+    vaultV2s(first: $first, where: $where, orderBy: $orderBy, orderDirection: $orderDirection) {
+      items {
+        address
+        symbol
+        name
+        listed
+        totalAssets
+        totalAssetsUsd
+        totalSupply
+        liquidity
+        liquidityUsd
+        idleAssets
+        idleAssetsUsd
+        sharePrice
+        avgNetApy
+        avgNetApyExcludingRewards
+        performanceFee
+        managementFee
+        maxRate
+        warnings {
+          type
+          level
+        }
+        asset {
+          id
+          address
+          decimals
+          symbol
+          name
+          priceUsd
+          yield {
+            apr
+            lookback
+          }
+        }
+        chain {
+          id
+          network
+        }
+        rewards {
+          supplyApr
+          asset {
+            address
+            symbol
+            chain {
+              id
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const MORPHO_VAULT_BY_ADDRESS_QUERY = `
+  query MorphoVaultV2ByAddress($address: String!, $chainId: Int!) {
+    vaultV2ByAddress(address: $address, chainId: $chainId) {
+      address
+      symbol
+      name
+      listed
+      totalAssets
+      totalAssetsUsd
+      totalSupply
+      liquidity
+      liquidityUsd
+      idleAssets
+      idleAssetsUsd
+      sharePrice
+      avgNetApy
+      avgNetApyExcludingRewards
+      performanceFee
+      managementFee
+      maxRate
+      metadata {
+        description
+        image
+      }
+      warnings {
+        type
+        level
+      }
+      asset {
+        id
+        address
+        decimals
+        symbol
+        name
+        priceUsd
+        yield {
+          apr
+          lookback
+        }
+      }
+      chain {
+        id
+        network
+      }
+      rewards {
+        supplyApr
+        asset {
+          address
+          symbol
+          chain {
+            id
+          }
+        }
+      }
+      adapters(first: 20) {
+        items {
+          __typename
+          address
+          type
+          assets
+          assetsUsd
+          ... on MorphoMarketV1Adapter {
+            positions(first: 50) {
+              items {
+                market {
+                  marketId
+                  collateralAsset {
+                    symbol
+                    address
+                  }
+                  loanAsset {
+                    symbol
+                    address
+                  }
+                }
+                state {
+                  supplyAssets
+                  supplyAssetsUsd
+                }
+              }
+            }
+          }
+          ... on MetaMorphoAdapter {
+            metaMorpho {
+              address
+              name
+              symbol
+            }
+          }
+          ... on MorphoVaultV2Adapter {
+            innerVault {
+              address
+              name
+              symbol
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const MORPHO_MARKET_LIST_QUERY = `
+  query MorphoMarketList($first: Int!, $where: MarketFilters, $orderBy: MarketOrderBy, $orderDirection: OrderDirection) {
+    markets(first: $first, where: $where, orderBy: $orderBy, orderDirection: $orderDirection) {
+      items {
+        marketId
+        lltv
+        irmAddress
+        warnings {
+          type
+          level
+        }
+        oracle {
+          address
+          type
+        }
+        loanAsset {
+          address
+          symbol
+          decimals
+          name
+          priceUsd
+        }
+        collateralAsset {
+          address
+          symbol
+          decimals
+          name
+          priceUsd
+        }
+        state {
+          collateralAssets
+          collateralAssetsUsd
+          borrowAssets
+          borrowAssetsUsd
+          supplyAssets
+          supplyAssetsUsd
+          liquidityAssets
+          liquidityAssetsUsd
+          borrowApy
+          avgBorrowApy
+          avgNetBorrowApy
+          supplyApy
+          avgSupplyApy
+          avgNetSupplyApy
+          fee
+          utilization
+          rewards {
+            supplyApr
+            borrowApr
+            asset {
+              address
+              symbol
+              chain {
+                id
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const MORPHO_MARKET_BY_ID_QUERY = `
+  query MorphoMarketById($marketId: String!, $chainId: Int!) {
+    marketById(marketId: $marketId, chainId: $chainId) {
+      marketId
+      lltv
+      irmAddress
+      warnings {
+        type
+        level
+      }
+      oracle {
+        address
+        type
+      }
+      loanAsset {
+        address
+        symbol
+        decimals
+        name
+        priceUsd
+      }
+      collateralAsset {
+        address
+        symbol
+        decimals
+        name
+        priceUsd
+      }
+      state {
+        collateralAssets
+        collateralAssetsUsd
+        borrowAssets
+        borrowAssetsUsd
+        supplyAssets
+        supplyAssetsUsd
+        liquidityAssets
+        liquidityAssetsUsd
+        borrowApy
+        avgBorrowApy
+        avgNetBorrowApy
+        supplyApy
+        avgSupplyApy
+        avgNetSupplyApy
+        fee
+        utilization
+        rewards {
+          supplyApr
+          borrowApr
+          asset {
+            address
+            symbol
+            chain {
+              id
+            }
+          }
+        }
+      }
+      supplyingVaults {
+        address
+        name
+        symbol
+      }
+      supplyingVaultV2s {
+        address
+        name
+        symbol
+      }
+    }
+  }
+`;
+const MORPHO_USER_OVERVIEW_QUERY = `
+  query MorphoUserByAddress($address: String!, $chainId: Int!) {
+    userByAddress(address: $address, chainId: $chainId) {
+      address
+      marketPositions {
+        market {
+          marketId
+          loanAsset {
+            address
+            symbol
+            decimals
+            name
+          }
+          collateralAsset {
+            address
+            symbol
+            decimals
+            name
+          }
+        }
+        state {
+          supplyShares
+          supplyAssets
+          supplyAssetsUsd
+          borrowShares
+          borrowAssets
+          borrowAssetsUsd
+          collateral
+          collateralUsd
+        }
+      }
+      vaultV2Positions {
+        vault {
+          address
+          name
+          symbol
+          asset {
+            address
+            symbol
+            decimals
+            name
+          }
+        }
+        shares
+        assets
+        assetsUsd
+      }
+    }
+  }
+`;
 
 function createTaggedError(message, code, details = {}) {
   const error = new Error(message);
@@ -209,6 +555,136 @@ function assertLidoSupportedNetwork(network) {
   }
 }
 
+function assertMorphoSupportedNetwork(network) {
+  if (!["ethereum", "base"].includes(network)) {
+    throw new Error("Morpho is currently supported only on ethereum and base mainnet.");
+  }
+}
+
+function normalizeMorphoListLimit(value) {
+  if (value === undefined || value === null || value === "") {
+    return MORPHO_DEFAULT_LIST_LIMIT;
+  }
+  const limit = assertNonNegativeInteger(value, "limit");
+  if (limit < 1 || limit > MORPHO_MAX_LIST_LIMIT) {
+    throw new Error(`limit must be between 1 and ${MORPHO_MAX_LIST_LIMIT}.`);
+  }
+  return limit;
+}
+
+function normalizeMorphoListedOnly(value, fallback = true) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error("listedOnly must be a boolean.");
+  }
+  return value;
+}
+
+function buildOrderFieldLookup(fields) {
+  const lookup = new Map();
+  for (const field of fields) {
+    lookup.set(field.toLowerCase(), field);
+  }
+  return lookup;
+}
+
+const MORPHO_VAULT_ORDER_LOOKUP = buildOrderFieldLookup([
+  "Address",
+  "TotalAssets",
+  "TotalAssetsUsd",
+  "TotalSupply",
+  "Liquidity",
+  "LiquidityUsd",
+  "Apy",
+  "NetApy",
+  "RealAssets",
+  "RealAssetsUsd",
+  "IdleAssets",
+  "IdleAssetsUsd",
+]);
+
+const MORPHO_MARKET_ORDER_LOOKUP = buildOrderFieldLookup([
+  "UniqueKey",
+  "Lltv",
+  "BorrowAssets",
+  "BorrowAssetsUsd",
+  "SupplyAssets",
+  "SupplyAssetsUsd",
+  "BorrowShares",
+  "SupplyShares",
+  "Utilization",
+  "ApyAtTarget",
+  "SupplyApy",
+  "NetSupplyApy",
+  "BorrowApy",
+  "NetBorrowApy",
+  "Fee",
+  "LoanAssetSymbol",
+  "CollateralAssetSymbol",
+  "TotalLiquidityUsd",
+  "AvgBorrowApy",
+  "AvgNetBorrowApy",
+  "DailyBorrowApy",
+  "DailyNetBorrowApy",
+  "SizeUsd",
+]);
+
+function normalizeMorphoOrderBy(value, lookup, fallback, fieldName = "orderBy") {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  const canonical = lookup.get(String(value).trim().toLowerCase());
+  if (!canonical) {
+    throw new Error(`${fieldName} must be one of: ${[...lookup.values()].join(", ")}.`);
+  }
+  return canonical;
+}
+
+function normalizeMorphoOrderDirection(value, fallback = "Desc") {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "asc") {
+    return "Asc";
+  }
+  if (normalized === "desc") {
+    return "Desc";
+  }
+  throw new Error("orderDirection must be 'asc' or 'desc'.");
+}
+
+function normalizeMorphoSearch(value) {
+  if (value === undefined || value === null || value === "") {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error("search must be a string.");
+  }
+  return value.trim() || null;
+}
+
+function normalizeOptionalAddressFilter(value, fieldName) {
+  if (value === undefined || value === null || value === "") {
+    return null;
+  }
+  const values = Array.isArray(value) ? value : [value];
+  const normalized = values
+    .filter((entry) => entry !== undefined && entry !== null && String(entry).trim())
+    .map((entry) => normalizeAddress(entry, fieldName));
+  return normalized.length > 0 ? normalized : null;
+}
+
+function assertMorphoMarketId(value, fieldName = "marketId") {
+  const id = assertNonEmptyString(value, fieldName);
+  if (!/^0x[a-fA-F0-9]{64}$/.test(id)) {
+    throw new Error(`${fieldName} must be a 32-byte hex string.`);
+  }
+  return id;
+}
+
 function normalizeAaveOperation(value) {
   const operation = assertNonEmptyString(value, "operation").toLowerCase();
   if (!["supply", "withdraw", "borrow", "repay"].includes(operation)) {
@@ -217,6 +693,24 @@ function normalizeAaveOperation(value) {
   return operation;
 }
 
+function normalizeMorphoVaultOperation(value) {
+  const operation = assertNonEmptyString(value, "operation").toLowerCase();
+  if (!["supply", "withdraw"].includes(operation)) {
+    throw new Error("operation must be one of: supply, withdraw.");
+  }
+  return operation;
+}
+
+function normalizeMorphoMarketOperation(value) {
+  const operation = assertNonEmptyString(value, "operation").toLowerCase();
+  if (!["supply_collateral", "borrow", "repay", "withdraw_collateral"].includes(operation)) {
+    throw new Error(
+      "operation must be one of: supply_collateral, borrow, repay, withdraw_collateral."
+    );
+  }
+  return operation;
+}
+
 function normalizeLidoOperation(value) {
   const operation = assertNonEmptyString(value, "operation").toLowerCase();
   if (!["stake_eth_for_wsteth", "wrap_steth", "unwrap_wsteth"].includes(operation)) {
@@ -517,6 +1011,152 @@ function buildAaveOperationRequest({ operation, token, tokenAddress, amount, onB
   };
 }
 
+function parseOptionalPositiveBigIntString(value, fieldName) {
+  if (value === undefined || value === null || value === "") {
+    return null;
+  }
+  return assertPositiveBigIntString(value, fieldName);
+}
+
+function normalizeMorphoVaultTarget({ vaultAddress, vaultPreset }) {
+  const normalizedVaultAddress = vaultAddress ? normalizeAddress(vaultAddress, "vaultAddress") : null;
+  const normalizedVaultPreset =
+    vaultPreset !== undefined && vaultPreset !== null && String(vaultPreset).trim()
+      ? assertNonEmptyString(vaultPreset, "vaultPreset")
+      : null;
+  if (normalizedVaultAddress && normalizedVaultPreset) {
+    throw new Error("Provide either vaultAddress or vaultPreset, not both.");
+  }
+  if (!normalizedVaultAddress && !normalizedVaultPreset) {
+    throw new Error("vaultAddress or vaultPreset is required.");
+  }
+  return {
+    vaultAddress: normalizedVaultAddress,
+    vaultPreset: normalizedVaultPreset,
+  };
+}
+
+function normalizeMorphoMarketTarget({ marketId, marketPreset }) {
+  const normalizedMarketId =
+    marketId === undefined || marketId === null || marketId === ""
+      ? null
+      : assertMorphoMarketId(marketId, "marketId");
+  const normalizedMarketPreset =
+    marketPreset !== undefined && marketPreset !== null && String(marketPreset).trim()
+      ? assertNonEmptyString(marketPreset, "marketPreset")
+      : null;
+  if (normalizedMarketId && normalizedMarketPreset) {
+    throw new Error("Provide either marketId or marketPreset, not both.");
+  }
+  if (!normalizedMarketId && !normalizedMarketPreset) {
+    throw new Error("marketId or marketPreset is required.");
+  }
+  return {
+    marketId: normalizedMarketId,
+    marketPreset: normalizedMarketPreset,
+  };
+}
+
+function buildMorphoVaultOperationRequest({
+  operation,
+  vaultAddress,
+  vaultPreset,
+  token,
+  tokenAddress,
+  amount,
+  nativeAmount,
+  onBehalfOf,
+  to,
+}) {
+  if (onBehalfOf !== undefined && onBehalfOf !== null && String(onBehalfOf).trim()) {
+    throw new Error("Morpho delegated onBehalfOf operations are not exposed by this local wallet runtime.");
+  }
+  if (to !== undefined && to !== null && String(to).trim()) {
+    throw new Error("Morpho third-party withdraw destinations are not exposed by this local wallet runtime.");
+  }
+  const preferredToken = tokenAddress ?? token;
+  if (tokenAddress && token && String(tokenAddress).toLowerCase() !== String(token).toLowerCase()) {
+    throw new Error("tokenAddress and token must refer to the same address.");
+  }
+  const request = {
+    target: normalizeMorphoVaultTarget({ vaultAddress, vaultPreset }),
+    operation: normalizeMorphoVaultOperation(operation),
+    token: normalizeAddress(preferredToken, "tokenAddress"),
+  };
+  if (request.operation === "supply") {
+    const supplyAmount = parseOptionalPositiveBigIntString(amount, "amount");
+    const supplyNativeAmount = parseOptionalPositiveBigIntString(nativeAmount, "nativeAmount");
+    if (supplyAmount === null && supplyNativeAmount === null) {
+      throw new Error("amount or nativeAmount is required for Morpho vault supply.");
+    }
+    return {
+      ...request,
+      amount: supplyAmount,
+      nativeAmount: supplyNativeAmount,
+    };
+  }
+  return {
+    ...request,
+    amount: assertPositiveBigIntString(amount, "amount"),
+  };
+}
+
+function buildMorphoMarketOperationRequest({
+  operation,
+  marketId,
+  marketPreset,
+  token,
+  tokenAddress,
+  amount,
+  nativeAmount,
+  onBehalfOf,
+  to,
+}) {
+  if (onBehalfOf !== undefined && onBehalfOf !== null && String(onBehalfOf).trim()) {
+    throw new Error("Morpho delegated onBehalfOf operations are not exposed by this local wallet runtime.");
+  }
+  if (to !== undefined && to !== null && String(to).trim()) {
+    throw new Error("Morpho third-party withdraw destinations are not exposed by this local wallet runtime.");
+  }
+  const preferredToken = tokenAddress ?? token;
+  if (tokenAddress && token && String(tokenAddress).toLowerCase() !== String(token).toLowerCase()) {
+    throw new Error("tokenAddress and token must refer to the same address.");
+  }
+  const request = {
+    target: normalizeMorphoMarketTarget({ marketId, marketPreset }),
+    operation: normalizeMorphoMarketOperation(operation),
+    token: normalizeAddress(preferredToken, "tokenAddress"),
+  };
+  if (request.operation === "repay") {
+    const normalizedAmount = String(amount ?? "").trim().toLowerCase();
+    return {
+      ...request,
+      amount:
+        normalizedAmount === "max"
+          ? "max"
+          : assertPositiveBigIntString(amount, "amount"),
+      nativeAmount: null,
+    };
+  }
+  if (request.operation === "supply_collateral") {
+    const collateralAmount = parseOptionalPositiveBigIntString(amount, "amount");
+    const collateralNativeAmount = parseOptionalPositiveBigIntString(nativeAmount, "nativeAmount");
+    if (collateralAmount === null && collateralNativeAmount === null) {
+      throw new Error("amount or nativeAmount is required for Morpho market supply_collateral.");
+    }
+    return {
+      ...request,
+      amount: collateralAmount,
+      nativeAmount: collateralNativeAmount,
+    };
+  }
+  return {
+    ...request,
+    amount: assertPositiveBigIntString(amount, "amount"),
+    nativeAmount: null,
+  };
+}
+
 function buildLidoOperationRequest({ operation, amount }) {
   return {
     operation: normalizeLidoOperation(operation),
@@ -1279,35 +1919,231 @@ export class WdkEvmWalletService {
     );
   }
 
-  async quoteAaveOperation({
+  async getMorphoVaults({
+    network,
+    vaultAddress = null,
+    limit,
+    listedOnly = true,
+    assetAddress = null,
+    orderBy,
+    orderDirection,
+  }) {
+    const runtimeConfig = this.#resolveRuntimeConfig(network);
+    assertMorphoSupportedNetwork(runtimeConfig.network);
+    if (vaultAddress !== null && vaultAddress !== undefined && String(vaultAddress).trim()) {
+      const data = await this.#morphoGraphqlRequest({
+        query: MORPHO_VAULT_BY_ADDRESS_QUERY,
+        variables: {
+          address: normalizeAddress(vaultAddress, "vaultAddress"),
+          chainId: runtimeConfig.chainId,
+        },
+        operationName: "MorphoVaultV2ByAddress",
+      });
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        protocol: "morpho",
+        vault: data.vaultV2ByAddress || null,
+        found: Boolean(data.vaultV2ByAddress),
+        source: "morpho-api",
+      };
+    }
+    const first = normalizeMorphoListLimit(limit);
+    const onlyListed = normalizeMorphoListedOnly(listedOnly);
+    const assetAddressFilter = normalizeOptionalAddressFilter(assetAddress, "assetAddress");
+    const resolvedOrderBy = normalizeMorphoOrderBy(
+      orderBy,
+      MORPHO_VAULT_ORDER_LOOKUP,
+      "TotalAssetsUsd"
+    );
+    const resolvedOrderDirection = normalizeMorphoOrderDirection(orderDirection);
+    const where = { chainId_in: [runtimeConfig.chainId] };
+    if (onlyListed) {
+      where.listed = true;
+    }
+    if (assetAddressFilter) {
+      where.assetAddress_in = assetAddressFilter;
+    }
+    const data = await this.#morphoGraphqlRequest({
+      query: MORPHO_VAULT_LIST_QUERY,
+      variables: {
+        first,
+        where,
+        orderBy: resolvedOrderBy,
+        orderDirection: resolvedOrderDirection,
+      },
+      operationName: "MorphoVaultV2List",
+    });
+    const vaults = Array.isArray(data?.vaultV2s?.items) ? data.vaultV2s.items : [];
+    return {
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      protocol: "morpho",
+      listedOnly: onlyListed,
+      requestedLimit: first,
+      orderBy: resolvedOrderBy,
+      orderDirection: resolvedOrderDirection,
+      assetAddressFilter,
+      vaultCount: vaults.length,
+      vaults,
+      source: "morpho-api",
+    };
+  }
+
+  async getMorphoMarkets({
+    network,
+    marketId = null,
+    limit,
+    listedOnly = true,
+    search,
+    collateralAssetAddress = null,
+    loanAssetAddress = null,
+    orderBy,
+    orderDirection,
+  }) {
+    const runtimeConfig = this.#resolveRuntimeConfig(network);
+    assertMorphoSupportedNetwork(runtimeConfig.network);
+    if (marketId !== null && marketId !== undefined && String(marketId).trim()) {
+      const data = await this.#morphoGraphqlRequest({
+        query: MORPHO_MARKET_BY_ID_QUERY,
+        variables: {
+          marketId: assertMorphoMarketId(marketId, "marketId"),
+          chainId: runtimeConfig.chainId,
+        },
+        operationName: "MorphoMarketById",
+      });
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        protocol: "morpho",
+        market: data.marketById || null,
+        found: Boolean(data.marketById),
+        source: "morpho-api",
+      };
+    }
+    const first = normalizeMorphoListLimit(limit);
+    const onlyListed = normalizeMorphoListedOnly(listedOnly);
+    const searchTerm = normalizeMorphoSearch(search);
+    const collateralFilter = normalizeOptionalAddressFilter(
+      collateralAssetAddress,
+      "collateralAssetAddress"
+    );
+    const loanFilter = normalizeOptionalAddressFilter(loanAssetAddress, "loanAssetAddress");
+    const resolvedOrderBy = normalizeMorphoOrderBy(
+      orderBy,
+      MORPHO_MARKET_ORDER_LOOKUP,
+      "SupplyAssetsUsd"
+    );
+    const resolvedOrderDirection = normalizeMorphoOrderDirection(orderDirection);
+    const where = { chainId_in: [runtimeConfig.chainId] };
+    if (onlyListed) {
+      where.listed = true;
+    }
+    if (searchTerm) {
+      where.search = searchTerm;
+    }
+    if (collateralFilter) {
+      where.collateralAssetAddress_in = collateralFilter;
+    }
+    if (loanFilter) {
+      where.loanAssetAddress_in = loanFilter;
+    }
+    const data = await this.#morphoGraphqlRequest({
+      query: MORPHO_MARKET_LIST_QUERY,
+      variables: {
+        first,
+        where,
+        orderBy: resolvedOrderBy,
+        orderDirection: resolvedOrderDirection,
+      },
+      operationName: "MorphoMarketList",
+    });
+    const markets = Array.isArray(data?.markets?.items) ? data.markets.items : [];
+    return {
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      protocol: "morpho",
+      listedOnly: onlyListed,
+      requestedLimit: first,
+      orderBy: resolvedOrderBy,
+      orderDirection: resolvedOrderDirection,
+      search: searchTerm,
+      collateralAssetFilter: collateralFilter,
+      loanAssetFilter: loanFilter,
+      marketCount: markets.length,
+      markets,
+      source: "morpho-api",
+    };
+  }
+
+  async getMorphoPositions({ seedPhrase, address, accountIndex = 0, network }) {
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertMorphoSupportedNetwork(runtimeConfig.network);
+        const accountAddress = await account.getAddress();
+        const data = await this.#morphoGraphqlRequest({
+          query: MORPHO_USER_OVERVIEW_QUERY,
+          variables: {
+            address: accountAddress,
+            chainId: runtimeConfig.chainId,
+          },
+          operationName: "MorphoUserByAddress",
+        });
+        const user = data.userByAddress || null;
+        const marketPositions = Array.isArray(user?.marketPositions) ? user.marketPositions : [];
+        const vaultPositions = Array.isArray(user?.vaultV2Positions) ? user.vaultV2Positions : [];
+        return {
+          network: runtimeConfig.network,
+          chainId: runtimeConfig.chainId,
+          accountIndex,
+          address: accountAddress,
+          protocol: "morpho",
+          marketPositionCount: marketPositions.length,
+          vaultPositionCount: vaultPositions.length,
+          marketPositions,
+          vaultPositions,
+          source: "morpho-api",
+        };
+      }
+    );
+  }
+
+  async quoteMorphoVaultOperation({
     seedPhrase,
     address,
     operation,
+    vaultAddress,
+    vaultPreset,
     token,
     tokenAddress,
     amount,
+    nativeAmount,
     accountIndex = 0,
     network,
   }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertAaveSupportedNetwork(runtimeConfig.network);
-        const request = buildAaveOperationRequest({
+        assertMorphoSupportedNetwork(runtimeConfig.network);
+        const request = buildMorphoVaultOperationRequest({
           operation,
+          vaultAddress,
+          vaultPreset,
           token,
           tokenAddress,
           amount,
+          nativeAmount,
         });
         const accountAddress = await account.getAddress();
-        const plan = await this.#buildAaveOperationPlan({
+        const plan = await this.#buildMorphoOperationPlan({
           account,
           runtimeConfig,
           address: accountAddress,
           request,
           tolerateOperationFeeFailure: true,
         });
-        return this.#formatAaveOperationResponse({
+        return this.#formatMorphoOperationResponse({
           runtimeConfig,
           accountIndex,
           address: accountAddress,
@@ -1318,42 +2154,47 @@ export class WdkEvmWalletService {
     );
   }
 
-  async sendAaveOperation({
+  async sendMorphoVaultOperation({
     seedPhrase,
     operation,
+    vaultAddress,
+    vaultPreset,
     token,
     tokenAddress,
     amount,
+    nativeAmount,
     accountIndex = 0,
     network,
     expectedQuoteFingerprint = null,
   }) {
     return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertAaveSupportedNetwork(runtimeConfig.network);
-      const request = buildAaveOperationRequest({
+      assertMorphoSupportedNetwork(runtimeConfig.network);
+      const request = buildMorphoVaultOperationRequest({
         operation,
+        vaultAddress,
+        vaultPreset,
         token,
         tokenAddress,
         amount,
+        nativeAmount,
       });
       const normalizedExpectedQuoteFingerprint =
         typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
           ? expectedQuoteFingerprint.trim()
           : null;
       const address = await account.getAddress();
-      let initialPlan = await this.#buildAaveOperationPlan({
+      let initialPlan = await this.#buildMorphoOperationPlan({
         account,
         runtimeConfig,
         address,
         request,
         tolerateOperationFeeFailure: true,
       });
-      this.#assertExpectedAaveFingerprint(
+      this.#assertExpectedMorphoFingerprint(
         normalizedExpectedQuoteFingerprint,
         initialPlan.quoteFingerprint
       );
-
-      const approvalExecution = await this.#executeAaveApprovalsIfNeeded({
+      const requirementExecution = await this.#executeMorphoRequirementsIfNeeded({
         account,
         runtimeConfig,
         request,
@@ -1362,35 +2203,34 @@ export class WdkEvmWalletService {
 
       let finalPlan = initialPlan;
       try {
-        if (approvalExecution.performed) {
-          finalPlan = await this.#buildAaveOperationPlan({
+        if (requirementExecution.performed) {
+          finalPlan = await this.#buildMorphoOperationPlan({
             account,
             runtimeConfig,
             address,
             request,
           });
-          this.#assertExpectedAaveFingerprint(
+          this.#assertExpectedMorphoFingerprint(
             normalizedExpectedQuoteFingerprint,
             finalPlan.quoteFingerprint
           );
         }
 
-        if (finalPlan.approval.required) {
+        if (finalPlan.requirements.required) {
           throw createTaggedError(
-            "Aave operation still requires token approval after the approval step completed.",
-            "aave_approval_required",
+            "Morpho operation still requires prerequisite transactions after the requirement step completed.",
+            "morpho_requirements_unresolved",
             {
-              spender: finalPlan.spender,
-              requiredAllowance: finalPlan.amount.toString(),
-              currentAllowance: finalPlan.currentAllowance.toString(),
+              requirementCount: finalPlan.requirements.steps.length,
+              requirements: finalPlan.requirements.steps,
             }
           );
         }
 
         if (finalPlan.operationFee === null) {
           throw createTaggedError(
-            "Aave operation fee estimate was unavailable. Generate a new quote before sending.",
-            "aave_fee_unavailable",
+            "Morpho operation fee estimate was unavailable. Generate a new quote before sending.",
+            "morpho_fee_unavailable",
             {
               operation: request.operation,
               feeEstimateError: finalPlan.operationFeeError,
@@ -1398,20 +2238,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const protocol = new AaveProtocolEvm(account);
+        const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
         let result;
         try {
-          result = await protocol[request.operation]({
-            token: request.token,
-            amount: request.amount,
-          });
+          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
+            this.#buildMorphoOperationOptions(request)
+          );
         } finally {
           await maybeDispose(protocol);
         }
-        const resultFee = BigInt(result?.fee || 0);
-        const totalFee = approvalExecution.totalFee + resultFee;
+        const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
+        const totalFee = requirementExecution.totalFee + resultFee;
         return {
-          ...this.#formatAaveOperationResponse({
+          ...this.#formatMorphoOperationResponse({
             runtimeConfig,
             accountIndex,
             address,
@@ -1420,9 +2259,9 @@ export class WdkEvmWalletService {
               ...finalPlan,
               operationFee: resultFee,
               totalEstimatedFee: totalFee,
-              approval: {
-                ...finalPlan.approval,
-                estimatedFee: approvalExecution.totalFee,
+              requirements: {
+                ...finalPlan.requirements,
+                estimatedFee: requirementExecution.totalFee,
               },
             },
           }),
@@ -1430,210 +2269,58 @@ export class WdkEvmWalletService {
             ...result,
             fee: resultFee.toString(),
             totalFee: totalFee.toString(),
-            approvalFee: approvalExecution.totalFee.toString(),
-            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-            ...(approvalExecution.resetAllowanceHash
-              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-              : {}),
+            requirementsFee: requirementExecution.totalFee.toString(),
+            requirements: requirementExecution.transactions,
           },
         };
       } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedAaveOperation({
+        const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
           account,
           runtimeConfig,
-          tokenAddress: request.token,
-          spender: initialPlan.spender,
-          originalAllowance: initialPlan.currentAllowance,
-          approvalExecution,
+          request,
+          plan: initialPlan,
+          requirementExecution,
         });
-        this.#throwAaveFailureWithCleanup(error, cleanup);
+        this.#throwMorphoFailureWithCleanup(error, cleanup);
       }
     });
   }
 
-  async getLidoOverview({ seedPhrase, address, accountIndex = 0, network }) {
-    return this.#withReadableAccount(
-      { seedPhrase, address, accountIndex, network },
-      async (account, runtimeConfig) => {
-        assertLidoSupportedNetwork(runtimeConfig.network);
-        const contracts = this.#getLidoContracts(runtimeConfig.network);
-        const [stEthMetadata, wstEthMetadata, rates, stakingAprResult] = await Promise.all([
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
-          this.#readLidoSampleRates(runtimeConfig),
-          this.#readLidoStakingApr(runtimeConfig),
-        ]);
-        return {
-          network: runtimeConfig.network,
-          chainId: runtimeConfig.chainId,
-          accountIndex,
-          protocol: "lido",
-          preferredPositionToken: "wstETH",
-          stakingAsset: {
-            type: "native",
-            symbol: runtimeConfig.nativeSymbol,
-            decimals: 18,
-          },
-          referralAddress: this.#getLidoReferralAddress(),
-          contracts: {
-            stETH: contracts.steth.address,
-            wstETH: contracts.wsteth.address,
-            referralStaker: contracts.referralStaker,
-            withdrawalQueue: contracts.withdrawalQueue,
-          },
-          stEthMetadata,
-          wstEthMetadata,
-          sampleRates: rates,
-          stakingApr: stakingAprResult.data,
-          stakingAprError: stakingAprResult.error,
-          withdrawalLimits: {
-            minStEthAmountRaw: LIDO_MIN_STETH_WITHDRAWAL_AMOUNT.toString(),
-            minStEthAmountFormatted: formatUnits(LIDO_MIN_STETH_WITHDRAWAL_AMOUNT, LIDO_STETH_DECIMALS),
-            maxStEthAmountRaw: LIDO_MAX_STETH_WITHDRAWAL_AMOUNT.toString(),
-            maxStEthAmountFormatted: formatUnits(LIDO_MAX_STETH_WITHDRAWAL_AMOUNT, LIDO_STETH_DECIMALS),
-          },
-          source: "lido-contracts",
-        };
-      }
-    );
-  }
-
-  async getLidoPositions({ seedPhrase, address, accountIndex = 0, network }) {
-    return this.#withReadableAccount(
-      { seedPhrase, address, accountIndex, network },
-      async (account, runtimeConfig) => {
-        assertLidoSupportedNetwork(runtimeConfig.network);
-        const accountAddress = await account.getAddress();
-        const contracts = this.#getLidoContracts(runtimeConfig.network);
-        const [nativeBalance, stEthMetadata, wstEthMetadata, stEthBalance, wstEthBalance] = await Promise.all([
-          account.getBalance(),
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
-          this.#readTokenBalanceWithFallback({
-            account,
-            runtimeConfig,
-            tokenAddress: contracts.steth.address,
-            ownerAddress: accountAddress,
-          }),
-          this.#readTokenBalanceWithFallback({
-            account,
-            runtimeConfig,
-            tokenAddress: contracts.wsteth.address,
-            ownerAddress: accountAddress,
-          }),
-        ]);
-        const wstEthAsStEth = await this.#quoteLidoOutputRaw({
-          runtimeConfig,
-          operation: "unwrap_wsteth",
-          amount: wstEthBalance,
-          fromAddress: accountAddress,
-        });
-        const stEthEquivalentTotal = stEthBalance + wstEthAsStEth;
-        const positions = [];
-        if (stEthBalance > 0n) {
-          positions.push({
-            asset: "stETH",
-            tokenAddress: contracts.steth.address,
-            tokenMetadata: stEthMetadata,
-            balanceRaw: stEthBalance.toString(),
-            balanceFormatted: formatUnits(stEthBalance, stEthMetadata.decimals),
-            stEthEquivalentRaw: stEthBalance.toString(),
-            stEthEquivalentFormatted: formatUnits(stEthBalance, stEthMetadata.decimals),
-          });
-        }
-        if (wstEthBalance > 0n) {
-          positions.push({
-            asset: "wstETH",
-            tokenAddress: contracts.wsteth.address,
-            tokenMetadata: wstEthMetadata,
-            balanceRaw: wstEthBalance.toString(),
-            balanceFormatted: formatUnits(wstEthBalance, wstEthMetadata.decimals),
-            stEthEquivalentRaw: wstEthAsStEth.toString(),
-            stEthEquivalentFormatted: formatUnits(wstEthAsStEth, stEthMetadata.decimals),
-          });
-        }
-        return {
-          network: runtimeConfig.network,
-          chainId: runtimeConfig.chainId,
-          accountIndex,
-          address: accountAddress,
-          protocol: "lido",
-          preferredPositionToken: "wstETH",
-          contracts: {
-            stETH: contracts.steth.address,
-            wstETH: contracts.wsteth.address,
-            referralStaker: contracts.referralStaker,
-            withdrawalQueue: contracts.withdrawalQueue,
-          },
-          nativeBalanceWei: BigInt(nativeBalance || 0).toString(),
-          nativeBalanceFormatted: formatUnits(BigInt(nativeBalance || 0), 18),
-          stEthEquivalentTotalRaw: stEthEquivalentTotal.toString(),
-          stEthEquivalentTotalFormatted: formatUnits(stEthEquivalentTotal, stEthMetadata.decimals),
-          positionCount: positions.length,
-          positions,
-          source: "lido-contracts",
-        };
-      }
-    );
-  }
-
-  async getLidoWithdrawalRequests({ seedPhrase, address, accountIndex = 0, network }) {
-    return this.#withReadableAccount(
-      { seedPhrase, address, accountIndex, network },
-      async (account, runtimeConfig) => {
-        assertLidoSupportedNetwork(runtimeConfig.network);
-        const accountAddress = await account.getAddress();
-        const contracts = this.#getLidoContracts(runtimeConfig.network);
-        const [stEthMetadata, wstEthMetadata, requestIds] = await Promise.all([
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
-          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
-          this.#getLidoWithdrawalRequestIds(runtimeConfig, accountAddress),
-        ]);
-        const statuses = requestIds.length
-          ? await this.#getLidoWithdrawalStatuses(runtimeConfig, requestIds)
-          : [];
-        const requests = statuses.map((status) =>
-          this.#formatLidoWithdrawalStatus(status, stEthMetadata, wstEthMetadata)
-        );
-        const claimableCount = requests.filter((request) => request.claimable).length;
-        return {
-          network: runtimeConfig.network,
-          chainId: runtimeConfig.chainId,
-          accountIndex,
-          address: accountAddress,
-          protocol: "lido",
-          withdrawalQueue: contracts.withdrawalQueue,
-          requestCount: requests.length,
-          claimableCount,
-          requests,
-          source: "lido-contracts",
-        };
-      }
-    );
-  }
-
-  async quoteLidoOperation({
+  async quoteMorphoMarketOperation({
     seedPhrase,
     address,
     operation,
+    marketId,
+    marketPreset,
+    token,
+    tokenAddress,
     amount,
+    nativeAmount,
     accountIndex = 0,
     network,
   }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertLidoSupportedNetwork(runtimeConfig.network);
-        const request = buildLidoOperationRequest({ operation, amount });
+        assertMorphoSupportedNetwork(runtimeConfig.network);
+        const request = buildMorphoMarketOperationRequest({
+          operation,
+          marketId,
+          marketPreset,
+          token,
+          tokenAddress,
+          amount,
+          nativeAmount,
+        });
         const accountAddress = await account.getAddress();
-        const plan = await this.#buildLidoOperationPlan({
+        const plan = await this.#buildMorphoOperationPlan({
           account,
           runtimeConfig,
           address: accountAddress,
           request,
           tolerateOperationFeeFailure: true,
         });
-        return this.#formatLidoOperationResponse({
+        return this.#formatMorphoOperationResponse({
           runtimeConfig,
           accountIndex,
           address: accountAddress,
@@ -1644,35 +2331,47 @@ export class WdkEvmWalletService {
     );
   }
 
-  async sendLidoOperation({
+  async sendMorphoMarketOperation({
     seedPhrase,
     operation,
+    marketId,
+    marketPreset,
+    token,
+    tokenAddress,
     amount,
+    nativeAmount,
     accountIndex = 0,
     network,
     expectedQuoteFingerprint = null,
   }) {
     return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertLidoSupportedNetwork(runtimeConfig.network);
-      const request = buildLidoOperationRequest({ operation, amount });
+      assertMorphoSupportedNetwork(runtimeConfig.network);
+      const request = buildMorphoMarketOperationRequest({
+        operation,
+        marketId,
+        marketPreset,
+        token,
+        tokenAddress,
+        amount,
+        nativeAmount,
+      });
       const normalizedExpectedQuoteFingerprint =
         typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
           ? expectedQuoteFingerprint.trim()
           : null;
       const address = await account.getAddress();
-      let initialPlan = await this.#buildLidoOperationPlan({
+      let initialPlan = await this.#buildMorphoOperationPlan({
         account,
         runtimeConfig,
         address,
         request,
         tolerateOperationFeeFailure: true,
       });
-      this.#assertExpectedLidoFingerprint(
+      this.#assertExpectedMorphoFingerprint(
         normalizedExpectedQuoteFingerprint,
         initialPlan.quoteFingerprint
       );
-
-      const approvalExecution = await this.#executeLidoApprovalsIfNeeded({
+      const requirementExecution = await this.#executeMorphoRequirementsIfNeeded({
         account,
         runtimeConfig,
         request,
@@ -1681,35 +2380,34 @@ export class WdkEvmWalletService {
 
       let finalPlan = initialPlan;
       try {
-        if (approvalExecution.performed) {
-          finalPlan = await this.#buildLidoOperationPlan({
+        if (requirementExecution.performed) {
+          finalPlan = await this.#buildMorphoOperationPlan({
             account,
             runtimeConfig,
             address,
             request,
           });
-          this.#assertExpectedLidoFingerprint(
+          this.#assertExpectedMorphoFingerprint(
             normalizedExpectedQuoteFingerprint,
             finalPlan.quoteFingerprint
           );
         }
 
-        if (finalPlan.approval.required) {
+        if (finalPlan.requirements.required) {
           throw createTaggedError(
-            "Lido operation still requires token approval after the approval step completed.",
-            "lido_approval_required",
+            "Morpho operation still requires prerequisite transactions after the requirement step completed.",
+            "morpho_requirements_unresolved",
             {
-              spender: finalPlan.spender,
-              requiredAllowance: finalPlan.amount.toString(),
-              currentAllowance: finalPlan.currentAllowance.toString(),
+              requirementCount: finalPlan.requirements.steps.length,
+              requirements: finalPlan.requirements.steps,
             }
           );
         }
 
         if (finalPlan.operationFee === null) {
           throw createTaggedError(
-            "Lido operation fee estimate was unavailable. Generate a new quote before sending.",
-            "lido_fee_unavailable",
+            "Morpho operation fee estimate was unavailable. Generate a new quote before sending.",
+            "morpho_fee_unavailable",
             {
               operation: request.operation,
               feeEstimateError: finalPlan.operationFeeError,
@@ -1717,11 +2415,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
+        const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
+        let result;
+        try {
+          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
+            this.#buildMorphoOperationOptions(request)
+          );
+        } finally {
+          await maybeDispose(protocol);
+        }
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
-        const totalFee = approvalExecution.totalFee + resultFee;
+        const totalFee = requirementExecution.totalFee + resultFee;
         return {
-          ...this.#formatLidoOperationResponse({
+          ...this.#formatMorphoOperationResponse({
             runtimeConfig,
             accountIndex,
             address,
@@ -1730,9 +2436,9 @@ export class WdkEvmWalletService {
               ...finalPlan,
               operationFee: resultFee,
               totalEstimatedFee: totalFee,
-              approval: {
-                ...finalPlan.approval,
-                estimatedFee: approvalExecution.totalFee,
+              requirements: {
+                ...finalPlan.requirements,
+                estimatedFee: requirementExecution.totalFee,
               },
             },
           }),
@@ -1740,50 +2446,52 @@ export class WdkEvmWalletService {
             ...result,
             fee: resultFee.toString(),
             totalFee: totalFee.toString(),
-            approvalFee: approvalExecution.totalFee.toString(),
-            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-            ...(approvalExecution.resetAllowanceHash
-              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-              : {}),
+            requirementsFee: requirementExecution.totalFee.toString(),
+            requirements: requirementExecution.transactions,
           },
         };
       } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedLidoOperation({
+        const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
           account,
           runtimeConfig,
-          tokenAddress: finalPlan.inputTokenAddress,
-          spender: initialPlan.spender,
-          originalAllowance: initialPlan.currentAllowance,
-          approvalExecution,
+          request,
+          plan: initialPlan,
+          requirementExecution,
         });
-        this.#throwLidoFailureWithCleanup(error, cleanup);
+        this.#throwMorphoFailureWithCleanup(error, cleanup);
       }
     });
   }
 
-  async quoteLidoWithdrawalOperation({
+  async quoteAaveOperation({
     seedPhrase,
     address,
     operation,
+    token,
+    tokenAddress,
     amount,
-    requestId,
     accountIndex = 0,
     network,
   }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertLidoSupportedNetwork(runtimeConfig.network);
-        const request = buildLidoWithdrawalRequest({ operation, amount, requestId });
+        assertAaveSupportedNetwork(runtimeConfig.network);
+        const request = buildAaveOperationRequest({
+          operation,
+          token,
+          tokenAddress,
+          amount,
+        });
         const accountAddress = await account.getAddress();
-        const plan = await this.#buildLidoWithdrawalPlan({
+        const plan = await this.#buildAaveOperationPlan({
           account,
           runtimeConfig,
           address: accountAddress,
           request,
           tolerateOperationFeeFailure: true,
         });
-        return this.#formatLidoWithdrawalResponse({
+        return this.#formatAaveOperationResponse({
           runtimeConfig,
           accountIndex,
           address: accountAddress,
@@ -1794,36 +2502,42 @@ export class WdkEvmWalletService {
     );
   }
 
-  async sendLidoWithdrawalOperation({
+  async sendAaveOperation({
     seedPhrase,
     operation,
+    token,
+    tokenAddress,
     amount,
-    requestId,
     accountIndex = 0,
     network,
     expectedQuoteFingerprint = null,
   }) {
     return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertLidoSupportedNetwork(runtimeConfig.network);
-      const request = buildLidoWithdrawalRequest({ operation, amount, requestId });
+      assertAaveSupportedNetwork(runtimeConfig.network);
+      const request = buildAaveOperationRequest({
+        operation,
+        token,
+        tokenAddress,
+        amount,
+      });
       const normalizedExpectedQuoteFingerprint =
         typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
           ? expectedQuoteFingerprint.trim()
           : null;
       const address = await account.getAddress();
-      let initialPlan = await this.#buildLidoWithdrawalPlan({
+      let initialPlan = await this.#buildAaveOperationPlan({
         account,
         runtimeConfig,
         address,
         request,
         tolerateOperationFeeFailure: true,
       });
-      this.#assertExpectedLidoWithdrawalFingerprint(
+      this.#assertExpectedAaveFingerprint(
         normalizedExpectedQuoteFingerprint,
         initialPlan.quoteFingerprint
       );
 
-      const approvalExecution = await this.#executeLidoWithdrawalApprovalsIfNeeded({
+      const approvalExecution = await this.#executeAaveApprovalsIfNeeded({
         account,
         runtimeConfig,
         request,
@@ -1833,13 +2547,13 @@ export class WdkEvmWalletService {
       let finalPlan = initialPlan;
       try {
         if (approvalExecution.performed) {
-          finalPlan = await this.#buildLidoWithdrawalPlan({
+          finalPlan = await this.#buildAaveOperationPlan({
             account,
             runtimeConfig,
             address,
             request,
           });
-          this.#assertExpectedLidoWithdrawalFingerprint(
+          this.#assertExpectedAaveFingerprint(
             normalizedExpectedQuoteFingerprint,
             finalPlan.quoteFingerprint
           );
@@ -1847,11 +2561,11 @@ export class WdkEvmWalletService {
 
         if (finalPlan.approval.required) {
           throw createTaggedError(
-            "Lido withdrawal still requires token approval after the approval step completed.",
-            "lido_withdrawal_approval_required",
+            "Aave operation still requires token approval after the approval step completed.",
+            "aave_approval_required",
             {
               spender: finalPlan.spender,
-              requiredAllowance: finalPlan.requiredAllowance.toString(),
+              requiredAllowance: finalPlan.amount.toString(),
               currentAllowance: finalPlan.currentAllowance.toString(),
             }
           );
@@ -1859,8 +2573,8 @@ export class WdkEvmWalletService {
 
         if (finalPlan.operationFee === null) {
           throw createTaggedError(
-            "Lido withdrawal fee estimate was unavailable. Generate a new quote before sending.",
-            "lido_withdrawal_fee_unavailable",
+            "Aave operation fee estimate was unavailable. Generate a new quote before sending.",
+            "aave_fee_unavailable",
             {
               operation: request.operation,
               feeEstimateError: finalPlan.operationFeeError,
@@ -1868,11 +2582,20 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
-        const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
+        const protocol = new AaveProtocolEvm(account);
+        let result;
+        try {
+          result = await protocol[request.operation]({
+            token: request.token,
+            amount: request.amount,
+          });
+        } finally {
+          await maybeDispose(protocol);
+        }
+        const resultFee = BigInt(result?.fee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
-          ...this.#formatLidoWithdrawalResponse({
+          ...this.#formatAaveOperationResponse({
             runtimeConfig,
             accountIndex,
             address,
@@ -1899,416 +2622,297 @@ export class WdkEvmWalletService {
           },
         };
       } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedLidoWithdrawal({
+        const cleanup = await this.#restoreAllowanceAfterFailedAaveOperation({
           account,
           runtimeConfig,
-          tokenAddress: finalPlan.inputTokenAddress,
+          tokenAddress: request.token,
           spender: initialPlan.spender,
           originalAllowance: initialPlan.currentAllowance,
           approvalExecution,
         });
-        this.#throwLidoWithdrawalFailureWithCleanup(error, cleanup);
+        this.#throwAaveFailureWithCleanup(error, cleanup);
       }
     });
   }
 
-  async quoteSwap({
-    seedPhrase,
-    address,
-    tokenIn,
-    tokenOut,
-    tokenInAmount,
-    accountIndex = 0,
-    network,
-  }) {
+  async getLidoOverview({ seedPhrase, address, accountIndex = 0, network }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertVeloraSupportedNetwork(runtimeConfig.network);
-        const swapRequest = buildSwapRequest({ tokenIn, tokenOut, tokenInAmount });
-        const address = await account.getAddress();
-        const readOnlyAccount =
-          typeof account.toReadOnlyAccount === "function" ? await account.toReadOnlyAccount() : account;
-        try {
-          const plan = await this.#buildVeloraSwapPlan({
-            account: readOnlyAccount,
-            runtimeConfig,
-            swapRequest,
-            tolerateSwapFeeFailure: true,
-          });
-          const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
-            this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenIn, plan.priceRoute?.srcDecimals),
-            this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenOut, plan.priceRoute?.destDecimals),
-          ]);
-          const quote = {
-            fee: plan.swapFee !== null ? plan.swapFee.toString() : null,
-            tokenInAmount: plan.tokenInAmount.toString(),
-            tokenOutAmount: plan.tokenOutAmount.toString(),
-            priceRoute: plan.priceRoute,
-          };
-          return {
-            network: runtimeConfig.network,
-            chainId: runtimeConfig.chainId,
-            accountIndex,
-            address,
-            protocol: "velora",
-            executionSupported: true,
-            swapRequest,
-            tokenInMetadata,
-            tokenOutMetadata,
-            inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
-            outputAmountFormatted: formatUnits(plan.tokenOutAmount, tokenOutMetadata.decimals),
-            quoteFingerprint: plan.quoteFingerprint,
-            estimatedFeeWei:
-              plan.totalEstimatedFee !== null ? plan.totalEstimatedFee.toString() : null,
-            estimatedSwapFeeWei: plan.swapFee !== null ? plan.swapFee.toString() : null,
-            estimatedApprovalFeeWei: plan.approval.estimatedFee.toString(),
-            feeEstimateAvailable: plan.swapFee !== null,
-            feeEstimateError: plan.swapFeeError,
-            slippageBps: plan.slippageBps,
-            minimumOutputAmountRaw: plan.minimumTokenOutAmount.toString(),
-            allowance: {
-              spender: plan.spender,
-              currentAllowance: plan.currentAllowance.toString(),
-              requiredAllowance: plan.tokenInAmount.toString(),
-              approvalRequired: plan.approval.required,
-              approvalSequence: plan.approval.steps,
-              readError: plan.allowanceReadError,
-            },
-            router: plan.router,
-            simulation: plan.simulation,
-            swapTransaction: plan.swapTransaction,
-            quote,
-            source: "wdk-protocol-swap-velora-evm",
-          };
-        } finally {
-          if (readOnlyAccount !== account) {
-            await maybeDispose(readOnlyAccount);
-          }
-        }
+        assertLidoSupportedNetwork(runtimeConfig.network);
+        const contracts = this.#getLidoContracts(runtimeConfig.network);
+        const [stEthMetadata, wstEthMetadata, rates, stakingAprResult] = await Promise.all([
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
+          this.#readLidoSampleRates(runtimeConfig),
+          this.#readLidoStakingApr(runtimeConfig),
+        ]);
+        return {
+          network: runtimeConfig.network,
+          chainId: runtimeConfig.chainId,
+          accountIndex,
+          protocol: "lido",
+          preferredPositionToken: "wstETH",
+          stakingAsset: {
+            type: "native",
+            symbol: runtimeConfig.nativeSymbol,
+            decimals: 18,
+          },
+          referralAddress: this.#getLidoReferralAddress(),
+          contracts: {
+            stETH: contracts.steth.address,
+            wstETH: contracts.wsteth.address,
+            referralStaker: contracts.referralStaker,
+            withdrawalQueue: contracts.withdrawalQueue,
+          },
+          stEthMetadata,
+          wstEthMetadata,
+          sampleRates: rates,
+          stakingApr: stakingAprResult.data,
+          stakingAprError: stakingAprResult.error,
+          withdrawalLimits: {
+            minStEthAmountRaw: LIDO_MIN_STETH_WITHDRAWAL_AMOUNT.toString(),
+            minStEthAmountFormatted: formatUnits(LIDO_MIN_STETH_WITHDRAWAL_AMOUNT, LIDO_STETH_DECIMALS),
+            maxStEthAmountRaw: LIDO_MAX_STETH_WITHDRAWAL_AMOUNT.toString(),
+            maxStEthAmountFormatted: formatUnits(LIDO_MAX_STETH_WITHDRAWAL_AMOUNT, LIDO_STETH_DECIMALS),
+          },
+          source: "lido-contracts",
+        };
       }
     );
   }
 
-  async quoteLifiSwap({
-    seedPhrase,
-    address,
-    tokenIn,
-    destinationChain,
-    outputToken,
-    destinationAddress,
-    tokenInAmount,
-    slippage = DEFAULT_LIFI_SLIPPAGE,
-    allowBridges = null,
-    denyBridges = null,
-    preferBridges = null,
-    accountIndex = 0,
-    network,
-  }) {
+  async getLidoPositions({ seedPhrase, address, accountIndex = 0, network }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertLifiSupportedNetwork(runtimeConfig.network);
-        const swapRequest = buildLifiEvmSwapRequest({
-          tokenIn,
-          destinationChain,
-          outputToken,
-          destinationAddress,
-          tokenInAmount,
-          slippage,
-          allowBridges,
-          denyBridges,
-          preferBridges,
-        });
-        const sourceAddress = await account.getAddress();
-        const plan = await this.#buildLifiEvmSwapPlan({
-          account,
-          runtimeConfig,
-          address: sourceAddress,
-          swapRequest,
-          tolerateSwapFeeFailure: true,
-        });
-        return this.#formatLifiSwapResponse({
+        assertLidoSupportedNetwork(runtimeConfig.network);
+        const accountAddress = await account.getAddress();
+        const contracts = this.#getLidoContracts(runtimeConfig.network);
+        const [nativeBalance, stEthMetadata, wstEthMetadata, stEthBalance, wstEthBalance] = await Promise.all([
+          account.getBalance(),
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
+          this.#readTokenBalanceWithFallback({
+            account,
+            runtimeConfig,
+            tokenAddress: contracts.steth.address,
+            ownerAddress: accountAddress,
+          }),
+          this.#readTokenBalanceWithFallback({
+            account,
+            runtimeConfig,
+            tokenAddress: contracts.wsteth.address,
+            ownerAddress: accountAddress,
+          }),
+        ]);
+        const wstEthAsStEth = await this.#quoteLidoOutputRaw({
           runtimeConfig,
-          accountIndex,
-          address: sourceAddress,
-          swapRequest,
-          plan,
+          operation: "unwrap_wsteth",
+          amount: wstEthBalance,
+          fromAddress: accountAddress,
         });
-      }
-    );
-  }
-
-  async swap({
+        const stEthEquivalentTotal = stEthBalance + wstEthAsStEth;
+        const positions = [];
+        if (stEthBalance > 0n) {
+          positions.push({
+            asset: "stETH",
+            tokenAddress: contracts.steth.address,
+            tokenMetadata: stEthMetadata,
+            balanceRaw: stEthBalance.toString(),
+            balanceFormatted: formatUnits(stEthBalance, stEthMetadata.decimals),
+            stEthEquivalentRaw: stEthBalance.toString(),
+            stEthEquivalentFormatted: formatUnits(stEthBalance, stEthMetadata.decimals),
+          });
+        }
+        if (wstEthBalance > 0n) {
+          positions.push({
+            asset: "wstETH",
+            tokenAddress: contracts.wsteth.address,
+            tokenMetadata: wstEthMetadata,
+            balanceRaw: wstEthBalance.toString(),
+            balanceFormatted: formatUnits(wstEthBalance, wstEthMetadata.decimals),
+            stEthEquivalentRaw: wstEthAsStEth.toString(),
+            stEthEquivalentFormatted: formatUnits(wstEthAsStEth, stEthMetadata.decimals),
+          });
+        }
+        return {
+          network: runtimeConfig.network,
+          chainId: runtimeConfig.chainId,
+          accountIndex,
+          address: accountAddress,
+          protocol: "lido",
+          preferredPositionToken: "wstETH",
+          contracts: {
+            stETH: contracts.steth.address,
+            wstETH: contracts.wsteth.address,
+            referralStaker: contracts.referralStaker,
+            withdrawalQueue: contracts.withdrawalQueue,
+          },
+          nativeBalanceWei: BigInt(nativeBalance || 0).toString(),
+          nativeBalanceFormatted: formatUnits(BigInt(nativeBalance || 0), 18),
+          stEthEquivalentTotalRaw: stEthEquivalentTotal.toString(),
+          stEthEquivalentTotalFormatted: formatUnits(stEthEquivalentTotal, stEthMetadata.decimals),
+          positionCount: positions.length,
+          positions,
+          source: "lido-contracts",
+        };
+      }
+    );
+  }
+
+  async getLidoWithdrawalRequests({ seedPhrase, address, accountIndex = 0, network }) {
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertLidoSupportedNetwork(runtimeConfig.network);
+        const accountAddress = await account.getAddress();
+        const contracts = this.#getLidoContracts(runtimeConfig.network);
+        const [stEthMetadata, wstEthMetadata, requestIds] = await Promise.all([
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.steth),
+          this.#getLidoTokenMetadata(runtimeConfig, contracts.wsteth),
+          this.#getLidoWithdrawalRequestIds(runtimeConfig, accountAddress),
+        ]);
+        const statuses = requestIds.length
+          ? await this.#getLidoWithdrawalStatuses(runtimeConfig, requestIds)
+          : [];
+        const requests = statuses.map((status) =>
+          this.#formatLidoWithdrawalStatus(status, stEthMetadata, wstEthMetadata)
+        );
+        const claimableCount = requests.filter((request) => request.claimable).length;
+        return {
+          network: runtimeConfig.network,
+          chainId: runtimeConfig.chainId,
+          accountIndex,
+          address: accountAddress,
+          protocol: "lido",
+          withdrawalQueue: contracts.withdrawalQueue,
+          requestCount: requests.length,
+          claimableCount,
+          requests,
+          source: "lido-contracts",
+        };
+      }
+    );
+  }
+
+  async quoteLidoOperation({
     seedPhrase,
-    tokenIn,
-    tokenOut,
-    tokenInAmount,
+    address,
+    operation,
+    amount,
+    accountIndex = 0,
+    network,
+  }) {
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertLidoSupportedNetwork(runtimeConfig.network);
+        const request = buildLidoOperationRequest({ operation, amount });
+        const accountAddress = await account.getAddress();
+        const plan = await this.#buildLidoOperationPlan({
+          account,
+          runtimeConfig,
+          address: accountAddress,
+          request,
+          tolerateOperationFeeFailure: true,
+        });
+        return this.#formatLidoOperationResponse({
+          runtimeConfig,
+          accountIndex,
+          address: accountAddress,
+          request,
+          plan,
+        });
+      }
+    );
+  }
+
+  async sendLidoOperation({
+    seedPhrase,
+    operation,
+    amount,
     accountIndex = 0,
     network,
     expectedQuoteFingerprint = null,
-    minimumTokenOutAmount = null,
   }) {
     return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertVeloraSupportedNetwork(runtimeConfig.network);
-      const swapRequest = buildSwapRequest({ tokenIn, tokenOut, tokenInAmount });
+      assertLidoSupportedNetwork(runtimeConfig.network);
+      const request = buildLidoOperationRequest({ operation, amount });
       const normalizedExpectedQuoteFingerprint =
         typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
           ? expectedQuoteFingerprint.trim()
           : null;
-      const requestedMinimumTokenOutAmount =
-        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
-          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
-          : null;
       const address = await account.getAddress();
-      let initialPlan = await this.#buildVeloraSwapPlan({
+      let initialPlan = await this.#buildLidoOperationPlan({
         account,
         runtimeConfig,
-        swapRequest,
+        address,
+        request,
+        tolerateOperationFeeFailure: true,
       });
-      const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
-        this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenIn, initialPlan.priceRoute?.srcDecimals),
-        this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenOut, initialPlan.priceRoute?.destDecimals),
-      ]);
-      this.#assertExpectedSwapFingerprint(
+      this.#assertExpectedLidoFingerprint(
         normalizedExpectedQuoteFingerprint,
         initialPlan.quoteFingerprint
       );
-      this.#assertMinimumSwapOutput(
-        requestedMinimumTokenOutAmount,
-        initialPlan.minimumTokenOutAmount,
-        initialPlan.tokenOutAmount
-      );
 
-      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
+      const approvalExecution = await this.#executeLidoApprovalsIfNeeded({
         account,
         runtimeConfig,
-        swapRequest,
+        request,
         plan: initialPlan,
       });
 
       let finalPlan = initialPlan;
       try {
         if (approvalExecution.performed) {
-          finalPlan = await this.#buildVeloraSwapPlan({
+          finalPlan = await this.#buildLidoOperationPlan({
             account,
             runtimeConfig,
-            swapRequest,
+            address,
+            request,
           });
-          this.#assertExpectedSwapFingerprint(
+          this.#assertExpectedLidoFingerprint(
             normalizedExpectedQuoteFingerprint,
             finalPlan.quoteFingerprint
           );
         }
-        this.#assertMinimumSwapOutput(
-          requestedMinimumTokenOutAmount,
-          finalPlan.minimumTokenOutAmount,
-          finalPlan.tokenOutAmount
-        );
-
-        const allowanceReadUncertain =
-          approvalExecution.performed && finalPlan.allowanceReadError !== null;
 
-        if (finalPlan.approval.required && !allowanceReadUncertain) {
+        if (finalPlan.approval.required) {
           throw createTaggedError(
-            "Swap still requires token approval after the approval step completed.",
-            "swap_approval_required",
+            "Lido operation still requires token approval after the approval step completed.",
+            "lido_approval_required",
             {
               spender: finalPlan.spender,
-              requiredAllowance: finalPlan.tokenInAmount.toString(),
+              requiredAllowance: finalPlan.amount.toString(),
               currentAllowance: finalPlan.currentAllowance.toString(),
             }
           );
         }
 
-        const effectiveSimulation = allowanceReadUncertain
-          ? await this.#simulatePreparedTransaction({
-              runtimeConfig,
-              from: address,
-              tx: finalPlan.swapTx,
-            })
-          : finalPlan.simulation;
-        this.#assertSimulationSucceeded(effectiveSimulation);
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
-        const result = {
-          hash,
-          fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
-          approvalFee: approvalExecution.totalFee.toString(),
-          tokenInAmount: finalPlan.tokenInAmount.toString(),
-          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
-          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-          ...(approvalExecution.resetAllowanceHash
-            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-            : {}),
-        };
-        return {
-          network: runtimeConfig.network,
-          chainId: runtimeConfig.chainId,
-          accountIndex,
-          address,
-          protocol: "velora",
-          executionSupported: true,
-          swapRequest,
-          tokenInMetadata,
-          tokenOutMetadata,
-          inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
-          outputAmountFormatted: formatUnits(finalPlan.tokenOutAmount, tokenOutMetadata.decimals),
-        quoteFingerprint: finalPlan.quoteFingerprint,
-        estimatedFeeWei: totalFee.toString(),
-        estimatedSwapFeeWei: finalPlan.swapFee.toString(),
-        estimatedApprovalFeeWei: approvalExecution.totalFee.toString(),
-        feeEstimateAvailable: true,
-        feeEstimateError: null,
-        slippageBps: finalPlan.slippageBps,
-        minimumOutputAmountRaw: finalPlan.minimumTokenOutAmount.toString(),
-        allowance: {
-          spender: finalPlan.spender,
-          currentAllowance: finalPlan.currentAllowance.toString(),
-          requiredAllowance: finalPlan.tokenInAmount.toString(),
-          approvalRequired: finalPlan.approval.required,
-            approvalSequence: finalPlan.approval.steps,
-            readError: finalPlan.allowanceReadError,
-          },
-          router: finalPlan.router,
-          simulation: effectiveSimulation,
-          swapTransaction: finalPlan.swapTransaction,
-          result,
-          source: "wdk-protocol-swap-velora-evm",
-        };
-      } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
-          account,
-          runtimeConfig,
-          tokenAddress: swapRequest.tokenIn,
-          spender: initialPlan.spender,
-          originalAllowance: initialPlan.currentAllowance,
-          approvalExecution,
-        });
-        this.#throwSwapFailureWithCleanup(error, cleanup);
-      }
-    });
-  }
+        if (finalPlan.operationFee === null) {
+          throw createTaggedError(
+            "Lido operation fee estimate was unavailable. Generate a new quote before sending.",
+            "lido_fee_unavailable",
+            {
+              operation: request.operation,
+              feeEstimateError: finalPlan.operationFeeError,
+            }
+          );
+        }
 
-  async sendLifiSwap({
-    seedPhrase,
-    tokenIn,
-    destinationChain,
-    outputToken,
-    destinationAddress,
-    tokenInAmount,
-    slippage = DEFAULT_LIFI_SLIPPAGE,
-    allowBridges = null,
-    denyBridges = null,
-    preferBridges = null,
-    accountIndex = 0,
-    network,
-    minimumTokenOutAmount = null,
-  }) {
-    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertLifiSupportedNetwork(runtimeConfig.network);
-      const swapRequest = buildLifiEvmSwapRequest({
-        tokenIn,
-        destinationChain,
-        outputToken,
-        destinationAddress,
-        tokenInAmount,
-        slippage,
-        allowBridges,
-        denyBridges,
-        preferBridges,
-      });
-      const requestedMinimumTokenOutAmount =
-        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
-          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
-          : null;
-      const sourceAddress = await account.getAddress();
-      let initialPlan = await this.#buildLifiEvmSwapPlan({
-        account,
-        runtimeConfig,
-        address: sourceAddress,
-        swapRequest,
-      });
-      this.#assertMinimumSwapOutput(
-        requestedMinimumTokenOutAmount,
-        initialPlan.minimumTokenOutAmount,
-        initialPlan.tokenOutAmount
-      );
-
-      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
-        account,
-        runtimeConfig,
-        swapRequest: {
-          tokenIn: swapRequest.tokenIn,
-        },
-        plan: initialPlan,
-      });
-
-      let finalPlan = initialPlan;
-      try {
-        if (approvalExecution.performed) {
-          finalPlan = await this.#buildLifiEvmSwapPlan({
-            account,
-            runtimeConfig,
-            address: sourceAddress,
-            swapRequest,
-          });
-        }
-        this.#assertMinimumSwapOutput(
-          requestedMinimumTokenOutAmount,
-          finalPlan.minimumTokenOutAmount,
-          finalPlan.tokenOutAmount
-        );
-
-        const allowanceReadUncertain =
-          approvalExecution.performed && finalPlan.allowanceReadError !== null;
-
-        if (finalPlan.approval.required && !allowanceReadUncertain) {
-          throw createTaggedError(
-            "LI.FI cross-chain swap still requires token approval after the approval step completed.",
-            "swap_approval_required",
-            {
-              spender: finalPlan.spender,
-              requiredAllowance: finalPlan.tokenInAmount.toString(),
-              currentAllowance: finalPlan.currentAllowance.toString(),
-            }
-          );
-        }
-
-        const effectiveSimulation = allowanceReadUncertain
-          ? await this.#simulatePreparedTransaction({
-              runtimeConfig,
-              from: sourceAddress,
-              tx: finalPlan.swapTx,
-            })
-          : finalPlan.simulation;
-        this.#assertSimulationSucceeded(effectiveSimulation);
-
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
-        const result = {
-          hash,
-          fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
-          approvalFee: approvalExecution.totalFee.toString(),
-          tokenInAmount: finalPlan.tokenInAmount.toString(),
-          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
-          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-          ...(approvalExecution.resetAllowanceHash
-            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-            : {}),
-        };
+        const result = await account.sendTransaction(finalPlan.operationTx);
+        const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
+        const totalFee = approvalExecution.totalFee + resultFee;
         return {
-          ...this.#formatLifiSwapResponse({
+          ...this.#formatLidoOperationResponse({
             runtimeConfig,
             accountIndex,
-            address: sourceAddress,
-            swapRequest,
+            address,
+            request,
             plan: {
               ...finalPlan,
-              simulation: effectiveSimulation,
-              swapFee: totalFee,
+              operationFee: resultFee,
               totalEstimatedFee: totalFee,
               approval: {
                 ...finalPlan.approval,
@@ -2316,358 +2920,938 @@ export class WdkEvmWalletService {
               },
             },
           }),
-          result,
+          result: {
+            ...result,
+            fee: resultFee.toString(),
+            totalFee: totalFee.toString(),
+            approvalFee: approvalExecution.totalFee.toString(),
+            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+            ...(approvalExecution.resetAllowanceHash
+              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+              : {}),
+          },
         };
       } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
+        const cleanup = await this.#restoreAllowanceAfterFailedLidoOperation({
           account,
           runtimeConfig,
-          tokenAddress: swapRequest.tokenIn,
+          tokenAddress: finalPlan.inputTokenAddress,
           spender: initialPlan.spender,
           originalAllowance: initialPlan.currentAllowance,
           approvalExecution,
         });
-        this.#throwSwapFailureWithCleanup(error, cleanup);
+        this.#throwLidoFailureWithCleanup(error, cleanup);
       }
     });
   }
 
-  async quoteUniswapSwap({
+  async quoteLidoWithdrawalOperation({
     seedPhrase,
     address,
-    tokenIn,
-    tokenOut,
-    tokenInAmount,
-    slippageBps,
+    operation,
+    amount,
+    requestId,
     accountIndex = 0,
     network,
   }) {
     return this.#withReadableAccount(
       { seedPhrase, address, accountIndex, network },
       async (account, runtimeConfig) => {
-        assertUniswapSupportedNetwork(runtimeConfig.network);
-        const swapRequest = buildUniswapSwapRequest({
-          tokenIn,
-          tokenOut,
-          tokenInAmount,
-          slippageBps:
-            slippageBps === undefined || slippageBps === null
-              ? this.config.uniswapDefaultSlippageBps
-              : slippageBps,
-        });
-        const swapperAddress = await account.getAddress();
-        const plan = await this.#buildUniswapSwapPlan({
+        assertLidoSupportedNetwork(runtimeConfig.network);
+        const request = buildLidoWithdrawalRequest({ operation, amount, requestId });
+        const accountAddress = await account.getAddress();
+        const plan = await this.#buildLidoWithdrawalPlan({
           account,
           runtimeConfig,
-          address: swapperAddress,
-          swapRequest,
+          address: accountAddress,
+          request,
+          tolerateOperationFeeFailure: true,
         });
-        return this.#formatUniswapSwapResponse({
+        return this.#formatLidoWithdrawalResponse({
           runtimeConfig,
           accountIndex,
-          address: swapperAddress,
-          swapRequest,
+          address: accountAddress,
+          request,
           plan,
         });
       }
     );
   }
 
-  async sendUniswapSwap({
+  async sendLidoWithdrawalOperation({
     seedPhrase,
-    tokenIn,
-    tokenOut,
-    tokenInAmount,
-    slippageBps,
+    operation,
+    amount,
+    requestId,
     accountIndex = 0,
     network,
     expectedQuoteFingerprint = null,
-    minimumTokenOutAmount = null,
   }) {
     return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      assertUniswapSupportedNetwork(runtimeConfig.network);
-      const swapRequest = buildUniswapSwapRequest({
-        tokenIn,
-        tokenOut,
-        tokenInAmount,
-        slippageBps:
-          slippageBps === undefined || slippageBps === null
-            ? this.config.uniswapDefaultSlippageBps
-            : slippageBps,
-      });
+      assertLidoSupportedNetwork(runtimeConfig.network);
+      const request = buildLidoWithdrawalRequest({ operation, amount, requestId });
       const normalizedExpectedQuoteFingerprint =
         typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
           ? expectedQuoteFingerprint.trim()
           : null;
-      const requestedMinimumTokenOutAmount =
-        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
-          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
-          : null;
       const address = await account.getAddress();
-      let initialPlan = await this.#buildUniswapSwapPlan({
+      let initialPlan = await this.#buildLidoWithdrawalPlan({
         account,
         runtimeConfig,
         address,
-        swapRequest,
+        request,
+        tolerateOperationFeeFailure: true,
       });
-      this.#assertExpectedSwapFingerprint(
+      this.#assertExpectedLidoWithdrawalFingerprint(
         normalizedExpectedQuoteFingerprint,
         initialPlan.quoteFingerprint
       );
-      this.#assertMinimumSwapOutput(
-        requestedMinimumTokenOutAmount,
-        initialPlan.minimumTokenOutAmount,
-        initialPlan.tokenOutAmount
-      );
 
-      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
+      const approvalExecution = await this.#executeLidoWithdrawalApprovalsIfNeeded({
         account,
         runtimeConfig,
-        swapRequest: { tokenIn: swapRequest.tokenIn },
+        request,
         plan: initialPlan,
       });
 
       let finalPlan = initialPlan;
       try {
         if (approvalExecution.performed) {
-          // Re-fetch after approval to obtain fresh permitData (the deadline/nonce are short-lived).
-          finalPlan = await this.#buildUniswapSwapPlan({
+          finalPlan = await this.#buildLidoWithdrawalPlan({
             account,
             runtimeConfig,
             address,
-            swapRequest,
+            request,
           });
-          this.#assertExpectedSwapFingerprint(
+          this.#assertExpectedLidoWithdrawalFingerprint(
             normalizedExpectedQuoteFingerprint,
             finalPlan.quoteFingerprint
           );
         }
-        this.#assertMinimumSwapOutput(
-          requestedMinimumTokenOutAmount,
-          finalPlan.minimumTokenOutAmount,
-          finalPlan.tokenOutAmount
-        );
 
-        const allowanceReadUncertain =
-          approvalExecution.performed && finalPlan.allowanceReadError !== null;
-        if (finalPlan.approval.required && !allowanceReadUncertain) {
+        if (finalPlan.approval.required) {
           throw createTaggedError(
-            "Uniswap swap still requires token approval after the approval step completed.",
-            "swap_approval_required",
+            "Lido withdrawal still requires token approval after the approval step completed.",
+            "lido_withdrawal_approval_required",
             {
               spender: finalPlan.spender,
-              requiredAllowance: finalPlan.tokenInAmount.toString(),
+              requiredAllowance: finalPlan.requiredAllowance.toString(),
               currentAllowance: finalPlan.currentAllowance.toString(),
             }
           );
         }
 
-        const signature =
-          finalPlan.isNativeTokenIn || !finalPlan.permitData
-            ? null
-            : await this.#signUniswapPermit(account, finalPlan.permitData, runtimeConfig);
+        if (finalPlan.operationFee === null) {
+          throw createTaggedError(
+            "Lido withdrawal fee estimate was unavailable. Generate a new quote before sending.",
+            "lido_withdrawal_fee_unavailable",
+            {
+              operation: request.operation,
+              feeEstimateError: finalPlan.operationFeeError,
+            }
+          );
+        }
 
-        const swapTx = await this.#fetchUniswapSwapCalldata({
-          runtimeConfig,
-          quoteResponse: finalPlan.quoteResponse,
-          permitData: finalPlan.permitData,
-          signature,
-        });
-
-        const simulation = await this.#simulatePreparedTransaction({
-          runtimeConfig,
-          from: address,
-          tx: swapTx,
-        });
-        this.#assertSimulationSucceeded(simulation);
-
-        const { hash } = await account.sendTransaction(swapTx);
-        const result = {
-          hash,
-          approvalFee: approvalExecution.totalFee.toString(),
-          tokenInAmount: finalPlan.tokenInAmount.toString(),
-          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
-          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
-          ...(approvalExecution.resetAllowanceHash
-            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
-            : {}),
-        };
+        const result = await account.sendTransaction(finalPlan.operationTx);
+        const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
+        const totalFee = approvalExecution.totalFee + resultFee;
         return {
-          ...(await this.#formatUniswapSwapResponse({
+          ...this.#formatLidoWithdrawalResponse({
             runtimeConfig,
             accountIndex,
             address,
-            swapRequest,
+            request,
             plan: {
               ...finalPlan,
+              operationFee: resultFee,
+              totalEstimatedFee: totalFee,
               approval: {
                 ...finalPlan.approval,
                 estimatedFee: approvalExecution.totalFee,
               },
             },
-          })),
-          simulation,
-          swapTransaction: { to: swapTx.to, value: swapTx.value.toString(), dataHash: sha256Hex(swapTx.data) },
-          result,
+          }),
+          result: {
+            ...result,
+            fee: resultFee.toString(),
+            totalFee: totalFee.toString(),
+            approvalFee: approvalExecution.totalFee.toString(),
+            ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+            ...(approvalExecution.resetAllowanceHash
+              ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+              : {}),
+          },
         };
       } catch (error) {
-        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
+        const cleanup = await this.#restoreAllowanceAfterFailedLidoWithdrawal({
           account,
           runtimeConfig,
-          tokenAddress: swapRequest.tokenIn,
+          tokenAddress: finalPlan.inputTokenAddress,
           spender: initialPlan.spender,
           originalAllowance: initialPlan.currentAllowance,
           approvalExecution,
         });
-        this.#throwSwapFailureWithCleanup(error, cleanup);
+        this.#throwLidoWithdrawalFailureWithCleanup(error, cleanup);
       }
     });
   }
 
-  async #getUniswapTokenMetadata(runtimeConfig, tokenAddress) {
-    if (isZeroAddress(tokenAddress)) {
-      return {
-        address: ZERO_ADDRESS,
-        name: runtimeConfig.nativeSymbol === "ETH" ? "Ether" : runtimeConfig.nativeSymbol,
-        symbol: runtimeConfig.nativeSymbol,
-        decimals: 18,
-        verified: true,
-        source: "native-asset",
-      };
-    }
-    return this.#getTokenMetadata(runtimeConfig, tokenAddress);
-  }
-
-  async #formatUniswapSwapResponse({ runtimeConfig, accountIndex, address, swapRequest, plan }) {
-    const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
-      this.#getUniswapTokenMetadata(runtimeConfig, swapRequest.tokenIn),
-      this.#getUniswapTokenMetadata(runtimeConfig, swapRequest.tokenOut),
-    ]);
-    return {
-      network: runtimeConfig.network,
-      chainId: runtimeConfig.chainId,
-      accountIndex,
-      address,
-      protocol: "uniswap",
-      executionSupported: true,
-      routing: "CLASSIC",
-      swapRequest: {
-        tokenIn: swapRequest.tokenIn,
-        tokenOut: swapRequest.tokenOut,
-        tokenInAmount: swapRequest.tokenInAmount.toString(),
-      },
-      tokenInMetadata,
-      tokenOutMetadata,
-      inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
-      outputAmountFormatted: formatUnits(plan.tokenOutAmount, tokenOutMetadata.decimals),
-      quoteFingerprint: plan.quoteFingerprint,
-      slippageBps: plan.slippageBps,
-      minimumOutputAmountRaw: plan.minimumTokenOutAmount.toString(),
-      permitRequired: plan.permitData !== null,
-      gasFeeWei: plan.gasFee,
-      gasFeeUSD: plan.gasFeeUSD,
-      estimatedApprovalFeeWei: plan.approval.estimatedFee.toString(),
-      allowance: {
-        spender: plan.spender,
-        currentAllowance: plan.currentAllowance.toString(),
-        requiredAllowance: plan.tokenInAmount.toString(),
-        approvalRequired: plan.approval.required,
-        approvalSequence: plan.approval.steps,
-        readError: plan.allowanceReadError,
-      },
-      router: plan.router,
-      source: "uniswap-trading-api",
-    };
-  }
-
-  async quoteNativeTransfer({ seedPhrase, to, value, accountIndex = 0, network }) {
-    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      const tx = {
-        to: normalizeAddress(to, "to"),
-        value: assertPositiveBigIntString(value, "value"),
-      };
-      const quote = await account.quoteSendTransaction(tx);
-      return {
-        network: runtimeConfig.network,
-        chainId: runtimeConfig.chainId,
-        accountIndex,
-        transaction: tx,
-        quote,
-        source: "wdk-wallet-evm",
-      };
-    });
-  }
-
-  async sendNativeTransfer({ seedPhrase, to, value, accountIndex = 0, network }) {
-    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      const tx = {
-        to: normalizeAddress(to, "to"),
-        value: assertPositiveBigIntString(value, "value"),
-      };
-      const result = await account.sendTransaction(tx);
-      return {
-        network: runtimeConfig.network,
-        chainId: runtimeConfig.chainId,
-        accountIndex,
-        transaction: tx,
-        result,
-        source: "wdk-wallet-evm",
-      };
-    });
-  }
-
-  async quoteTokenTransfer({
+  async quoteSwap({
     seedPhrase,
-    tokenAddress,
-    recipient,
-    amount,
+    address,
+    tokenIn,
+    tokenOut,
+    tokenInAmount,
     accountIndex = 0,
     network,
   }) {
-    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      const transfer = {
-        token: normalizeAddress(tokenAddress, "tokenAddress"),
-        recipient: normalizeAddress(recipient, "recipient"),
-        amount: assertPositiveBigIntString(amount, "amount"),
-      };
-      const ownerAddress = await account.getAddress();
-      const { tokenMetadata } = await this.#prepareTokenTransferContext({
-        account,
-        runtimeConfig,
-        transfer,
-        ownerAddress,
-      });
-      let quote;
-      try {
-        quote = await account.quoteTransfer(transfer);
-      } catch (error) {
-        if (isRecoverableTokenTransferSimulationFailure(error)) {
-          throw createTaggedError(
-            "Token transfer could not be simulated by the token contract.",
-            "token_transfer_failed",
-            {
-              network: runtimeConfig.network,
-              tokenAddress: transfer.token,
-              ownerAddress,
-              recipient: transfer.recipient,
-              amount: transfer.amount.toString(),
-              underlying:
-                error instanceof Error
-                  ? {
-                      message: error.message,
-                      code: String(error.errorCode || error.code || "").trim() || null,
-                    }
-                  : {
-                      message: String(error),
-                      code: null,
-                    },
-            }
-          );
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertVeloraSupportedNetwork(runtimeConfig.network);
+        const swapRequest = buildSwapRequest({ tokenIn, tokenOut, tokenInAmount });
+        const address = await account.getAddress();
+        const readOnlyAccount =
+          typeof account.toReadOnlyAccount === "function" ? await account.toReadOnlyAccount() : account;
+        try {
+          const plan = await this.#buildVeloraSwapPlan({
+            account: readOnlyAccount,
+            runtimeConfig,
+            swapRequest,
+            tolerateSwapFeeFailure: true,
+          });
+          const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
+            this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenIn, plan.priceRoute?.srcDecimals),
+            this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenOut, plan.priceRoute?.destDecimals),
+          ]);
+          const quote = {
+            fee: plan.swapFee !== null ? plan.swapFee.toString() : null,
+            tokenInAmount: plan.tokenInAmount.toString(),
+            tokenOutAmount: plan.tokenOutAmount.toString(),
+            priceRoute: plan.priceRoute,
+          };
+          return {
+            network: runtimeConfig.network,
+            chainId: runtimeConfig.chainId,
+            accountIndex,
+            address,
+            protocol: "velora",
+            executionSupported: true,
+            swapRequest,
+            tokenInMetadata,
+            tokenOutMetadata,
+            inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
+            outputAmountFormatted: formatUnits(plan.tokenOutAmount, tokenOutMetadata.decimals),
+            quoteFingerprint: plan.quoteFingerprint,
+            estimatedFeeWei:
+              plan.totalEstimatedFee !== null ? plan.totalEstimatedFee.toString() : null,
+            estimatedSwapFeeWei: plan.swapFee !== null ? plan.swapFee.toString() : null,
+            estimatedApprovalFeeWei: plan.approval.estimatedFee.toString(),
+            feeEstimateAvailable: plan.swapFee !== null,
+            feeEstimateError: plan.swapFeeError,
+            slippageBps: plan.slippageBps,
+            minimumOutputAmountRaw: plan.minimumTokenOutAmount.toString(),
+            allowance: {
+              spender: plan.spender,
+              currentAllowance: plan.currentAllowance.toString(),
+              requiredAllowance: plan.tokenInAmount.toString(),
+              approvalRequired: plan.approval.required,
+              approvalSequence: plan.approval.steps,
+              readError: plan.allowanceReadError,
+            },
+            router: plan.router,
+            simulation: plan.simulation,
+            swapTransaction: plan.swapTransaction,
+            quote,
+            source: "wdk-protocol-swap-velora-evm",
+          };
+        } finally {
+          if (readOnlyAccount !== account) {
+            await maybeDispose(readOnlyAccount);
+          }
         }
-        throw error;
       }
-      return {
-        network: runtimeConfig.network,
+    );
+  }
+
+  async quoteLifiSwap({
+    seedPhrase,
+    address,
+    tokenIn,
+    destinationChain,
+    outputToken,
+    destinationAddress,
+    tokenInAmount,
+    slippage = DEFAULT_LIFI_SLIPPAGE,
+    allowBridges = null,
+    denyBridges = null,
+    preferBridges = null,
+    accountIndex = 0,
+    network,
+  }) {
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertLifiSupportedNetwork(runtimeConfig.network);
+        const swapRequest = buildLifiEvmSwapRequest({
+          tokenIn,
+          destinationChain,
+          outputToken,
+          destinationAddress,
+          tokenInAmount,
+          slippage,
+          allowBridges,
+          denyBridges,
+          preferBridges,
+        });
+        const sourceAddress = await account.getAddress();
+        const plan = await this.#buildLifiEvmSwapPlan({
+          account,
+          runtimeConfig,
+          address: sourceAddress,
+          swapRequest,
+          tolerateSwapFeeFailure: true,
+        });
+        return this.#formatLifiSwapResponse({
+          runtimeConfig,
+          accountIndex,
+          address: sourceAddress,
+          swapRequest,
+          plan,
+        });
+      }
+    );
+  }
+
+  async swap({
+    seedPhrase,
+    tokenIn,
+    tokenOut,
+    tokenInAmount,
+    accountIndex = 0,
+    network,
+    expectedQuoteFingerprint = null,
+    minimumTokenOutAmount = null,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      assertVeloraSupportedNetwork(runtimeConfig.network);
+      const swapRequest = buildSwapRequest({ tokenIn, tokenOut, tokenInAmount });
+      const normalizedExpectedQuoteFingerprint =
+        typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
+          ? expectedQuoteFingerprint.trim()
+          : null;
+      const requestedMinimumTokenOutAmount =
+        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
+          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
+          : null;
+      const address = await account.getAddress();
+      let initialPlan = await this.#buildVeloraSwapPlan({
+        account,
+        runtimeConfig,
+        swapRequest,
+      });
+      const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
+        this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenIn, initialPlan.priceRoute?.srcDecimals),
+        this.#getSwapTokenMetadata(runtimeConfig, swapRequest.tokenOut, initialPlan.priceRoute?.destDecimals),
+      ]);
+      this.#assertExpectedSwapFingerprint(
+        normalizedExpectedQuoteFingerprint,
+        initialPlan.quoteFingerprint
+      );
+      this.#assertMinimumSwapOutput(
+        requestedMinimumTokenOutAmount,
+        initialPlan.minimumTokenOutAmount,
+        initialPlan.tokenOutAmount
+      );
+
+      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
+        account,
+        runtimeConfig,
+        swapRequest,
+        plan: initialPlan,
+      });
+
+      let finalPlan = initialPlan;
+      try {
+        if (approvalExecution.performed) {
+          finalPlan = await this.#buildVeloraSwapPlan({
+            account,
+            runtimeConfig,
+            swapRequest,
+          });
+          this.#assertExpectedSwapFingerprint(
+            normalizedExpectedQuoteFingerprint,
+            finalPlan.quoteFingerprint
+          );
+        }
+        this.#assertMinimumSwapOutput(
+          requestedMinimumTokenOutAmount,
+          finalPlan.minimumTokenOutAmount,
+          finalPlan.tokenOutAmount
+        );
+
+        const allowanceReadUncertain =
+          approvalExecution.performed && finalPlan.allowanceReadError !== null;
+
+        if (finalPlan.approval.required && !allowanceReadUncertain) {
+          throw createTaggedError(
+            "Swap still requires token approval after the approval step completed.",
+            "swap_approval_required",
+            {
+              spender: finalPlan.spender,
+              requiredAllowance: finalPlan.tokenInAmount.toString(),
+              currentAllowance: finalPlan.currentAllowance.toString(),
+            }
+          );
+        }
+
+        const effectiveSimulation = allowanceReadUncertain
+          ? await this.#simulatePreparedTransaction({
+              runtimeConfig,
+              from: address,
+              tx: finalPlan.swapTx,
+            })
+          : finalPlan.simulation;
+        this.#assertSimulationSucceeded(effectiveSimulation);
+        const { hash } = await account.sendTransaction(finalPlan.swapTx);
+        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const result = {
+          hash,
+          fee: totalFee.toString(),
+          swapFee: finalPlan.swapFee.toString(),
+          approvalFee: approvalExecution.totalFee.toString(),
+          tokenInAmount: finalPlan.tokenInAmount.toString(),
+          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
+          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+          ...(approvalExecution.resetAllowanceHash
+            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+            : {}),
+        };
+        return {
+          network: runtimeConfig.network,
+          chainId: runtimeConfig.chainId,
+          accountIndex,
+          address,
+          protocol: "velora",
+          executionSupported: true,
+          swapRequest,
+          tokenInMetadata,
+          tokenOutMetadata,
+          inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
+          outputAmountFormatted: formatUnits(finalPlan.tokenOutAmount, tokenOutMetadata.decimals),
+        quoteFingerprint: finalPlan.quoteFingerprint,
+        estimatedFeeWei: totalFee.toString(),
+        estimatedSwapFeeWei: finalPlan.swapFee.toString(),
+        estimatedApprovalFeeWei: approvalExecution.totalFee.toString(),
+        feeEstimateAvailable: true,
+        feeEstimateError: null,
+        slippageBps: finalPlan.slippageBps,
+        minimumOutputAmountRaw: finalPlan.minimumTokenOutAmount.toString(),
+        allowance: {
+          spender: finalPlan.spender,
+          currentAllowance: finalPlan.currentAllowance.toString(),
+          requiredAllowance: finalPlan.tokenInAmount.toString(),
+          approvalRequired: finalPlan.approval.required,
+            approvalSequence: finalPlan.approval.steps,
+            readError: finalPlan.allowanceReadError,
+          },
+          router: finalPlan.router,
+          simulation: effectiveSimulation,
+          swapTransaction: finalPlan.swapTransaction,
+          result,
+          source: "wdk-protocol-swap-velora-evm",
+        };
+      } catch (error) {
+        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
+          account,
+          runtimeConfig,
+          tokenAddress: swapRequest.tokenIn,
+          spender: initialPlan.spender,
+          originalAllowance: initialPlan.currentAllowance,
+          approvalExecution,
+        });
+        this.#throwSwapFailureWithCleanup(error, cleanup);
+      }
+    });
+  }
+
+  async sendLifiSwap({
+    seedPhrase,
+    tokenIn,
+    destinationChain,
+    outputToken,
+    destinationAddress,
+    tokenInAmount,
+    slippage = DEFAULT_LIFI_SLIPPAGE,
+    allowBridges = null,
+    denyBridges = null,
+    preferBridges = null,
+    accountIndex = 0,
+    network,
+    minimumTokenOutAmount = null,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      assertLifiSupportedNetwork(runtimeConfig.network);
+      const swapRequest = buildLifiEvmSwapRequest({
+        tokenIn,
+        destinationChain,
+        outputToken,
+        destinationAddress,
+        tokenInAmount,
+        slippage,
+        allowBridges,
+        denyBridges,
+        preferBridges,
+      });
+      const requestedMinimumTokenOutAmount =
+        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
+          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
+          : null;
+      const sourceAddress = await account.getAddress();
+      let initialPlan = await this.#buildLifiEvmSwapPlan({
+        account,
+        runtimeConfig,
+        address: sourceAddress,
+        swapRequest,
+      });
+      this.#assertMinimumSwapOutput(
+        requestedMinimumTokenOutAmount,
+        initialPlan.minimumTokenOutAmount,
+        initialPlan.tokenOutAmount
+      );
+
+      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
+        account,
+        runtimeConfig,
+        swapRequest: {
+          tokenIn: swapRequest.tokenIn,
+        },
+        plan: initialPlan,
+      });
+
+      let finalPlan = initialPlan;
+      try {
+        if (approvalExecution.performed) {
+          finalPlan = await this.#buildLifiEvmSwapPlan({
+            account,
+            runtimeConfig,
+            address: sourceAddress,
+            swapRequest,
+          });
+        }
+        this.#assertMinimumSwapOutput(
+          requestedMinimumTokenOutAmount,
+          finalPlan.minimumTokenOutAmount,
+          finalPlan.tokenOutAmount
+        );
+
+        const allowanceReadUncertain =
+          approvalExecution.performed && finalPlan.allowanceReadError !== null;
+
+        if (finalPlan.approval.required && !allowanceReadUncertain) {
+          throw createTaggedError(
+            "LI.FI cross-chain swap still requires token approval after the approval step completed.",
+            "swap_approval_required",
+            {
+              spender: finalPlan.spender,
+              requiredAllowance: finalPlan.tokenInAmount.toString(),
+              currentAllowance: finalPlan.currentAllowance.toString(),
+            }
+          );
+        }
+
+        const effectiveSimulation = allowanceReadUncertain
+          ? await this.#simulatePreparedTransaction({
+              runtimeConfig,
+              from: sourceAddress,
+              tx: finalPlan.swapTx,
+            })
+          : finalPlan.simulation;
+        this.#assertSimulationSucceeded(effectiveSimulation);
+
+        const { hash } = await account.sendTransaction(finalPlan.swapTx);
+        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const result = {
+          hash,
+          fee: totalFee.toString(),
+          swapFee: finalPlan.swapFee.toString(),
+          approvalFee: approvalExecution.totalFee.toString(),
+          tokenInAmount: finalPlan.tokenInAmount.toString(),
+          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
+          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+          ...(approvalExecution.resetAllowanceHash
+            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+            : {}),
+        };
+        return {
+          ...this.#formatLifiSwapResponse({
+            runtimeConfig,
+            accountIndex,
+            address: sourceAddress,
+            swapRequest,
+            plan: {
+              ...finalPlan,
+              simulation: effectiveSimulation,
+              swapFee: totalFee,
+              totalEstimatedFee: totalFee,
+              approval: {
+                ...finalPlan.approval,
+                estimatedFee: approvalExecution.totalFee,
+              },
+            },
+          }),
+          result,
+        };
+      } catch (error) {
+        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
+          account,
+          runtimeConfig,
+          tokenAddress: swapRequest.tokenIn,
+          spender: initialPlan.spender,
+          originalAllowance: initialPlan.currentAllowance,
+          approvalExecution,
+        });
+        this.#throwSwapFailureWithCleanup(error, cleanup);
+      }
+    });
+  }
+
+  async quoteUniswapSwap({
+    seedPhrase,
+    address,
+    tokenIn,
+    tokenOut,
+    tokenInAmount,
+    slippageBps,
+    accountIndex = 0,
+    network,
+  }) {
+    return this.#withReadableAccount(
+      { seedPhrase, address, accountIndex, network },
+      async (account, runtimeConfig) => {
+        assertUniswapSupportedNetwork(runtimeConfig.network);
+        const swapRequest = buildUniswapSwapRequest({
+          tokenIn,
+          tokenOut,
+          tokenInAmount,
+          slippageBps:
+            slippageBps === undefined || slippageBps === null
+              ? this.config.uniswapDefaultSlippageBps
+              : slippageBps,
+        });
+        const swapperAddress = await account.getAddress();
+        const plan = await this.#buildUniswapSwapPlan({
+          account,
+          runtimeConfig,
+          address: swapperAddress,
+          swapRequest,
+        });
+        return this.#formatUniswapSwapResponse({
+          runtimeConfig,
+          accountIndex,
+          address: swapperAddress,
+          swapRequest,
+          plan,
+        });
+      }
+    );
+  }
+
+  async sendUniswapSwap({
+    seedPhrase,
+    tokenIn,
+    tokenOut,
+    tokenInAmount,
+    slippageBps,
+    accountIndex = 0,
+    network,
+    expectedQuoteFingerprint = null,
+    minimumTokenOutAmount = null,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      assertUniswapSupportedNetwork(runtimeConfig.network);
+      const swapRequest = buildUniswapSwapRequest({
+        tokenIn,
+        tokenOut,
+        tokenInAmount,
+        slippageBps:
+          slippageBps === undefined || slippageBps === null
+            ? this.config.uniswapDefaultSlippageBps
+            : slippageBps,
+      });
+      const normalizedExpectedQuoteFingerprint =
+        typeof expectedQuoteFingerprint === "string" && expectedQuoteFingerprint.trim()
+          ? expectedQuoteFingerprint.trim()
+          : null;
+      const requestedMinimumTokenOutAmount =
+        minimumTokenOutAmount !== null && minimumTokenOutAmount !== undefined
+          ? assertPositiveBigIntString(minimumTokenOutAmount, "minimumTokenOutAmount")
+          : null;
+      const address = await account.getAddress();
+      let initialPlan = await this.#buildUniswapSwapPlan({
+        account,
+        runtimeConfig,
+        address,
+        swapRequest,
+      });
+      this.#assertExpectedSwapFingerprint(
+        normalizedExpectedQuoteFingerprint,
+        initialPlan.quoteFingerprint
+      );
+      this.#assertMinimumSwapOutput(
+        requestedMinimumTokenOutAmount,
+        initialPlan.minimumTokenOutAmount,
+        initialPlan.tokenOutAmount
+      );
+
+      const approvalExecution = await this.#executeSwapApprovalsIfNeeded({
+        account,
+        runtimeConfig,
+        swapRequest: { tokenIn: swapRequest.tokenIn },
+        plan: initialPlan,
+      });
+
+      let finalPlan = initialPlan;
+      try {
+        if (approvalExecution.performed) {
+          // Re-fetch after approval to obtain fresh permitData (the deadline/nonce are short-lived).
+          finalPlan = await this.#buildUniswapSwapPlan({
+            account,
+            runtimeConfig,
+            address,
+            swapRequest,
+          });
+          this.#assertExpectedSwapFingerprint(
+            normalizedExpectedQuoteFingerprint,
+            finalPlan.quoteFingerprint
+          );
+        }
+        this.#assertMinimumSwapOutput(
+          requestedMinimumTokenOutAmount,
+          finalPlan.minimumTokenOutAmount,
+          finalPlan.tokenOutAmount
+        );
+
+        const allowanceReadUncertain =
+          approvalExecution.performed && finalPlan.allowanceReadError !== null;
+        if (finalPlan.approval.required && !allowanceReadUncertain) {
+          throw createTaggedError(
+            "Uniswap swap still requires token approval after the approval step completed.",
+            "swap_approval_required",
+            {
+              spender: finalPlan.spender,
+              requiredAllowance: finalPlan.tokenInAmount.toString(),
+              currentAllowance: finalPlan.currentAllowance.toString(),
+            }
+          );
+        }
+
+        const signature =
+          finalPlan.isNativeTokenIn || !finalPlan.permitData
+            ? null
+            : await this.#signUniswapPermit(account, finalPlan.permitData, runtimeConfig);
+
+        const swapTx = await this.#fetchUniswapSwapCalldata({
+          runtimeConfig,
+          quoteResponse: finalPlan.quoteResponse,
+          permitData: finalPlan.permitData,
+          signature,
+        });
+
+        const simulation = await this.#simulatePreparedTransaction({
+          runtimeConfig,
+          from: address,
+          tx: swapTx,
+        });
+        this.#assertSimulationSucceeded(simulation);
+
+        const { hash } = await account.sendTransaction(swapTx);
+        const result = {
+          hash,
+          approvalFee: approvalExecution.totalFee.toString(),
+          tokenInAmount: finalPlan.tokenInAmount.toString(),
+          tokenOutAmount: finalPlan.tokenOutAmount.toString(),
+          ...(approvalExecution.approveHash ? { approveHash: approvalExecution.approveHash } : {}),
+          ...(approvalExecution.resetAllowanceHash
+            ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
+            : {}),
+        };
+        return {
+          ...(await this.#formatUniswapSwapResponse({
+            runtimeConfig,
+            accountIndex,
+            address,
+            swapRequest,
+            plan: {
+              ...finalPlan,
+              approval: {
+                ...finalPlan.approval,
+                estimatedFee: approvalExecution.totalFee,
+              },
+            },
+          })),
+          simulation,
+          swapTransaction: { to: swapTx.to, value: swapTx.value.toString(), dataHash: sha256Hex(swapTx.data) },
+          result,
+        };
+      } catch (error) {
+        const cleanup = await this.#restoreAllowanceAfterFailedSwap({
+          account,
+          runtimeConfig,
+          tokenAddress: swapRequest.tokenIn,
+          spender: initialPlan.spender,
+          originalAllowance: initialPlan.currentAllowance,
+          approvalExecution,
+        });
+        this.#throwSwapFailureWithCleanup(error, cleanup);
+      }
+    });
+  }
+
+  async #getUniswapTokenMetadata(runtimeConfig, tokenAddress) {
+    if (isZeroAddress(tokenAddress)) {
+      return {
+        address: ZERO_ADDRESS,
+        name: runtimeConfig.nativeSymbol === "ETH" ? "Ether" : runtimeConfig.nativeSymbol,
+        symbol: runtimeConfig.nativeSymbol,
+        decimals: 18,
+        verified: true,
+        source: "native-asset",
+      };
+    }
+    return this.#getTokenMetadata(runtimeConfig, tokenAddress);
+  }
+
+  async #formatUniswapSwapResponse({ runtimeConfig, accountIndex, address, swapRequest, plan }) {
+    const [tokenInMetadata, tokenOutMetadata] = await Promise.all([
+      this.#getUniswapTokenMetadata(runtimeConfig, swapRequest.tokenIn),
+      this.#getUniswapTokenMetadata(runtimeConfig, swapRequest.tokenOut),
+    ]);
+    return {
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      accountIndex,
+      address,
+      protocol: "uniswap",
+      executionSupported: true,
+      routing: "CLASSIC",
+      swapRequest: {
+        tokenIn: swapRequest.tokenIn,
+        tokenOut: swapRequest.tokenOut,
+        tokenInAmount: swapRequest.tokenInAmount.toString(),
+      },
+      tokenInMetadata,
+      tokenOutMetadata,
+      inputAmountFormatted: formatUnits(swapRequest.tokenInAmount, tokenInMetadata.decimals),
+      outputAmountFormatted: formatUnits(plan.tokenOutAmount, tokenOutMetadata.decimals),
+      quoteFingerprint: plan.quoteFingerprint,
+      slippageBps: plan.slippageBps,
+      minimumOutputAmountRaw: plan.minimumTokenOutAmount.toString(),
+      permitRequired: plan.permitData !== null,
+      gasFeeWei: plan.gasFee,
+      gasFeeUSD: plan.gasFeeUSD,
+      estimatedApprovalFeeWei: plan.approval.estimatedFee.toString(),
+      allowance: {
+        spender: plan.spender,
+        currentAllowance: plan.currentAllowance.toString(),
+        requiredAllowance: plan.tokenInAmount.toString(),
+        approvalRequired: plan.approval.required,
+        approvalSequence: plan.approval.steps,
+        readError: plan.allowanceReadError,
+      },
+      router: plan.router,
+      source: "uniswap-trading-api",
+    };
+  }
+
+  async quoteNativeTransfer({ seedPhrase, to, value, accountIndex = 0, network }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      const tx = {
+        to: normalizeAddress(to, "to"),
+        value: assertPositiveBigIntString(value, "value"),
+      };
+      const quote = await account.quoteSendTransaction(tx);
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        accountIndex,
+        transaction: tx,
+        quote,
+        source: "wdk-wallet-evm",
+      };
+    });
+  }
+
+  async sendNativeTransfer({ seedPhrase, to, value, accountIndex = 0, network }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      const tx = {
+        to: normalizeAddress(to, "to"),
+        value: assertPositiveBigIntString(value, "value"),
+      };
+      const result = await account.sendTransaction(tx);
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        accountIndex,
+        transaction: tx,
+        result,
+        source: "wdk-wallet-evm",
+      };
+    });
+  }
+
+  async quoteTokenTransfer({
+    seedPhrase,
+    tokenAddress,
+    recipient,
+    amount,
+    accountIndex = 0,
+    network,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      const transfer = {
+        token: normalizeAddress(tokenAddress, "tokenAddress"),
+        recipient: normalizeAddress(recipient, "recipient"),
+        amount: assertPositiveBigIntString(amount, "amount"),
+      };
+      const ownerAddress = await account.getAddress();
+      const { tokenMetadata } = await this.#prepareTokenTransferContext({
+        account,
+        runtimeConfig,
+        transfer,
+        ownerAddress,
+      });
+      let quote;
+      try {
+        quote = await account.quoteTransfer(transfer);
+      } catch (error) {
+        if (isRecoverableTokenTransferSimulationFailure(error)) {
+          throw createTaggedError(
+            "Token transfer could not be simulated by the token contract.",
+            "token_transfer_failed",
+            {
+              network: runtimeConfig.network,
+              tokenAddress: transfer.token,
+              ownerAddress,
+              recipient: transfer.recipient,
+              amount: transfer.amount.toString(),
+              underlying:
+                error instanceof Error
+                  ? {
+                      message: error.message,
+                      code: String(error.errorCode || error.code || "").trim() || null,
+                    }
+                  : {
+                      message: String(error),
+                      code: null,
+                    },
+            }
+          );
+        }
+        throw error;
+      }
+      return {
+        network: runtimeConfig.network,
         chainId: runtimeConfig.chainId,
         accountIndex,
         transfer,
@@ -2725,113 +3909,714 @@ export class WdkEvmWalletService {
                       code: null,
                     },
             }
-          );
-        }
-        throw error;
-      }
+          );
+        }
+        throw error;
+      }
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        accountIndex,
+        transfer,
+        tokenMetadata,
+        amountFormatted: formatUnits(transfer.amount, tokenMetadata.decimals),
+        result,
+        source: "wdk-wallet-evm",
+      };
+    });
+  }
+
+  async signX402ExactTypedData({
+    seedPhrase,
+    accountIndex = 0,
+    network,
+    domain,
+    types,
+    primaryType,
+    message,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      const typedData = normalizeX402ExactTypedData(
+        { domain, types, primaryType, message },
+        runtimeConfig
+      );
+      const signerAddress = normalizeAddress(await account.getAddress(), "accountAddress");
+      if (typedData.message.from.toLowerCase() !== signerAddress.toLowerCase()) {
+        throw new Error("message.from must match the active wallet account address.");
+      }
+      const signature = await account.signTypedData({
+        domain: typedData.domain,
+        types: typedData.types,
+        message: typedData.message,
+      });
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        accountIndex,
+        address: signerAddress,
+        primaryType: typedData.primaryType,
+        signature,
+        source: "wdk-wallet-evm",
+      };
+    });
+  }
+
+  #resolveRuntimeConfig(networkOverride) {
+    const network = assertValidNetwork(networkOverride) || this.config.network;
+    const profile = this.config.networkProfiles?.[network];
+    if (!profile) {
+      throw new Error(`Missing RPC profile for network: ${network}`);
+    }
+    return {
+      ...this.config,
+      network,
+      chainId: profile.chainId,
+      providerUrl: profile.providerUrl,
+      nativeSymbol: profile.nativeSymbol,
+    };
+  }
+
+  async #withWallet({ seedPhrase, network }, callback) {
+    const mnemonic = assertValidSeedPhrase(seedPhrase);
+    const runtimeConfig = this.#resolveRuntimeConfig(network);
+    const options = {
+      provider: runtimeConfig.providerUrl,
+      chainId: runtimeConfig.chainId,
+    };
+    if (runtimeConfig.transferMaxFeeWei !== null) {
+      options.transferMaxFee = runtimeConfig.transferMaxFeeWei;
+    }
+    const wallet = new WalletManagerEvm(mnemonic, options);
+    try {
+      return await callback(wallet, runtimeConfig);
+    } finally {
+      await maybeDispose(wallet);
+    }
+  }
+
+  async #withAccount({ seedPhrase, accountIndex, network }, callback) {
+    return this.#withWallet({ seedPhrase, network }, async (wallet, runtimeConfig) => {
+      const account = await wallet.getAccount(assertNonNegativeInteger(accountIndex, "accountIndex"));
+      return await callback(account, runtimeConfig);
+    });
+  }
+
+  async #withReadableAccount({ seedPhrase, address, accountIndex, network }, callback) {
+    const normalizedAddress = String(address || "").trim();
+    if (normalizedAddress) {
+      const runtimeConfig = this.#resolveRuntimeConfig(network);
+      const account = new WalletAccountReadOnlyEvm(
+        normalizeAddress(normalizedAddress, "address"),
+        { provider: runtimeConfig.providerUrl }
+      );
+      try {
+        return await callback(account, runtimeConfig);
+      } finally {
+        await maybeDispose(account);
+      }
+    }
+    return this.#withAccount({ seedPhrase, accountIndex, network }, callback);
+  }
+
+  async #morphoGraphqlRequest({ query, variables = {}, operationName = null }) {
+    const baseUrl = String(this.config.morphoApiBaseUrl || "https://api.morpho.org/graphql").trim();
+    if (!baseUrl) {
+      throw createTaggedError("Morpho API base URL is not configured.", "morpho_api_failed");
+    }
+    let response;
+    try {
+      response = await fetch(baseUrl, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          query,
+          variables,
+          ...(operationName ? { operationName } : {}),
+        }),
+      });
+    } catch (error) {
+      throw createTaggedError(
+        `Morpho API request failed: ${error instanceof Error ? error.message : String(error)}`,
+        "network_unavailable",
+        {
+          provider: "morpho",
+          endpoint: baseUrl,
+          operationName,
+        }
+      );
+    }
+
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (error) {
+      throw createTaggedError(
+        `Morpho API returned invalid JSON (HTTP ${response.status}).`,
+        "morpho_api_failed",
+        {
+          provider: "morpho",
+          endpoint: baseUrl,
+          status: response.status,
+          operationName,
+        }
+      );
+    }
+
+    if (!response.ok) {
+      const message =
+        Array.isArray(payload?.errors) && payload.errors.length > 0
+          ? String(payload.errors[0]?.message || "").trim()
+          : "";
+      throw createTaggedError(
+        message || `Morpho API request failed with HTTP ${response.status}.`,
+        "morpho_api_failed",
+        {
+          provider: "morpho",
+          endpoint: baseUrl,
+          status: response.status,
+          operationName,
+          errors: Array.isArray(payload?.errors) ? payload.errors : [],
+        }
+      );
+    }
+
+    if (Array.isArray(payload?.errors) && payload.errors.length > 0) {
+      const allNotFound = payload.errors.every(
+        (entry) =>
+          String(entry?.status || entry?.extensions?.code || "").toUpperCase() === "NOT_FOUND"
+      );
+      if (!allNotFound) {
+        throw createTaggedError(
+          String(payload.errors[0]?.message || "Morpho API query failed."),
+          "morpho_api_failed",
+          {
+            provider: "morpho",
+            endpoint: baseUrl,
+            status: response.status,
+            operationName,
+            errors: payload.errors,
+          }
+        );
+      }
+    }
+
+    return payload?.data || {};
+  }
+
+  #createMorphoProtocol(account, runtimeConfig, request) {
+    return new MorphoProtocolEvm(account, this.#buildMorphoProtocolOptions(runtimeConfig, request));
+  }
+
+  #buildMorphoProtocolOptions(runtimeConfig, request) {
+    const options = {
+      chainId: runtimeConfig.chainId,
+      supportSignature: false,
+    };
+    if (request.target.vaultAddress) {
+      options.earnVaultAddress = request.target.vaultAddress;
+    } else if (request.target.vaultPreset) {
+      options.presets = {
+        ...(options.presets || {}),
+        earn: request.target.vaultPreset,
+      };
+    }
+    if (request.target.marketId) {
+      options.borrowMarketId = request.target.marketId;
+    } else if (request.target.marketPreset) {
+      options.presets = {
+        ...(options.presets || {}),
+        borrow: request.target.marketPreset,
+      };
+    }
+    return options;
+  }
+
+  #getMorphoOperationMethods(request) {
+    const table =
+      request.target.vaultAddress || request.target.vaultPreset
+        ? {
+            supply: {
+              requirementsMethod: "getSupplyRequirements",
+              quoteMethod: "quoteSupply",
+              sendMethod: "supply",
+            },
+            withdraw: {
+              requirementsMethod: null,
+              quoteMethod: "quoteWithdraw",
+              sendMethod: "withdraw",
+            },
+          }
+        : {
+            supply_collateral: {
+              requirementsMethod: "getSupplyCollateralRequirements",
+              quoteMethod: "quoteSupplyCollateral",
+              sendMethod: "supplyCollateral",
+            },
+            borrow: {
+              requirementsMethod: "getBorrowRequirements",
+              quoteMethod: "quoteBorrow",
+              sendMethod: "borrow",
+            },
+            repay: {
+              requirementsMethod: "getRepayRequirements",
+              quoteMethod: "quoteRepay",
+              sendMethod: "repay",
+            },
+            withdraw_collateral: {
+              requirementsMethod: null,
+              quoteMethod: "quoteWithdrawCollateral",
+              sendMethod: "withdrawCollateral",
+            },
+          };
+    const methods = table[request.operation];
+    if (!methods) {
+      throw new Error(`Unsupported Morpho operation '${request.operation}'.`);
+    }
+    return methods;
+  }
+
+  #buildMorphoOperationOptions(request) {
+    const options = {
+      token: request.token,
+    };
+    if (request.amount !== undefined && request.amount !== null) {
+      options.amount = request.amount;
+    }
+    if (request.nativeAmount !== undefined && request.nativeAmount !== null) {
+      options.nativeAmount = request.nativeAmount;
+    }
+    return options;
+  }
+
+  async #buildMorphoOperationPlan({
+    account,
+    runtimeConfig,
+    address,
+    request,
+    tolerateOperationFeeFailure = false,
+  }) {
+    const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
+    try {
+      const methods = this.#getMorphoOperationMethods(request);
+      const operationOptions = this.#buildMorphoOperationOptions(request);
+      const requirements = await this.#buildMorphoRequirementPlan({
+        account,
+        runtimeConfig,
+        protocol,
+        request,
+        methods,
+        operationOptions,
+      });
+      const operationFeeQuote = await this.#quoteMorphoProtocolOperation({
+        protocol,
+        methods,
+        operationOptions,
+        tolerateFailure: tolerateOperationFeeFailure,
+      });
+      const tokenMetadata = await this.#getBestEffortTokenMetadata(runtimeConfig, request.token);
+      const target =
+        request.target.vaultAddress || request.target.vaultPreset
+          ? {
+              type: "vault",
+              vaultAddress: protocol.getVaultAddress().toLowerCase(),
+              vaultPreset: request.target.vaultPreset || null,
+            }
+          : {
+              type: "market",
+              marketId: protocol.getBorrowMarketId(),
+              marketPreset: request.target.marketPreset || null,
+            };
+      const quoteFingerprint = sha256Hex(
+        JSON.stringify({
+          chainId: runtimeConfig.chainId,
+          network: runtimeConfig.network,
+          from: address.toLowerCase(),
+          protocol: "morpho",
+          target,
+          operation: request.operation,
+          token: request.token.toLowerCase(),
+          amount:
+            typeof request.amount === "bigint"
+              ? request.amount.toString()
+              : request.amount === "max"
+                ? "max"
+                : null,
+          nativeAmount: request.nativeAmount ? request.nativeAmount.toString() : null,
+        })
+      );
       return {
-        network: runtimeConfig.network,
-        chainId: runtimeConfig.chainId,
-        accountIndex,
-        transfer,
+        quoteFingerprint,
+        target,
+        amount: request.amount ?? null,
+        nativeAmount: request.nativeAmount ?? null,
         tokenMetadata,
-        amountFormatted: formatUnits(transfer.amount, tokenMetadata.decimals),
-        result,
-        source: "wdk-wallet-evm",
+        operationFee: operationFeeQuote.fee,
+        operationFeeError: operationFeeQuote.error,
+        totalEstimatedFee:
+          operationFeeQuote.fee !== null ? operationFeeQuote.fee + requirements.estimatedFee : null,
+        requirements,
       };
-    });
+    } finally {
+      await maybeDispose(protocol);
+    }
   }
 
-  async signX402ExactTypedData({
-    seedPhrase,
-    accountIndex = 0,
-    network,
-    domain,
-    types,
-    primaryType,
-    message,
+  async #buildMorphoRequirementPlan({
+    account,
+    runtimeConfig,
+    protocol,
+    request,
+    methods,
+    operationOptions,
   }) {
-    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
-      const typedData = normalizeX402ExactTypedData(
-        { domain, types, primaryType, message },
-        runtimeConfig
+    if (!methods.requirementsMethod) {
+      return {
+        required: false,
+        estimatedFee: 0n,
+        approvalRequired: false,
+        authorizationRequired: false,
+        steps: [],
+        transactions: [],
+        approvalContexts: [],
+        authorizationContexts: [],
+      };
+    }
+    const requirements = await protocol[methods.requirementsMethod](operationOptions);
+    const steps = [];
+    const transactions = [];
+    const approvalContexts = [];
+    const authorizationContexts = [];
+    let estimatedFee = 0n;
+    for (const requirement of Array.isArray(requirements) ? requirements : []) {
+      if (isRequirementApproval(requirement)) {
+        const spender = normalizeAddress(
+          String(requirement.action?.args?.spender || ""),
+          "morphoRequirement.spender"
+        ).toLowerCase();
+        const amount = BigInt(requirement.action?.args?.amount || 0);
+        const quote = await account.quoteSendTransaction({
+          to: requirement.to,
+          value: requirement.value ?? 0n,
+          data: requirement.data,
+        });
+        const fee = BigInt(quote?.fee || 0);
+        this.#assertMaxFee(runtimeConfig, fee, `morpho approval`);
+        estimatedFee += fee;
+        steps.push({
+          type: "approval",
+          spender,
+          amount: amount.toString(),
+          estimatedFeeWei: fee.toString(),
+          to: requirement.to.toLowerCase(),
+          value: BigInt(requirement.value ?? 0).toString(),
+          dataHash: sha256Hex(requirement.data),
+        });
+        transactions.push(requirement);
+        if (!approvalContexts.some((entry) => entry.spender === spender)) {
+          const originalAllowance = await account.getAllowance(request.token, spender);
+          approvalContexts.push({
+            tokenAddress: request.token,
+            spender,
+            originalAllowance,
+          });
+        }
+        continue;
+      }
+      if (isRequirementAuthorization(requirement)) {
+        const authorized = normalizeAddress(
+          String(requirement.action?.args?.authorized || ""),
+          "morphoRequirement.authorized"
+        ).toLowerCase();
+        const quote = await account.quoteSendTransaction({
+          to: requirement.to,
+          value: requirement.value ?? 0n,
+          data: requirement.data,
+        });
+        const fee = BigInt(quote?.fee || 0);
+        this.#assertMaxFee(runtimeConfig, fee, `morpho authorization`);
+        estimatedFee += fee;
+        steps.push({
+          type: "authorization",
+          authorized,
+          isAuthorized: Boolean(requirement.action?.args?.isAuthorized),
+          estimatedFeeWei: fee.toString(),
+          to: requirement.to.toLowerCase(),
+          value: BigInt(requirement.value ?? 0).toString(),
+          dataHash: sha256Hex(requirement.data),
+        });
+        transactions.push(requirement);
+        if (
+          !authorizationContexts.some(
+            (entry) =>
+              entry.contractAddress === requirement.to.toLowerCase() &&
+              entry.authorized === authorized
+          )
+        ) {
+          authorizationContexts.push({
+            contractAddress: requirement.to.toLowerCase(),
+            authorized,
+          });
+        }
+        continue;
+      }
+      throw createTaggedError(
+        "Morpho returned a signature requirement, but this runtime only supports transaction-based requirements.",
+        "morpho_requirements_unresolved",
+        {
+          requirementType: requirement?.action?.type || null,
+        }
       );
-      const signerAddress = normalizeAddress(await account.getAddress(), "accountAddress");
-      if (typedData.message.from.toLowerCase() !== signerAddress.toLowerCase()) {
-        throw new Error("message.from must match the active wallet account address.");
+    }
+    return {
+      required: steps.length > 0,
+      estimatedFee,
+      approvalRequired: steps.some((step) => step.type === "approval"),
+      authorizationRequired: steps.some((step) => step.type === "authorization"),
+      steps,
+      transactions,
+      approvalContexts,
+      authorizationContexts,
+    };
+  }
+
+  async #quoteMorphoProtocolOperation({
+    protocol,
+    methods,
+    operationOptions,
+    tolerateFailure,
+  }) {
+    try {
+      const quote = await protocol[methods.quoteMethod](operationOptions);
+      return {
+        fee: BigInt(quote?.fee || 0),
+        error: null,
+      };
+    } catch (error) {
+      if (!tolerateFailure) {
+        throw error;
       }
-      const signature = await account.signTypedData({
-        domain: typedData.domain,
-        types: typedData.types,
-        message: typedData.message,
-      });
       return {
-        network: runtimeConfig.network,
-        chainId: runtimeConfig.chainId,
-        accountIndex,
-        address: signerAddress,
-        primaryType: typedData.primaryType,
-        signature,
-        source: "wdk-wallet-evm",
+        fee: null,
+        error: {
+          code: normalizeErrorCodeValue(error) || null,
+          message: error instanceof Error ? error.message : String(error),
+        },
       };
-    });
+    }
   }
 
-  #resolveRuntimeConfig(networkOverride) {
-    const network = assertValidNetwork(networkOverride) || this.config.network;
-    const profile = this.config.networkProfiles?.[network];
-    if (!profile) {
-      throw new Error(`Missing RPC profile for network: ${network}`);
-    }
+  #formatMorphoOperationResponse({ runtimeConfig, accountIndex, address, request, plan }) {
+    const amountFormatted =
+      typeof plan.amount === "bigint" &&
+      plan.tokenMetadata &&
+      Number.isInteger(plan.tokenMetadata.decimals)
+        ? formatUnits(plan.amount, plan.tokenMetadata.decimals)
+        : null;
+    const nativeAmountFormatted =
+      typeof plan.nativeAmount === "bigint" ? formatUnits(plan.nativeAmount, 18) : null;
     return {
-      ...this.config,
-      network,
-      chainId: profile.chainId,
-      providerUrl: profile.providerUrl,
-      nativeSymbol: profile.nativeSymbol,
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      accountIndex,
+      address,
+      protocol: "morpho",
+      executionSupported: true,
+      surface: plan.target.type,
+      operation: request.operation,
+      target: plan.target,
+      operationRequest: {
+        token: request.token,
+        amount:
+          typeof plan.amount === "bigint"
+            ? plan.amount.toString()
+            : plan.amount === "max"
+              ? "max"
+              : null,
+        nativeAmount: typeof plan.nativeAmount === "bigint" ? plan.nativeAmount.toString() : null,
+      },
+      tokenMetadata: plan.tokenMetadata,
+      amountFormatted,
+      nativeAmountFormatted,
+      quoteFingerprint: plan.quoteFingerprint,
+      estimatedFeeWei: plan.totalEstimatedFee !== null ? plan.totalEstimatedFee.toString() : null,
+      estimatedOperationFeeWei: plan.operationFee !== null ? plan.operationFee.toString() : null,
+      estimatedRequirementsFeeWei: plan.requirements.estimatedFee.toString(),
+      feeEstimateAvailable: plan.operationFee !== null,
+      feeEstimateError: plan.operationFeeError,
+      requirements: {
+        required: plan.requirements.required,
+        requirementCount: plan.requirements.steps.length,
+        approvalRequired: plan.requirements.approvalRequired,
+        authorizationRequired: plan.requirements.authorizationRequired,
+        sequence: plan.requirements.steps,
+      },
+      source: "wdk-protocol-lending-morpho-evm",
     };
   }
 
-  async #withWallet({ seedPhrase, network }, callback) {
-    const mnemonic = assertValidSeedPhrase(seedPhrase);
-    const runtimeConfig = this.#resolveRuntimeConfig(network);
-    const options = {
-      provider: runtimeConfig.providerUrl,
-      chainId: runtimeConfig.chainId,
-    };
-    if (runtimeConfig.transferMaxFeeWei !== null) {
-      options.transferMaxFee = runtimeConfig.transferMaxFeeWei;
+  #assertExpectedMorphoFingerprint(expectedQuoteFingerprint, actualQuoteFingerprint) {
+    if (!expectedQuoteFingerprint) {
+      return;
     }
-    const wallet = new WalletManagerEvm(mnemonic, options);
-    try {
-      return await callback(wallet, runtimeConfig);
-    } finally {
-      await maybeDispose(wallet);
+    if (expectedQuoteFingerprint !== actualQuoteFingerprint) {
+      throw createTaggedError(
+        "Morpho quote changed since preview. Generate a new preview and approval before execute.",
+        "morpho_quote_changed",
+        {
+          expectedQuoteFingerprint,
+          actualQuoteFingerprint,
+        }
+      );
     }
   }
 
-  async #withAccount({ seedPhrase, accountIndex, network }, callback) {
-    return this.#withWallet({ seedPhrase, network }, async (wallet, runtimeConfig) => {
-      const account = await wallet.getAccount(assertNonNegativeInteger(accountIndex, "accountIndex"));
-      return await callback(account, runtimeConfig);
-    });
+  async #executeMorphoRequirementsIfNeeded({ account, runtimeConfig, plan }) {
+    if (!plan.requirements.required) {
+      return {
+        performed: false,
+        totalFee: 0n,
+        transactions: [],
+        approvalContexts: plan.requirements.approvalContexts,
+        authorizationContexts: plan.requirements.authorizationContexts,
+      };
+    }
+    let totalFee = 0n;
+    const transactions = [];
+    for (let index = 0; index < plan.requirements.transactions.length; index += 1) {
+      const requirementTx = plan.requirements.transactions[index];
+      const step = plan.requirements.steps[index];
+      const result = await account.sendTransaction({
+        to: requirementTx.to,
+        value: requirementTx.value ?? 0n,
+        data: requirementTx.data,
+      });
+      const fee = BigInt(result?.fee || 0);
+      totalFee += fee;
+      transactions.push({
+        ...step,
+        hash: result.hash,
+        fee: fee.toString(),
+      });
+      await this.#waitForTransactionReceipt(runtimeConfig, result.hash);
+    }
+    return {
+      performed: true,
+      totalFee,
+      transactions,
+      approvalContexts: plan.requirements.approvalContexts,
+      authorizationContexts: plan.requirements.authorizationContexts,
+    };
   }
 
-  async #withReadableAccount({ seedPhrase, address, accountIndex, network }, callback) {
-    const normalizedAddress = String(address || "").trim();
-    if (normalizedAddress) {
-      const runtimeConfig = this.#resolveRuntimeConfig(network);
-      const account = new WalletAccountReadOnlyEvm(
-        normalizeAddress(normalizedAddress, "address"),
-        { provider: runtimeConfig.providerUrl }
-      );
-      try {
-        return await callback(account, runtimeConfig);
-      } finally {
-        await maybeDispose(account);
+  async #restoreMorphoRequirementsAfterFailedOperation({
+    account,
+    runtimeConfig,
+    requirementExecution,
+  }) {
+    if (!requirementExecution?.performed) {
+      return {
+        attempted: false,
+        restored: false,
+      };
+    }
+    const cleanup = {
+      attempted: true,
+      restored: false,
+      approvals: [],
+      authorizations: [],
+      error: null,
+    };
+    try {
+      for (const context of requirementExecution.approvalContexts || []) {
+        const restorePlan = await this.#buildAllowanceRestorePlan({
+          account,
+          runtimeConfig,
+          tokenAddress: context.tokenAddress,
+          spender: context.spender,
+          targetAllowance: context.originalAllowance,
+        });
+        const entry = {
+          tokenAddress: context.tokenAddress,
+          spender: context.spender,
+          originalAllowance: BigInt(context.originalAllowance || 0).toString(),
+          restoreSteps: restorePlan.steps.map((step) => ({ ...step })),
+          restoreHashes: [],
+        };
+        for (const step of restorePlan.steps) {
+          const result = await account.approve({
+            token: context.tokenAddress,
+            spender: context.spender,
+            amount: step.amount,
+          });
+          entry.restoreHashes.push({
+            type: step.type,
+            hash: result.hash,
+            fee: BigInt(result.fee || 0).toString(),
+          });
+          await this.#waitForTransactionReceipt(runtimeConfig, result.hash);
+        }
+        const finalAllowance = await account.getAllowance(context.tokenAddress, context.spender);
+        entry.finalAllowance = finalAllowance.toString();
+        entry.restored = finalAllowance === BigInt(context.originalAllowance || 0);
+        cleanup.approvals.push(entry);
+        if (!entry.restored) {
+          throw new Error("Morpho approval allowance restore did not reach the original allowance.");
+        }
+      }
+
+      for (const context of requirementExecution.authorizationContexts || []) {
+        const result = await account.sendTransaction({
+          to: context.contractAddress,
+          value: 0n,
+          data: MORPHO_AUTHORIZATION_INTERFACE.encodeFunctionData("setAuthorization", [
+            context.authorized,
+            false,
+          ]),
+        });
+        cleanup.authorizations.push({
+          contractAddress: context.contractAddress,
+          authorized: context.authorized,
+          hash: result.hash,
+          fee: BigInt(result.fee || 0).toString(),
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash);
       }
+
+      cleanup.restored = true;
+      return cleanup;
+    } catch (cleanupError) {
+      cleanup.error = {
+        message: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+        code:
+          cleanupError && typeof cleanupError === "object"
+            ? String(cleanupError.errorCode || cleanupError.code || "").trim() || null
+            : null,
+      };
+      return cleanup;
     }
-    return this.#withAccount({ seedPhrase, accountIndex, network }, callback);
+  }
+
+  #throwMorphoFailureWithCleanup(error, cleanup) {
+    if (cleanup?.attempted && cleanup.restored !== true) {
+      throw createTaggedError(
+        "Morpho operation failed after prerequisite transactions and automatic cleanup did not complete.",
+        "morpho_cleanup_failed",
+        {
+          originalError:
+            error instanceof Error
+              ? {
+                  message: error.message,
+                  code: String(error.errorCode || error.code || "").trim() || null,
+                }
+              : { message: String(error), code: null },
+          cleanup,
+        }
+      );
+    }
+    throw error;
   }
 
   async #getTokenMetadata(runtimeConfig, tokenAddress) {
@@ -2990,6 +4775,7 @@ export class WdkEvmWalletService {
   #assertMaxFee(runtimeConfig, fee, operation) {
     if (
       runtimeConfig.transferMaxFeeWei !== null &&
+      runtimeConfig.transferMaxFeeWei !== undefined &&
       BigInt(fee) >= BigInt(runtimeConfig.transferMaxFeeWei)
     ) {
       throw createTaggedError(`Exceeded maximum fee cost for ${operation}.`, "fee_limit_exceeded", {