@agentlayer.tech/wallet 0.1.93 → 0.1.95

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",

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

@@ -359,6 +359,13 @@ export function loadConfig(env = process.env) {
       : "https://trade-api.gateway.uniswap.org/v1");
   const uniswapViaGateway =
     Boolean(gatewayBaseTrimmed) && uniswapTradingApiBaseUrl.startsWith(gatewayBaseTrimmed);
+  const uniswapLiquidityApiBaseUrl =
+    String(env.UNISWAP_LIQUIDITY_API_BASE_URL ?? "").trim() ||
+    (gatewayBaseTrimmed
+      ? `${gatewayBaseTrimmed}/v1/evm/uniswap/lp`
+      : "https://liquidity.api.uniswap.org");
+  const uniswapLiquidityViaGateway =
+    Boolean(gatewayBaseTrimmed) && uniswapLiquidityApiBaseUrl.startsWith(gatewayBaseTrimmed);
 
   return {
     host,
@@ -392,6 +399,8 @@ export function loadConfig(env = process.env) {
     lidoReferralAddress: String(env.LIDO_REFERRAL_ADDRESS ?? "").trim(),
     uniswapTradingApiBaseUrl,
     uniswapViaGateway,
+    uniswapLiquidityApiBaseUrl,
+    uniswapLiquidityViaGateway,
     providerGatewayToken,
     uniswapApiKey: String(env.UNISWAP_API_KEY ?? "").trim(),
     uniswapRouterVersion: String(env.UNISWAP_ROUTER_VERSION ?? "").trim() || "2.0",

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

@@ -640,6 +640,30 @@ async function handleRequest(request, response) {
       return sendJson(response, 200, { ok: true, data });
     }
 
+    if (method === "POST" && url.pathname === "/v1/evm/uniswap/liquidity/quote") {
+      const body = await withResolvedNetwork(await withResolvedSeedOrAddress(await readJsonBody(request)));
+      const data = await service.quoteUniswapLiquidity(body);
+      return sendJson(response, 200, { ok: true, data });
+    }
+
+    if (method === "POST" && url.pathname === "/v1/evm/uniswap/liquidity/pools") {
+      const body = await withResolvedNetwork(await readJsonBody(request));
+      const data = await service.getUniswapLiquidityPools(body);
+      return sendJson(response, 200, { ok: true, data });
+    }
+
+    if (method === "POST" && url.pathname === "/v1/evm/uniswap/liquidity/positions") {
+      const body = await withResolvedNetwork(await withResolvedSeedOrAddress(await readJsonBody(request)));
+      const data = await service.getUniswapLiquidityPositions(body);
+      return sendJson(response, 200, { ok: true, data });
+    }
+
+    if (method === "POST" && url.pathname === "/v1/evm/uniswap/liquidity/send") {
+      const body = await withResolvedNetwork(await withResolvedSeed(await readJsonBody(request)));
+      const data = await service.sendUniswapLiquidity(body);
+      return sendJson(response, 200, { ok: true, data });
+    }
+
     if (method === "POST" && url.pathname === "/v1/evm/transfer/quote") {
       const body = await withResolvedNetwork(await withResolvedSeed(await readJsonBody(request)));
       const data = await service.quoteNativeTransfer(body);

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

@@ -23,6 +23,36 @@ const DEFAULT_LIFI_SLIPPAGE = 0.005;
 const ALWAYS_DENIED_LIFI_BRIDGES = ["mayan"];
 const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 const UNISWAP_SUPPORTED_CHAIN_IDS = { ethereum: 1, base: 8453, robinhood: 4663 };
+const UNISWAP_LIQUIDITY_ACTIONS = new Set(["create", "increase", "decrease", "claim_fees"]);
+const UNISWAP_LIQUIDITY_PROTOCOLS = new Set(["V3", "V4"]);
+// LP API transactions are accepted only for these official per-chain position
+// managers. Keeping the list here makes the local signer a narrow protocol
+// integration rather than a generic calldata relay.
+const UNISWAP_LIQUIDITY_POSITION_MANAGERS = {
+  ethereum: {
+    V3: "0xc36442b4a4522e871399cd717abdd847ab11fe88",
+    V4: "0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e",
+  },
+  base: {
+    V3: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1",
+    V4: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
+  },
+  robinhood: {
+    V3: "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+    V4: "0x58daec3116aae6d93017baaea7749052e8a04fa7",
+  },
+};
+const ERC20_APPROVE_INTERFACE = new Interface([
+  "function approve(address spender,uint256 amount) returns (bool)",
+]);
+// V3 PositionManager is ERC-721 enumerable, so positions owned by the active
+// wallet can be discovered and then read directly from the canonical contract.
+// V4 deliberately is not enumerable; see getUniswapLiquidityPositions below.
+const UNISWAP_V3_POSITION_MANAGER_INTERFACE = new Interface([
+  "function balanceOf(address owner) view returns (uint256)",
+  "function tokenOfOwnerByIndex(address owner,uint256 index) view returns (uint256)",
+  "function positions(uint256 tokenId) view returns (uint96 nonce,address operator,address token0,address token1,uint24 fee,int24 tickLower,int24 tickUpper,uint128 liquidity,uint256 feeGrowthInside0LastX128,uint256 feeGrowthInside1LastX128,uint128 tokensOwed0,uint128 tokensOwed1)",
+]);
 // Every executable path is declared here rather than inferred from a Trading
 // API response. A new chain/router version therefore requires an explicit,
 // reviewed allow-list entry before it can receive a signed transaction.
@@ -925,6 +955,31 @@ function assertUniswapSupportedNetwork(network) {
   return chainId;
 }
 
+function normalizeUniswapLiquidityAction(value) {
+  const action = String(value || "").trim().toLowerCase();
+  if (!UNISWAP_LIQUIDITY_ACTIONS.has(action)) {
+    throw new Error("Uniswap liquidity action must be create, increase, decrease, or claim_fees.");
+  }
+  return action;
+}
+
+function normalizeUniswapLiquidityProtocol(value) {
+  const protocol = String(value || "").trim().toUpperCase();
+  if (!UNISWAP_LIQUIDITY_PROTOCOLS.has(protocol)) {
+    throw new Error("Uniswap liquidity protocol must be V3 or V4.");
+  }
+  return protocol;
+}
+
+function getUniswapLiquidityPositionManager(network, protocol) {
+  assertUniswapSupportedNetwork(network);
+  const manager = UNISWAP_LIQUIDITY_POSITION_MANAGERS[network]?.[protocol];
+  if (!manager) {
+    throw new Error(`Uniswap ${protocol} liquidity is not configured for ${network}.`);
+  }
+  return manager;
+}
+
 function getUniswapNetworkExecutionProfile(network) {
   const profile = UNISWAP_EXECUTION_PROFILES[network];
   if (!profile) {
@@ -5743,6 +5798,420 @@ export class WdkEvmWalletService {
     return payload;
   }
 
+  async #uniswapLiquidityApiRequest(action, body) {
+    const normalizedAction = String(action || "").trim().toLowerCase();
+    const headers = { "Content-Type": "application/json", Accept: "application/json" };
+    if (this.config.uniswapLiquidityViaGateway) {
+      const token = String(this.config.providerGatewayToken || "").trim();
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+    } else {
+      if (!this.config.uniswapApiKey) {
+        throw createTaggedError(
+          "UNISWAP_API_KEY is not configured. Set it, or route Uniswap through the provider gateway, to use liquidity operations.",
+          "uniswap_api_key_missing",
+          { provider: "uniswap" }
+        );
+      }
+      headers["x-api-key"] = this.config.uniswapApiKey;
+    }
+    const base = String(this.config.uniswapLiquidityApiBaseUrl).replace(/\/+$/, "");
+    const suffix = this.config.uniswapLiquidityViaGateway ? `/${normalizedAction}` : `/lp/${normalizedAction}`;
+    let response;
+    try {
+      response = await fetch(`${base}${suffix}`, { method: "POST", headers, body: JSON.stringify(body) });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw createTaggedError(`Uniswap liquidity API unavailable: ${message}`, "network_unavailable", {
+        provider: "uniswap",
+        action: normalizedAction,
+      });
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = null;
+    }
+    if (!response.ok || !payload || typeof payload !== "object") {
+      throw createTaggedError(
+        String(payload?.message || payload?.error || `Uniswap liquidity ${normalizedAction} failed with HTTP ${response.status}.`),
+        "network_unavailable",
+        { provider: "uniswap", action: normalizedAction, httpStatus: response.status }
+      );
+    }
+    return payload;
+  }
+
+  #buildUniswapLiquidityRequest({ action, protocol, address, request }) {
+    const body = { ...(request && typeof request === "object" ? request : {}) };
+    // Caller cannot select identity, chain or simulator behavior. These are set
+    // locally to make every preview/send reproducible through the active wallet.
+    body.walletAddress = address;
+    body.protocol = protocol;
+    body.simulateTransaction = true;
+    delete body.signature;
+    delete body.batchPermitData;
+    delete body.v4BatchPermitData;
+    delete body.v3NftPermitData;
+    if (action === "claim_fees") {
+      delete body.independentToken;
+    }
+    return body;
+  }
+
+  #extractUniswapLiquidityTransaction(payload, action) {
+    const field = action === "create" ? "create" : action === "increase" ? "increase" : action === "decrease" ? "decrease" : "claim";
+    const tx = payload?.[field] || payload?.transaction;
+    if (!tx || typeof tx !== "object") {
+      throw createTaggedError("Uniswap liquidity API returned no executable transaction.", "network_unavailable", {
+        provider: "uniswap",
+        action,
+      });
+    }
+    return tx;
+  }
+
+  async #getUniswapLiquidityApprovals({ runtimeConfig, protocol, action, address, payload }) {
+    if (action !== "create" && action !== "increase") {
+      return [];
+    }
+    const lpTokens = [payload?.token0, payload?.token1]
+      .filter((token) => token && typeof token === "object")
+      // The LP API represents native ETH with the zero-address sentinel. It
+      // cannot have an ERC-20 allowance, so exclude it from check_approval.
+      .filter((token) => !isZeroAddress(String(token.tokenAddress || "")))
+      .map((token) => {
+        const amount = BigInt(assertNonNegativeBigIntString(token.amount, "lp token amount"));
+        return {
+          tokenAddress: normalizeAddress(String(token.tokenAddress || ""), "lp token address"),
+          amount,
+        };
+      })
+      // Concentrated positions can legitimately be single-sided while the
+      // current price lies outside their selected range. A zero contribution
+      // has no ERC-20 allowance requirement and must not block the LP action.
+      .filter((token) => token.amount > 0n)
+      .map((token) => ({ ...token, amount: token.amount.toString() }));
+    if (!lpTokens.length) {
+      return [];
+    }
+    const expectedTokens = new Set(
+      lpTokens.map((token) => String(token.tokenAddress).toLowerCase())
+    );
+    const approvalPayload = await this.#uniswapLiquidityApiRequest("check_approval", {
+      walletAddress: address,
+      chainId: runtimeConfig.chainId,
+      protocol,
+      lpTokens,
+      action: action.toUpperCase(),
+      // The initial version uses ordinary, bounded approval transactions. This
+      // keeps the send path observable and avoids requiring an extra signature
+      // protocol before LP workflows have seen live use.
+      generatePermitAsTransaction: true,
+    });
+    const transactions = Array.isArray(approvalPayload.transactions) ? approvalPayload.transactions : [];
+    return transactions.map((item, index) => {
+      const raw = item?.transaction;
+      if (!raw || typeof raw !== "object") {
+        throw createTaggedError("Uniswap liquidity approval response is malformed.", "uniswap_liquidity_invalid_approval", { index });
+      }
+      const to = normalizeAddress(String(raw.to || ""), "liquidity approval.to");
+      if (!expectedTokens.has(to.toLowerCase())) {
+        throw createTaggedError("Uniswap liquidity approval is for a token outside this LP request.", "uniswap_liquidity_unexpected_token", { to });
+      }
+      const data = assertNonEmptyString(String(raw.data || ""), "liquidity approval.data");
+      if (parseHexOrDecimalBigInt(raw.value || "0", "liquidity approval.value") !== 0n) {
+        throw createTaggedError("Uniswap liquidity approval must not transfer native value.", "uniswap_liquidity_invalid_approval", { to });
+      }
+      if (raw.chainId !== undefined && Number(raw.chainId) !== runtimeConfig.chainId) {
+        throw createTaggedError("Uniswap liquidity approval has the wrong chain id.", "uniswap_liquidity_chain_mismatch");
+      }
+      if (raw.from && normalizeAddress(String(raw.from), "liquidity approval.from").toLowerCase() !== address.toLowerCase()) {
+        throw createTaggedError("Uniswap liquidity approval sender does not match the active wallet.", "uniswap_liquidity_sender_mismatch");
+      }
+      let decoded;
+      try {
+        decoded = ERC20_APPROVE_INTERFACE.parseTransaction({ data });
+      } catch {
+        decoded = null;
+      }
+      if (!decoded || decoded.name !== "approve") {
+        throw createTaggedError("Uniswap liquidity approval is not a bounded ERC-20 approve call.", "uniswap_liquidity_invalid_approval", { to });
+      }
+      const spender = normalizeAddress(String(decoded.args[0]), "liquidity approval spender").toLowerCase();
+      const amount = BigInt(decoded.args[1]);
+      const positionManager = getUniswapLiquidityPositionManager(runtimeConfig.network, protocol);
+      if (spender !== positionManager && spender !== PERMIT2_ADDRESS.toLowerCase()) {
+        throw createTaggedError("Uniswap liquidity approval has an unexpected spender.", "uniswap_liquidity_unexpected_spender", { spender, positionManager });
+      }
+      if (amount <= 0n || amount >= (2n ** 255n)) {
+        throw createTaggedError("Uniswap liquidity approval must use a bounded amount.", "uniswap_liquidity_unbounded_approval", { spender });
+      }
+      return {
+        tx: { to, data, value: 0n },
+        token: to,
+        spender,
+        amount,
+        action: String(item?.action || action).toUpperCase(),
+      };
+    });
+  }
+
+  #validateUniswapLiquidityTransaction({ runtimeConfig, protocol, address, transaction }) {
+    const to = normalizeAddress(String(transaction.to || ""), "liquidity transaction.to");
+    const expectedManager = getUniswapLiquidityPositionManager(runtimeConfig.network, protocol);
+    if (to.toLowerCase() !== expectedManager) {
+      throw createTaggedError("Uniswap liquidity API returned an unexpected PositionManager.", "uniswap_unexpected_position_manager", {
+        expected: expectedManager,
+        actual: to.toLowerCase(),
+        network: runtimeConfig.network,
+        protocol,
+      });
+    }
+    if (transaction.chainId !== undefined && Number(transaction.chainId) !== runtimeConfig.chainId) {
+      throw createTaggedError("Uniswap liquidity transaction has the wrong chain id.", "uniswap_liquidity_chain_mismatch", {
+        expected: runtimeConfig.chainId,
+        actual: transaction.chainId,
+      });
+    }
+    if (transaction.from && normalizeAddress(String(transaction.from), "liquidity transaction.from").toLowerCase() !== address.toLowerCase()) {
+      throw createTaggedError("Uniswap liquidity transaction sender does not match the active wallet.", "uniswap_liquidity_sender_mismatch");
+    }
+    const data = assertNonEmptyString(String(transaction.data || ""), "liquidity transaction.data");
+    if (!/^0x[0-9a-fA-F]+$/.test(data) || data.length < 10) {
+      throw createTaggedError("Uniswap liquidity transaction calldata is invalid.", "uniswap_liquidity_invalid_calldata");
+    }
+    return { to, data, value: parseHexOrDecimalBigInt(transaction.value || "0", "liquidity transaction.value") };
+  }
+
+  #formatUniswapLiquidityResponse({ runtimeConfig, accountIndex, address, action, protocol, request, payload, transaction, approvals = [], simulation = null }) {
+    const tx = transaction ? {
+      to: transaction.to,
+      value: transaction.value.toString(),
+      dataHash: sha256Hex(transaction.data),
+    } : null;
+    return {
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      accountIndex,
+      address,
+      protocol: "uniswap",
+      liquidityAction: action,
+      liquidityProtocol: protocol,
+      request,
+      requestId: String(payload?.requestId || "").trim() || null,
+      token0: payload?.token0 || null,
+      token1: payload?.token1 || null,
+      tickLower: payload?.tickLower ?? null,
+      tickUpper: payload?.tickUpper ?? null,
+      adjustedMinPrice: payload?.adjustedMinPrice ?? null,
+      adjustedMaxPrice: payload?.adjustedMaxPrice ?? null,
+      gasFee: payload?.gasFee ?? null,
+      positionTokenId: String(request?.nftTokenId || request?.tokenId || "").trim() || null,
+      positionManager: getUniswapLiquidityPositionManager(runtimeConfig.network, protocol),
+      approvals: approvals.map((approval) => ({
+        token: approval.token,
+        spender: approval.spender,
+        amount: approval.amount.toString(),
+        action: approval.action,
+      })),
+      transaction: tx,
+      simulation,
+      source: "uniswap-liquidity-api",
+    };
+  }
+
+  async getUniswapLiquidityPools({ protocol, poolParameters, poolReferences, pageSize = 20, currentPage = 1, network }) {
+    const runtimeConfig = this.#resolveRuntimeConfig(network);
+    assertUniswapSupportedNetwork(runtimeConfig.network);
+    const normalizedProtocol = normalizeUniswapLiquidityProtocol(protocol);
+    const hasParameters = poolParameters !== undefined && poolParameters !== null;
+    const hasReferences = poolReferences !== undefined && poolReferences !== null;
+    if (hasParameters === hasReferences) {
+      throw new Error("Provide exactly one of poolParameters or poolReferences.");
+    }
+    const boundedPageSize = Number(pageSize);
+    const normalizedPageSize = Number.isInteger(boundedPageSize) && boundedPageSize > 0
+      ? Math.min(boundedPageSize, 20)
+      : 20;
+    const boundedCurrentPage = Number(currentPage);
+    const normalizedCurrentPage = Number.isInteger(boundedCurrentPage) && boundedCurrentPage > 0
+      ? boundedCurrentPage
+      : 1;
+    const body = {
+      protocol: normalizedProtocol,
+      chainId: runtimeConfig.chainId,
+      pageSize: normalizedPageSize,
+      currentPage: normalizedCurrentPage,
+    };
+    if (hasParameters) {
+      body.poolParameters = assertPlainObject(poolParameters, "poolParameters");
+    } else {
+      if (!Array.isArray(poolReferences) || poolReferences.length === 0 || poolReferences.length > 20) {
+        throw new Error("poolReferences must be an array containing between 1 and 20 references.");
+      }
+      body.poolReferences = poolReferences.map((reference, index) => assertPlainObject(reference, `poolReferences[${index}]`));
+    }
+    const payload = await this.#uniswapLiquidityApiRequest("pool_info", body);
+    return {
+      network: runtimeConfig.network,
+      chainId: runtimeConfig.chainId,
+      protocol: normalizedProtocol,
+      requestId: String(payload?.requestId || "").trim() || null,
+      pools: Array.isArray(payload?.pools) ? payload.pools : [],
+      pageSize: Number(payload?.pageSize ?? normalizedPageSize),
+      currentPage: Number(payload?.currentPage ?? normalizedCurrentPage),
+      source: "uniswap-liquidity-api",
+    };
+  }
+
+  async getUniswapLiquidityPositions({ seedPhrase, address, protocol = "V3", accountIndex = 0, network, limit = 20 }) {
+    return this.#withReadableAccount({ seedPhrase, address, accountIndex, network }, async (account, runtimeConfig) => {
+      assertUniswapSupportedNetwork(runtimeConfig.network);
+      const normalizedProtocol = normalizeUniswapLiquidityProtocol(protocol);
+      if (normalizedProtocol === "V4") {
+        // Uniswap's V4 PositionManager is intentionally not ERC-721 enumerable.
+        // Discovering token IDs requires a chain-specific indexed subgraph, then
+        // on-chain verification. Do not pretend balanceOf/tokenOfOwnerByIndex is
+        // available or ask an RPC provider to scan unbounded transfer history.
+        throw createTaggedError(
+          "Uniswap V4 position discovery requires a configured indexed subgraph; the V4 PositionManager is not ERC-721 enumerable.",
+          "uniswap_v4_position_discovery_unavailable",
+          { network: runtimeConfig.network }
+        );
+      }
+      const owner = await account.getAddress();
+      const positionManager = getUniswapLiquidityPositionManager(runtimeConfig.network, "V3");
+      const rawBalance = await callContract(
+        runtimeConfig.providerUrl,
+        positionManager,
+        UNISWAP_V3_POSITION_MANAGER_INTERFACE,
+        "balanceOf",
+        [owner]
+      );
+      const balance = BigInt(rawBalance[0]);
+      const requestedLimit = Number(limit);
+      const boundedLimit = Number.isInteger(requestedLimit) && requestedLimit > 0 ? Math.min(requestedLimit, 100) : 20;
+      const count = Number(balance > BigInt(boundedLimit) ? BigInt(boundedLimit) : balance);
+      const positions = [];
+      for (let index = 0; index < count; index += 1) {
+        const tokenIdResult = await callContract(
+          runtimeConfig.providerUrl,
+          positionManager,
+          UNISWAP_V3_POSITION_MANAGER_INTERFACE,
+          "tokenOfOwnerByIndex",
+          [owner, index]
+        );
+        const tokenId = BigInt(tokenIdResult[0]);
+        const position = await callContract(
+          runtimeConfig.providerUrl,
+          positionManager,
+          UNISWAP_V3_POSITION_MANAGER_INTERFACE,
+          "positions",
+          [tokenId]
+        );
+        positions.push({
+          tokenId: tokenId.toString(),
+          token0: String(position[2]),
+          token1: String(position[3]),
+          fee: Number(position[4]),
+          tickLower: Number(position[5]),
+          tickUpper: Number(position[6]),
+          liquidity: BigInt(position[7]).toString(),
+          tokensOwed0: BigInt(position[10]).toString(),
+          tokensOwed1: BigInt(position[11]).toString(),
+        });
+      }
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        protocol: "V3",
+        owner,
+        positionManager,
+        totalCount: balance.toString(),
+        returnedCount: positions.length,
+        truncated: balance > BigInt(positions.length),
+        positions,
+        source: "uniswap-v3-position-manager",
+      };
+    });
+  }
+
+  async quoteUniswapLiquidity({ seedPhrase, address, action, protocol, request, accountIndex = 0, network }) {
+    return this.#withReadableAccount({ seedPhrase, address, accountIndex, network }, async (account, runtimeConfig) => {
+      assertUniswapSupportedNetwork(runtimeConfig.network);
+      const normalizedAction = normalizeUniswapLiquidityAction(action);
+      const normalizedProtocol = normalizeUniswapLiquidityProtocol(protocol);
+      const walletAddress = await account.getAddress();
+      const body = this.#buildUniswapLiquidityRequest({ action: normalizedAction, protocol: normalizedProtocol, address: walletAddress, request });
+      body.chainId = runtimeConfig.chainId;
+      const payload = await this.#uniswapLiquidityApiRequest(normalizedAction, body);
+      const transaction = this.#validateUniswapLiquidityTransaction({
+        runtimeConfig,
+        protocol: normalizedProtocol,
+        address: walletAddress,
+        transaction: this.#extractUniswapLiquidityTransaction(payload, normalizedAction),
+      });
+      const approvals = await this.#getUniswapLiquidityApprovals({ runtimeConfig, protocol: normalizedProtocol, action: normalizedAction, address: walletAddress, payload });
+      const simulation = await this.#simulatePreparedTransaction({ runtimeConfig, from: walletAddress, tx: transaction, operationLabel: "Uniswap liquidity" });
+      return this.#formatUniswapLiquidityResponse({ runtimeConfig, accountIndex, address: walletAddress, action: normalizedAction, protocol: normalizedProtocol, request: body, payload, transaction, approvals, simulation });
+    });
+  }
+
+  async sendUniswapLiquidity({ seedPhrase, action, protocol, request, accountIndex = 0, network }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      assertUniswapSupportedNetwork(runtimeConfig.network);
+      const normalizedAction = normalizeUniswapLiquidityAction(action);
+      const normalizedProtocol = normalizeUniswapLiquidityProtocol(protocol);
+      const address = await account.getAddress();
+      // Rebuild immediately before signing: price/ticks and calldata can change
+      // while an intent approval is being reviewed.
+      const body = this.#buildUniswapLiquidityRequest({ action: normalizedAction, protocol: normalizedProtocol, address, request });
+      body.chainId = runtimeConfig.chainId;
+      let payload = await this.#uniswapLiquidityApiRequest(normalizedAction, body);
+      let transaction = this.#validateUniswapLiquidityTransaction({
+        runtimeConfig,
+        protocol: normalizedProtocol,
+        address,
+        transaction: this.#extractUniswapLiquidityTransaction(payload, normalizedAction),
+      });
+      const approvals = await this.#getUniswapLiquidityApprovals({ runtimeConfig, protocol: normalizedProtocol, action: normalizedAction, address, payload });
+      const approvalResults = [];
+      for (const approval of approvals) {
+        const approvalSimulation = await this.#simulatePreparedTransaction({ runtimeConfig, from: address, tx: approval.tx, operationLabel: "Uniswap liquidity approval" });
+        this.#assertSimulationSucceeded(approvalSimulation);
+        const approvalResult = await this.#sendBufferedDefiTransaction({ account, runtimeConfig, from: address, tx: approval.tx, operationLabel: "Uniswap liquidity approval" });
+        await this.#waitForTransactionReceipt(runtimeConfig, approvalResult.hash, { operationLabel: "Uniswap liquidity approval", failureCode: "uniswap_liquidity_approval_reverted", timeoutCode: "uniswap_liquidity_approval_timeout" });
+        approvalResults.push({ token: approval.token, spender: approval.spender, amount: approval.amount.toString(), hash: approvalResult.hash });
+      }
+      if (approvals.length) {
+        payload = await this.#uniswapLiquidityApiRequest(normalizedAction, body);
+        transaction = this.#validateUniswapLiquidityTransaction({
+          runtimeConfig,
+          protocol: normalizedProtocol,
+          address,
+          transaction: this.#extractUniswapLiquidityTransaction(payload, normalizedAction),
+        });
+      }
+      const simulation = await this.#simulatePreparedTransaction({ runtimeConfig, from: address, tx: transaction, operationLabel: "Uniswap liquidity" });
+      this.#assertSimulationSucceeded(simulation);
+      const result = await this.#sendBufferedDefiTransaction({ account, runtimeConfig, from: address, tx: transaction, operationLabel: "Uniswap liquidity" });
+      await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+        operationLabel: "Uniswap liquidity",
+        failureCode: "uniswap_liquidity_reverted",
+        timeoutCode: "uniswap_liquidity_confirmation_timeout",
+      });
+      return {
+        ...this.#formatUniswapLiquidityResponse({ runtimeConfig, accountIndex, address, action: normalizedAction, protocol: normalizedProtocol, request: body, payload, transaction, approvals, simulation }),
+        result,
+        approvalResults,
+        confirmed: true,
+      };
+    });
+  }
+
   async #fetchUniswapQuote({ runtimeConfig, routerProfile, address, swapRequest }) {
     const chainId = UNISWAP_SUPPORTED_CHAIN_IDS[runtimeConfig.network];
     const quoteRequest = {