@agentlayer.tech/wallet 0.1.93 → 0.1.94

package/.openclaw/extensions/agent-wallet/dist/index.js

@@ -29,6 +29,7 @@ const AUTONOMOUS_DEFI_TOOLS = new Set([
   "manage_evm_lido_withdrawal",
   "manage_evm_morpho_market_position",
   "manage_evm_morpho_vault_position",
+  "manage_evm_uniswap_liquidity",
 ]);
 const approvalPreviewCache = new Map();
 const WALLET_TOOL_ONLY_GUIDANCE =
@@ -1977,6 +1978,23 @@ const evmToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "search_uniswap_pairs",
+    description: "Search read-only onchain Uniswap-tradeable pairs by name, ticker, or ERC-20 address. Verify any returned token address independently before quoting or trading.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        token_address: { type: "string" },
+        chain: { type: "string" },
+        dex_id: { type: "string" },
+        all_chains: { type: "boolean" },
+        limit: { type: "integer" },
+        network: { type: "string", enum: EVM_CORE_NETWORKS },
+      },
+      additionalProperties: false,
+    },
+  },
   {
     name: "swap_evm_uniswap_tokens",
     description: "Preview, prepare, or execute a supported Uniswap path on ethereum, base, or robinhood: CLASSIC, UniswapX orders, or canonical ETH↔WETH wrap/unwrap. ERC-20 paths may use Permit2 EIP-712 or an UniswapX order signature. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically.",
@@ -1997,6 +2015,29 @@ const evmToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "manage_evm_uniswap_liquidity",
+    description: "Preview, prepare, or execute a Uniswap V3/V4 liquidity action on ethereum, base, or robinhood. Supported actions are create, increase, decrease, and claim_fees. The official Liquidity API builds the transaction again immediately before signing, so confirmation is scoped to the LP intent rather than fragile ticks or calldata.",
+    optional: true,
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "increase", "decrease", "claim_fees"] },
+        protocol: { type: "string", enum: ["V3", "V4"] },
+        request: {
+          type: "object",
+          description: "Official Uniswap Liquidity API fields. walletAddress, chainId, protocol, simulateTransaction, and permit/signature fields are controlled by the wallet.",
+          additionalProperties: true,
+        },
+        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        purpose: { type: "string" },
+        user_intent: { type: "boolean" },
+        network: { type: "string", enum: EVM_CORE_NETWORKS },
+      },
+      required: ["action", "protocol", "request", "mode", "purpose"],
+      additionalProperties: false,
+    },
+  },
   {
     name: "swap_evm_lifi_cross_chain_tokens",
     description: "Preview, prepare, or execute an EVM-origin cross-chain swap through LI.FI. This currently supports ethereum/base as the source network and ethereum/base/solana as the destination chain. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically.",

package/.openclaw/extensions/agent-wallet/index.ts

@@ -29,6 +29,7 @@ const AUTONOMOUS_DEFI_TOOLS = new Set([
   "manage_evm_lido_withdrawal",
   "manage_evm_morpho_market_position",
   "manage_evm_morpho_vault_position",
+  "manage_evm_uniswap_liquidity",
 ]);
 const approvalPreviewCache = new Map();
 const WALLET_TOOL_ONLY_GUIDANCE =
@@ -1977,6 +1978,23 @@ const evmToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "search_uniswap_pairs",
+    description: "Search read-only onchain Uniswap-tradeable pairs by name, ticker, or ERC-20 address. Verify any returned token address independently before quoting or trading.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        token_address: { type: "string" },
+        chain: { type: "string" },
+        dex_id: { type: "string" },
+        all_chains: { type: "boolean" },
+        limit: { type: "integer" },
+        network: { type: "string", enum: EVM_CORE_NETWORKS },
+      },
+      additionalProperties: false,
+    },
+  },
   {
     name: "swap_evm_uniswap_tokens",
     description: "Preview, prepare, or execute a supported Uniswap path on ethereum, base, or robinhood: CLASSIC, UniswapX orders, or canonical ETH↔WETH wrap/unwrap. ERC-20 paths may use Permit2 EIP-712 or an UniswapX order signature. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically.",
@@ -1997,6 +2015,29 @@ const evmToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "manage_evm_uniswap_liquidity",
+    description: "Preview, prepare, or execute a Uniswap V3/V4 liquidity action on ethereum, base, or robinhood. Supported actions are create, increase, decrease, and claim_fees. The official Liquidity API builds the transaction again immediately before signing, so confirmation is scoped to the LP intent rather than fragile ticks or calldata.",
+    optional: true,
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "increase", "decrease", "claim_fees"] },
+        protocol: { type: "string", enum: ["V3", "V4"] },
+        request: {
+          type: "object",
+          description: "Official Uniswap Liquidity API fields. walletAddress, chainId, protocol, simulateTransaction, and permit/signature fields are controlled by the wallet.",
+          additionalProperties: true,
+        },
+        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        purpose: { type: "string" },
+        user_intent: { type: "boolean" },
+        network: { type: "string", enum: EVM_CORE_NETWORKS },
+      },
+      required: ["action", "protocol", "request", "mode", "purpose"],
+      additionalProperties: false,
+    },
+  },
   {
     name: "swap_evm_lifi_cross_chain_tokens",
     description: "Preview, prepare, or execute an EVM-origin cross-chain swap through LI.FI. This currently supports ethereum/base as the source network and ethereum/base/solana as the destination chain. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically.",

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",
@@ -30,6 +30,7 @@
       "get_evm_token_balance",
       "get_evm_token_metadata",
       "get_evm_transaction_receipt",
+      "get_uniswap_swap_quote",
       "get_flash_trade_markets",
       "get_flash_trade_positions",
       "get_kamino_earn_positions",
@@ -61,11 +62,13 @@
       "manage_evm_morpho_vault_position",
       "manage_evm_lido_position",
       "manage_evm_lido_withdrawal",
+      "manage_evm_uniswap_liquidity",
       "search_uniswap_pairs",
       "set_evm_network",
       "set_wallet_backend",
       "sign_wallet_message",
       "swap_evm_lifi_cross_chain_tokens",
+      "swap_evm_uniswap_tokens",
       "swap_evm_tokens",
       "swap_solana_lifi_cross_chain_tokens",
       "swap_solana_tokens",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## v0.1.94 - 2026-08-13
+
+- **Added Uniswap V3/V4 liquidity provisioning for Ethereum, Base, and
+  Robinhood Chain.** The EVM wallet now previews, prepares, and executes
+  create, increase, decrease, and fee-claim actions through Uniswap's
+  Liquidity API. Final LP calldata is refreshed and simulated immediately
+  before signing; executable transactions are accepted only for pinned
+  PositionManager deployments and matching wallet/network fields.
+- **Added bounded LP approval handling and intent-safe confirmations.** Token
+  approvals are restricted to LP-request assets and approved spenders, while
+  confirmations bind the action, network, protocol, pool/position, and assets
+  rather than fast-expiring ticks or calldata. Single-sided concentrated
+  positions with a zero amount on one ERC-20 side no longer fail approval
+  discovery.
+- **Exposed LP actions through the provider gateway, OpenClaw, and Codex.**
+  The provider gateway forwards the existing shared Uniswap API key to the
+  Liquidity API; OpenClaw's pair-search contract was restored and registered.
+
 ## v0.1.93 - 2026-08-10
 
 - **Added `/cards` (Claude Code) and `cards` (Codex) for Laso Finance card

package/VERSION

@@ -1 +1 @@
-0.1.93
+0.1.94

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.93"
+__version__ = "0.1.94"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/autonomous_permissions.py

@@ -31,6 +31,7 @@ DEFI_TOOLS = frozenset(
         "manage_evm_lido_withdrawal",
         "manage_evm_morpho_market_position",
         "manage_evm_morpho_vault_position",
+        "manage_evm_uniswap_liquidity",
     }
 )
 DEFI_TOOLS_ISSUER = "autonomous-permission:defi-tools"

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -751,6 +751,28 @@ class OpenClawWalletAdapter:
                 "quote_fingerprint": provided_fingerprint,
             }
 
+        if asset_type == "evm-uniswap-liquidity":
+            request = payload.get("request") if isinstance(payload.get("request"), dict) else {}
+            existing_pool = request.get("existingPool") if isinstance(request.get("existingPool"), dict) else {}
+            return {
+                "operation": action_label,
+                "network": str(payload.get("network") or getattr(self.backend, "network", "unknown")),
+                "from_address": payload.get("from_address"),
+                "protocol": payload.get("protocol"),
+                "liquidity_action": payload.get("liquidity_action"),
+                "liquidity_protocol": payload.get("liquidity_protocol"),
+                # Intent binds to the action and caller-provided LP scope, not a
+                # per-block transaction hash, adjusted ticks, or calculated amount.
+                "token0_address": request.get("token0Address") or existing_pool.get("token0Address"),
+                "token1_address": request.get("token1Address") or existing_pool.get("token1Address"),
+                "pool_reference": existing_pool.get("poolReference"),
+                "position_token_id": request.get("nftTokenId") or request.get("tokenId") or payload.get("position_token_id"),
+                "independent_token": request.get("independentToken"),
+                "liquidity_percentage_to_decrease": request.get("liquidityPercentageToDecrease"),
+                "slippage_tolerance": request.get("slippageTolerance"),
+                "position_manager": payload.get("position_manager"),
+            }
+
         if asset_type == "evm-morpho-vault":
             return {
                 "operation": action_label,
@@ -1722,6 +1744,35 @@ class OpenClawWalletAdapter:
                         risk_level="low",
                     ),
                 )
+                tools.insert(
+                    13,
+                    AgentToolSpec(
+                        name="manage_evm_uniswap_liquidity",
+                        description=(
+                            "Preview, prepare, or execute a Uniswap V3/V4 liquidity action on ethereum, base, or robinhood. "
+                            "Supported actions are create, increase, decrease, and claim_fees. The request is passed to the "
+                            "official Uniswap Liquidity API; execute refreshes the transaction immediately before signing."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "action": {"type": "string", "enum": ["create", "increase", "decrease", "claim_fees"]},
+                                "protocol": {"type": "string", "enum": ["V3", "V4"]},
+                                "request": {"type": "object", "description": "Uniswap LP API fields excluding walletAddress, chainId, protocol, and simulateTransaction; those are set from the active wallet.", "additionalProperties": True},
+                                "mode": {"type": "string", "enum": ["preview", "prepare", "execute"]},
+                                "purpose": {"type": "string"},
+                                "user_intent": {"type": "boolean"},
+                                "approval_token": {"type": "string"},
+                                "network": {"type": "string", "enum": ["ethereum", "base", "robinhood"]},
+                            },
+                            "required": ["action", "protocol", "request", "mode", "purpose"],
+                            "additionalProperties": False,
+                        },
+                        read_only=False,
+                        requires_explicit_user_intent=True,
+                        risk_level="high",
+                    ),
+                )
                 tools.insert(
                     14,
                     AgentToolSpec(
@@ -5757,6 +5808,91 @@ class OpenClawWalletAdapter:
                     ),
                 )
 
+            if tool_name == "manage_evm_uniswap_liquidity":
+                action = args.get("action")
+                protocol = args.get("protocol")
+                request = args.get("request")
+                mode = args.get("mode")
+                purpose = args.get("purpose")
+                user_intent = args.get("user_intent", False)
+                approval_token = args.get("approval_token")
+                if action not in {"create", "increase", "decrease", "claim_fees"}:
+                    raise WalletBackendError("action must be create, increase, decrease, or claim_fees.")
+                if protocol not in {"V3", "V4"}:
+                    raise WalletBackendError("protocol must be V3 or V4.")
+                if not isinstance(request, dict):
+                    raise WalletBackendError("request must be an object.")
+                if mode not in {"preview", "prepare", "execute"}:
+                    raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
+                if not isinstance(purpose, str) or not purpose.strip():
+                    raise WalletBackendError("purpose is required.")
+                # The caller must not override values that are derived from the
+                # active wallet/network in the WDK layer.
+                forbidden = {"walletAddress", "chainId", "protocol", "simulateTransaction", "signature", "batchPermitData", "v4BatchPermitData", "v3NftPermitData"}
+                overlap = forbidden.intersection(request)
+                if overlap:
+                    raise WalletBackendError(f"request must not set wallet-controlled fields: {', '.join(sorted(overlap))}.")
+                preview_kwargs = {"action": action, "protocol": protocol, "request": dict(request)}
+                if mode == "preview":
+                    preview = await active_backend.preview_uniswap_liquidity(**preview_kwargs)
+                    return AgentToolResult(tool=tool_name, ok=True, data=self._annotate_sensitive_payload(preview, action_label="Uniswap liquidity", mode="preview"))
+                if mode == "prepare":
+                    self._require_prepare_intent(user_intent)
+                    preview = await active_backend.preview_uniswap_liquidity(**preview_kwargs)
+                    return AgentToolResult(tool=tool_name, ok=True, data=self._annotate_sensitive_payload(self._build_prepare_plan(preview_payload=preview, action_label="Uniswap liquidity"), action_label="Uniswap liquidity", mode="prepare"))
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(active_backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
+                    )
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
+                        raise WalletBackendError("approval_token does not match the requested LP operation. Generate a new approval after prepare.")
+                    approval_summary_copy = dict(approval_summary)
+                else:
+                    fresh_preview = await active_backend.preview_uniswap_liquidity(**preview_kwargs)
+                    approval_summary_copy = self._build_confirmation_summary(action_label="Uniswap liquidity", payload=fresh_preview)
+                expected = {
+                    "operation": "Uniswap liquidity",
+                    "network": str(getattr(active_backend, "network", "unknown")),
+                    "liquidity_action": action,
+                    "liquidity_protocol": protocol,
+                }
+                for key, value in expected.items():
+                    if approval_summary_copy.get(key) != value:
+                        raise WalletBackendError("approval_token does not match the requested LP operation. Generate a new approval after prepare.")
+                # An LP intent deliberately does not bind API-calculated ticks,
+                # price, calldata, or quote amounts: those are regenerated just
+                # before broadcast. It must still be scoped to the selected
+                # assets/pool/position so an approval cannot be reused for a
+                # different liquidity position.
+                requested_scope = self._build_confirmation_summary(
+                    action_label="Uniswap liquidity",
+                    payload={
+                        "asset_type": "evm-uniswap-liquidity",
+                        "network": str(getattr(active_backend, "network", "unknown")),
+                        "protocol": "uniswap",
+                        "liquidity_action": action,
+                        "liquidity_protocol": protocol,
+                        "request": preview_kwargs["request"],
+                    },
+                )
+                for key in ("token0_address", "token1_address", "pool_reference", "position_token_id", "independent_token"):
+                    requested_value = requested_scope.get(key)
+                    if requested_value is not None and approval_summary_copy.get(key) != requested_value:
+                        raise WalletBackendError("approval_token does not match the requested LP assets or position. Generate a new approval after prepare.")
+                self._require_execute_approval(
+                    approval_token=approval_token,
+                    tool_name=tool_name,
+                    summary=approval_summary_copy,
+                    action_label="Uniswap liquidity",
+                    backend=active_backend,
+                )
+                result = await active_backend.send_uniswap_liquidity(**preview_kwargs)
+                return AgentToolResult(tool=tool_name, ok=True, data=self._annotate_sensitive_payload(result, action_label="Uniswap liquidity", mode="execute"))
+
             if tool_name == "issue_wallet_approval":
                 from agent_wallet.approval import issue_approval_token
 

package/agent-wallet/agent_wallet/providers/wdk_evm_local.py

@@ -40,6 +40,8 @@ LONG_RUNNING_POST_PATHS = {
     "/v1/evm/swap/send",
     "/v1/evm/uniswap/swap/quote",
     "/v1/evm/uniswap/swap/send",
+    "/v1/evm/uniswap/liquidity/quote",
+    "/v1/evm/uniswap/liquidity/send",
     "/v1/evm/lifi/quote",
     "/v1/evm/lifi/send",
     "/v1/evm/transfer/send",

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -349,6 +349,24 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Uniswap swaps.")
 
+    async def preview_uniswap_liquidity(
+        self,
+        *,
+        action: str,
+        protocol: str,
+        request: dict[str, Any],
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap liquidity previews.")
+
+    async def send_uniswap_liquidity(
+        self,
+        *,
+        action: str,
+        protocol: str,
+        request: dict[str, Any],
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap liquidity operations.")
+
     async def preview_evm_native_transfer(
         self,
         *,

package/agent-wallet/agent_wallet/wallet_layer/wdk_evm.py

@@ -2028,6 +2028,103 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "source": str(data.get("source") or "wdk-evm-wallet"),
         }
 
+    def _normalize_uniswap_liquidity_payload(
+        self,
+        data: dict[str, Any],
+        *,
+        action: str,
+        protocol: str,
+    ) -> dict[str, Any]:
+        transaction = dict(data.get("transaction") or {})
+        result = dict(data.get("result") or {})
+        request = dict(data.get("request") or {})
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "asset_type": "evm-uniswap-liquidity",
+            "protocol": str(data.get("protocol") or "uniswap"),
+            "liquidity_action": str(data.get("liquidityAction") or action),
+            "liquidity_protocol": str(data.get("liquidityProtocol") or protocol).upper(),
+            "from_address": str(data.get("address") or "").strip() or None,
+            "request": request,
+            "request_id": str(data.get("requestId") or "").strip() or None,
+            "token0": data.get("token0"),
+            "token1": data.get("token1"),
+            "tick_lower": data.get("tickLower"),
+            "tick_upper": data.get("tickUpper"),
+            "adjusted_min_price": data.get("adjustedMinPrice"),
+            "adjusted_max_price": data.get("adjustedMaxPrice"),
+            "position_token_id": str(data.get("positionTokenId") or "").strip() or None,
+            "position_manager": str(data.get("positionManager") or "").strip() or None,
+            "gas_fee": str(data.get("gasFee")) if data.get("gasFee") is not None else None,
+            "approvals": list(data.get("approvals") or []),
+            "approval_results": list(data.get("approvalResults") or []),
+            "simulation": _normalize_swap_simulation(data.get("simulation")),
+            "transaction": {
+                "to": str(transaction.get("to") or "").strip() or None,
+                "value": str(transaction.get("value") or "0"),
+                "data_hash": str(transaction.get("dataHash") or "").strip() or None,
+            },
+            "hash": result.get("hash"),
+            "result": result,
+            "chain_id": int(data.get("chainId") or 0),
+            "broadcasted": bool(result.get("hash")),
+            "confirmed": bool(data.get("confirmed")),
+            "source": str(data.get("source") or "wdk-evm-wallet"),
+        }
+
+    async def preview_uniswap_liquidity(
+        self,
+        *,
+        action: str,
+        protocol: str,
+        request: dict[str, Any],
+    ) -> dict[str, Any]:
+        if not isinstance(request, dict):
+            raise WalletBackendError("Uniswap liquidity request must be an object.")
+        data = await self.client.post(
+            "/v1/evm/uniswap/liquidity/quote",
+            {
+                "walletId": self.wallet_id,
+                "address": await self.get_address(),
+                "accountIndex": self.account_index,
+                "network": self.network,
+                "action": action,
+                "protocol": protocol,
+                "request": request,
+            },
+        )
+        normalized = self._normalize_uniswap_liquidity_payload(data, action=action, protocol=protocol)
+        normalized["from_address"] = await self.get_address()
+        normalized["execution_supported"] = not self.sign_only
+        return normalized
+
+    async def send_uniswap_liquidity(
+        self,
+        *,
+        action: str,
+        protocol: str,
+        request: dict[str, Any],
+    ) -> dict[str, Any]:
+        if self.sign_only:
+            raise WalletBackendError("wdk_evm_local is configured as sign_only.")
+        if not isinstance(request, dict):
+            raise WalletBackendError("Uniswap liquidity request must be an object.")
+        data = await self.client.post(
+            "/v1/evm/uniswap/liquidity/send",
+            {
+                "walletId": self.wallet_id,
+                "accountIndex": self.account_index,
+                "network": self.network,
+                "action": action,
+                "protocol": protocol,
+                "request": request,
+            },
+        )
+        normalized = self._normalize_uniswap_liquidity_payload(data, action=action, protocol=protocol)
+        normalized["from_address"] = await self.get_address()
+        return normalized
+
     async def preview_evm_lifi_cross_chain_swap(
         self,
         *,

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.93"
+version = "0.1.94"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/server.py

@@ -69,6 +69,7 @@ AUTONOMOUS_DEFI_TOOLS = {
     "manage_evm_lido_withdrawal",
     "manage_evm_morpho_market_position",
     "manage_evm_morpho_vault_position",
+    "manage_evm_uniswap_liquidity",
 }
 APPROVAL_PREVIEW_TOOL_ALIASES = {
     "x402_pay_request": "x402_preview_request",

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.93
+version: 0.1.94
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Universal AgentLayer wallet installer for OpenClaw, Codex, Claude Code, and Hermes.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/.env.example

@@ -26,6 +26,9 @@ MORPHO_API_BASE_URL=https://api.morpho.org/graphql
 # directly (https://trade-api.gateway.uniswap.org/v1) for legacy/offline direct mode.
 UNISWAP_API_KEY=
 # UNISWAP_TRADING_API_BASE_URL=   # defaults to PROVIDER_GATEWAY_URL/v1/evm/uniswap
+# LP actions use the Liquidity API. Gateway mode is the default; set this only
+# for direct API access (for example https://liquidity.api.uniswap.org).
+# UNISWAP_LIQUIDITY_API_BASE_URL= # defaults to PROVIDER_GATEWAY_URL/v1/evm/uniswap/lp
 UNISWAP_ROUTER_VERSION=2.0
 # Optional per-network override; each value must exist in the wallet's reviewed
 # execution profile and match the provider-gateway's per-chain configuration.

package/wdk-evm-wallet/README.md

@@ -187,6 +187,7 @@ Environment variables:
 - `MORPHO_API_BASE_URL`
 - `UNISWAP_API_KEY`
 - `UNISWAP_TRADING_API_BASE_URL`
+- `UNISWAP_LIQUIDITY_API_BASE_URL`
 - `UNISWAP_ROUTER_VERSION`
 - `UNISWAP_ROUTER_VERSION_BY_NETWORK`
 - `UNISWAP_DEFAULT_SLIPPAGE_BPS`
@@ -214,6 +215,11 @@ Swap providers:
 - `UNISWAP_API_KEY` is required for the Uniswap routes; it identifies the
   integrator (this service), not an end user — swaps are scoped per request by the
   active wallet address, so a single key never mixes users
+- LP actions (`create`, `increase`, `decrease`, `claim_fees`) are exposed at
+  `/v1/evm/uniswap/liquidity/*` and use Uniswap's Liquidity API. The runtime
+  accepts transactions only for pinned V3/V4 PositionManager deployments on
+  Ethereum, Base, and Robinhood, refreshes the final LP transaction just before
+  signing, and executes only API-returned bounded approvals.
 
 Gateway mode:
 

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "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,18 @@ 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/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,28 @@ 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)",
+]);
 // 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 +947,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 +5790,304 @@ 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 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 = {