@continuumdao/ctm-mpc-defi 0.2.56 → 0.2.58

package/dist/agent/skills/aave-v4/SKILL.md

@@ -11,7 +11,7 @@ Aave v4 organizes liquidity into **hubs** (market segments) and **spokes** (on-c
 
 | Concept | What it is | Agent needs to know |
 |---------|------------|---------------------|
-| **Hub** | Off-chain market segment (Core, Plus, Prime) | Maps to UI `marketId`: `main` → Plus, `core` → Core, `bluechip` → Prime |
+| **Hub** | Off-chain market segment (Core, Plus, Prime, Coinbase Stocks) | Maps to UI `marketId`: `main` → Plus, `core` → Core, `bluechip` → Prime, `bstocks` → Coinbase Stocks (Base tokenized equities) |
 | **Spoke** | On-chain contract (`supply`, `withdraw`, `borrow`, `repay`) | **Do not guess.** The MCP server resolves spoke from the Aave v4 API using `chainId` + `underlying` + `marketId` |
 | **Reserve** | One asset in one hub (underlying + APY + spoke) | From `ctm_aave_v4_fetch_markets` — do not web-search rates |
 | **Position** | User’s supplies/debt on a spoke | Withdraw/borrow/repay risk depends on health factor on that spoke |
@@ -33,6 +33,7 @@ Do **not** web-search Aave APRs, APYs, or reserves. Load the protocol and use th
 | User intent | MCP tool |
 |-------------|----------|
 | List reserves / lending APRs / compare rates | `ctm_aave_v4_fetch_markets` |
+| Base tokenized stocks (bStocks) | `ctm_aave_v4_fetch_stock_markets` |
 | One asset’s APY (optionally one hub) | `ctm_aave_v4_fetch_market` |
 | Supply / deposit (lend) | `ctm_aave_v4_build_deposit_multisign` |
 | Withdraw supplied balance | `ctm_aave_v4_build_withdraw_multisign` |
@@ -50,7 +51,7 @@ Do **not** web-search Aave APRs, APYs, or reserves. Load the protocol and use th
 | `purposeText` | yes | Human-readable reason for the sign request |
 | `underlying` | yes | Token address for the action (see per-action below) |
 | `amountHuman` | yes | Human amount (e.g. `"0.5"`, `"100"`) |
-| `marketId` | no | `main` (default), `core`, or `bluechip` |
+| `marketId` | no | `main` (default), `core`, `bluechip`, or `bstocks` (aliases: `stocks`, `equities`) |
 | `useCustomGas` | no | `true` to use chain registry gas config |
 | `spoke` | no | **Omit** — server resolves from Aave API |
 
@@ -87,7 +88,7 @@ Do **not** web-search Aave APRs, APYs, or reserves. Load the protocol and use th
 Example: “How do Aave lending APRs compare to Compound on Ethereum?”
 
 1. `load_defi_protocol({ protocolId: "aave-v4" })` then `get_defi_protocol_skill`.
-2. `ctm_aave_v4_fetch_markets` with `chainId` 1. Optional `marketId` (`main` / `core` / `bluechip`) or `underlying` to filter.
+2. `ctm_aave_v4_fetch_markets` with `chainId` 1. Optional `marketId` (`main` / `core` / `bluechip` / `bstocks`) or `underlying` to filter. On Base, `ctm_aave_v4_fetch_stock_markets` lists the Coinbase Stocks hub.
 3. Each row is one live spoke on a hub (unused zero-liquidity listings omitted): `supplyApyPercent`, `borrowApyPercent`, `utilizationPercent`, `availableLiquidity`. The same asset can appear on more than one spoke.
 4. Aave reports **APY** (compounded). Compound v3 reports **APR** — say so when comparing.
 5. Copy `underlying` + `marketId` for a later deposit/borrow. Do not invent rates from the web.
@@ -158,6 +159,28 @@ After stETH is supplied:
 }
 ```
 
+## bStocks (Base tokenized equities)
+
+Aave v4 on Base (chainId **8453**) has a **Coinbase Stocks** hub. UI and MCP `marketId` is **`bstocks`**. The same hub resolver is used by the node app and by `ctm_aave_v4_fetch_stock_markets` / `build_*_multisign`.
+
+- Collateral is whatever the Coinbase Stocks hub currently lists (`ctm_aave_v4_fetch_stock_markets`). Pass a ticker such as `AAPLc`; it resolves from the live Coinbase catalog. Equity reserves are **not borrowable**.
+- Borrow asset: **USDC** only. Supply the stock with `marketId: "bstocks"`, then borrow USDC. `collateralUnderlying` may be the stock ticker.
+- Chainlink equity feeds publish 24/5 (Sunday 20:00 ET through Friday 20:00 ET) and hold the last price over weekends and US market holidays. Health factor can still fall from interest while the feed is stale.
+- Coinbase Tokenized Stocks are not for U.S. persons.
+- Do not treat `main` as this hub. Base has no Plus hub; `main` does not select Coinbase Stocks.
+
+```json
+{
+  "keyGenId": "<keygen-id>",
+  "chainId": 8453,
+  "purposeText": "Supply 1 AAPLc to Aave v4 bStocks",
+  "underlying": "AAPLc",
+  "marketId": "bstocks",
+  "amountHuman": "1",
+  "enableAsCollateralAfterSupply": true
+}
+```
+
 ## Notes
 
 - Native supply uses wrapped native from `get_defi_protocol_supported_tokens` (`nativeWrapped`).

package/dist/agent/skills/aerodrome/SKILL.md

@@ -86,7 +86,9 @@ Skip emissions when `claimEmissions` is `null` (no gauge). Slipstream unstaked f
 
 Loaded from official GitHub (`velodrome-finance/sugar` `deployments/base.env` and `aerodrome-finance/docs` security.mdx) with baked fallbacks. Do not invent addresses.
 
-Coinbase B20 stocks (AAPLc, NVDAc, METAc, GOOGLc, SPCXc, …) trade on **Slipstream 3** (`clFactory3`) vs USDC. Stock-backed **loans** (lend/borrow USDC against B20 collateral) are Morpho — `load_defi_protocol morpho` and `ctm_morpho_fetch_stock_markets`, not Aerodrome LP. New official names are picked up from the [Base tokenized-stocks docs](https://docs.base.org/base-chain/asset-issuance/tokenized-stocks-on-base) and from Sugar tokens whose address uses the B20 ASSET prefix `0xb200…`. The docs fetch is optional: if that page is gone or unusable, discovery continues from the seed list + Sugar. `issued` is live `totalSupply() > 0` — do not hard-code unissued tickers. Quotes use factory `getPool` discovery + MixedRouteQuoterV3 (path bitmasks). Sugar `forSwaps` alone misses these pools. Native ETH → stock is typically WETH → USDC → stock.
+Aero (the Aerodrome rename) is scheduled for **2026-10-22 00:00 UTC** on Base, Ethereum, OP Mainnet, Arc, Ink, Robinhood Chain, and Arbitrum. Those contract addresses are not published yet, so quotes and writes stay on the live Base deployment (`chainId` 8453). Tokenized stocks stay on Base even after that launch.
+
+Coinbase B20 stocks (AAPLc, NVDAc, PYPLc, AMDc, ORCLc, BRK.Bc, …) trade on **Slipstream 3** (`clFactory3`) vs USDC. Tickers resolve from the live Coinbase tokenized-stocks API. There is no baked-in address list. Pass the ticker — do not ask for a contract address. Stock-backed **loans** (lend/borrow USDC against B20 collateral) are Morpho — `load_defi_protocol morpho` and `ctm_morpho_fetch_stock_markets`, not Aerodrome LP. Sugar tokens whose address uses the B20 ASSET prefix `0xb200…` are also treated as stocks. `issued` is live `totalSupply() > 0`. Quotes use factory `getPool` discovery + MixedRouteQuoterV3 (path bitmasks). Sugar `forSwaps` alone misses these pools. Native ETH → stock is typically WETH → USDC → stock.
 
 ## Out of scope
 

package/dist/agent/skills/circle-cctp/SKILL.md

@@ -33,7 +33,7 @@ After `{ requestId }`: `sign_request_agree` → `trigger_sign_result` → `broad
 | `sourceChainId` | yes | EIP-155 id where burn executes |
 | `destChainId` | yes | EIP-155 destination (mint chain) |
 | `transferAmountHuman` | yes for a usable maxFee | USDC the recipient receives (6 decimals). Protocol fee is this amount times Iris `minimumFee` bps. Omit only to inspect raw forwarding tiers. |
-| `feeTier` | no | `low` \| `med` (default) \| `high` |
+| `feeTier` | no | `low` \| `med` \| `high` (default) |
 | `minFinalityThreshold` | no | `1000` fast (default, has protocol fee) or `2000` standard |
 
 `maxFee = forwardFee[tier] + protocolFee`. `forwardFee*` is the Forwarding Service component only. `maxFeeLow` / `Med` / `High` are the combined caps. Returns `fees` plus the same fields at the top level, including `protocolFeeHuman`, `minimumFeeBps`, and `totalBurnHuman` when an amount was passed. Pass that output as `feeSnapshot` to build and balance tools. Do not add `minimumFee` again on top of `maxFee`.

package/dist/agent/skills/curve-dao/SKILL.md

@@ -55,8 +55,8 @@ Always quote first unless the user already has a verified route. Explain quote o
 | Field | Required | Notes |
 |-------|----------|-------|
 | `chainId` | yes | Must be Curve-supported (see supported chains below) |
-| `tokenIn` | yes | ERC-20 address, or native: `0xeeee…`, `0x0`, `eth` |
-| `tokenOut` | yes | ERC-20 address or `0xeeee…` for native out |
+| `tokenIn` | yes | ERC-20 address, a Coinbase stock ticker (`AAPLc`) from the live catalog, or native: `0xeeee…`, `0x0`, `eth` |
+| `tokenOut` | yes | ERC-20 address, the same Coinbase stock ticker, or `0xeeee…` for native out |
 | `amountHuman` | yes | Human decimal string of **tokenIn** (e.g. `"100"`, `"0.5"`) |
 | `tokenInDecimals` | no | Omit to read decimals on-chain (native = 18) |
 | `rpcUrl` | no | **Do not pass** — server injects from chain registry |

package/dist/agent/skills/railgun/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: railgun
+description: Shield public ERC-20s into the Railgun wallet stored on the KeyGen. Private transfer and unshield need the KeyGen signing quorum.
+---
+
+# Railgun (MCP)
+
+Railgun does not publish a token allowlist. Any standard ERC-20 on a deployed chain can be shielded, except CTM. CTM is off until a broadcaster quotes it: do not shield, privately transfer, or unshield CTM, and do not treat it as a supported Railgun token. The asset-row icon is the top 5 ERC-20s in the latest indexed Shield events. That read does not scan chain logs. Railgun is not deployed on Linea.
+
+Use `get_defi_protocol_supported_chains` for deployed chains. Contract addresses come from Railgun `NETWORK_CONFIG`. Do not invent chain ids or token lists.
+
+The 0zk address and its balances are stored on the KeyGen record. Each node holds a viewing key, so the node agent and Telegram can scan balances. The spending key is split into shares at the KeyGen signing quorum. No node can spend the 0zk wallet by itself. Do not ask the user to unlock a browser wallet, and do not pass a mnemonic, viewing key, or encryption key.
+
+## Tools
+
+| Intent | Tool |
+|--------|------|
+| Create the KeyGen Railgun wallet, or read its 0zk address | `ctm_railgun_ensure_wallet` |
+| Public tokens that show the Railgun icon | `ctm_railgun_fetch_popular_assets` |
+| This KeyGen's shielded balances | `ctm_railgun_fetch_private_balances` |
+| Shield a public ERC-20 into the 0zk address | `ctm_railgun_build_shield_multisign` |
+| Start a private transfer | `ctm_railgun_private_transfer` |
+| Start an unshield to a public address | `ctm_railgun_unshield` |
+| Agree this node's share of a pending spend | `ctm_railgun_agree_spend` |
+
+Call `ctm_railgun_ensure_wallet` first. Use the returned `railgunAddress` as the shield recipient. Call `ctm_railgun_fetch_private_balances` before an unshield or private transfer. Pass `refresh: true` when the stored scan may be stale. If `walletConfigured` is false, call `ctm_railgun_ensure_wallet` and then fetch again.
+
+`ctm_railgun_fetch_popular_assets` is the public icon list, not the shielded holdings.
+
+## Shield
+
+1. Call `ctm_railgun_build_shield_multisign` without `shieldSignature`, with `railgunAddress` from `ctm_railgun_ensure_wallet`. Submit that personal_sign request.
+2. Call the same tool again with `shieldSignature` set to the completed signature. Submit the resulting approve-and-shield transaction.
+
+The first call signs Railgun's shield message. The second call builds the EVM shield. If allowance is short, the second call includes an approve, and a zero-approve reset when a non-zero allowance is still too small. Shielding spends the KeyGen threshold key, not the 0zk spending key.
+
+## Private transfer and unshield
+
+These start a pending spend and agree this node's share. The response is `pending` until `approvals` reaches `quorum`. Tell the user the `spendId` and ask an operator on each other KeyGen node to call `ctm_railgun_agree_spend` with that id. When the quorum is reached, the node that started the spend builds the proof and discards the spending key. A later balance scan shows the result. Unshield defaults the recipient to the KeyGen Ethereum address.

package/dist/agent/skills/uniswap-v4/SKILL.md

@@ -41,8 +41,8 @@ Do not skip steps. Pass the **full quote JSON** into `create_swap`, then pass **
 |-------|----------|-------|
 | `type` | yes | `EXACT_INPUT` (sell exact tokenIn) or `EXACT_OUTPUT` (receive exact tokenOut) |
 | `amount` | yes | **Base units** string (wei for 18-decimal tokens). For human amounts, convert with token decimals first |
-| `tokenIn` | yes | Input token; native ETH: `0x0000000000000000000000000000000000000000` |
-| `tokenOut` | yes | Output token address (same chain) |
+| `tokenIn` | yes | Input token address, or a Coinbase stock ticker (`AAPLc`) from the live catalog. Native ETH: `0x0000000000000000000000000000000000000000` |
+| `tokenOut` | yes | Output token address, or the same Coinbase stock ticker |
 | `chainId` | yes | Must be Uniswap-supported |
 | `keyGenId` | recommended | Server resolves `swapper` (MPC executor) |
 | `swapper` | optional | MPC wallet address if `keyGenId` omitted |

package/dist/index.cjs

@@ -51,6 +51,124 @@ var init_expiry = __esm({
     ]);
   }
 });
+function isCoinbaseB20AssetToken(address) {
+  try {
+    return viem.getAddress(address).toLowerCase().startsWith(COINBASE_B20_ASSET_PREFIX);
+  } catch {
+    return false;
+  }
+}
+function looksLikeCoinbaseStockSymbol(symbol) {
+  return /^[A-Za-z][A-Za-z0-9]{0,8}(?:\.[A-Za-z][A-Za-z0-9]{0,4})?c$/.test((symbol ?? "").trim());
+}
+function indexCatalog(rows) {
+  catalogRows = rows;
+  catalogAt = Date.now();
+  catalogBySymbol.clear();
+  catalogByAddress.clear();
+  for (const row of rows) {
+    catalogBySymbol.set(row.symbol.toLowerCase(), row);
+    catalogByAddress.set(row.address.toLowerCase(), row);
+  }
+}
+function parseCoinbaseTokenizedStocksPayload(payload) {
+  const tokens = Array.isArray(payload) ? payload : payload && typeof payload === "object" && Array.isArray(payload.tokens) ? payload.tokens : [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of tokens) {
+    if (!row || typeof row !== "object") continue;
+    const rec = row;
+    const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
+    const addressRaw = typeof rec.contract_address === "string" ? rec.contract_address.trim() : "";
+    if (!looksLikeCoinbaseStockSymbol(symbol) || !isCoinbaseB20AssetToken(addressRaw)) continue;
+    const address = viem.getAddress(addressRaw);
+    const key = address.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const name = typeof rec.name === "string" && rec.name.trim() ? rec.name.trim() : symbol;
+    const iconUrl = typeof rec.icon_url === "string" && rec.icon_url.trim() ? rec.icon_url.trim() : void 0;
+    const decimals = typeof rec.decimals === "number" && Number.isInteger(rec.decimals) && rec.decimals >= 0 && rec.decimals <= 18 ? rec.decimals : COINBASE_B20_STOCK_DECIMALS;
+    out.push({ address, symbol, name, decimals, iconUrl });
+    if (out.length >= CATALOG_MAX) break;
+  }
+  return out;
+}
+async function fetchCoinbaseB20StockCatalog() {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  let pageToken = "";
+  for (let page = 0; page < 4; page++) {
+    const url = new URL(COINBASE_TOKENIZED_STOCKS_API_URL);
+    url.searchParams.set("page_size", "500");
+    if (pageToken) url.searchParams.set("page_token", pageToken);
+    const res = await fetch(url, { cache: "no-store", signal: AbortSignal.timeout(8e3) });
+    if (!res.ok) break;
+    const json = await res.json();
+    for (const row of parseCoinbaseTokenizedStocksPayload(json)) {
+      const key = row.address.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      merged.push(row);
+      if (merged.length >= CATALOG_MAX) break;
+    }
+    pageToken = typeof json.next_page_token === "string" ? json.next_page_token.trim() : "";
+    if (!pageToken || merged.length >= CATALOG_MAX) break;
+  }
+  if (merged.length > 0) indexCatalog(merged);
+  return catalogRows ?? [];
+}
+async function ensureCoinbaseB20StockCatalog() {
+  if (catalogRows && catalogRows.length > 0 && Date.now() - catalogAt < CATALOG_TTL_MS) return catalogRows;
+  if (!catalogInflight) {
+    catalogInflight = fetchCoinbaseB20StockCatalog().finally(() => {
+      catalogInflight = null;
+    });
+  }
+  try {
+    return await catalogInflight;
+  } catch {
+    return catalogRows ?? [];
+  }
+}
+function lookupCoinbaseB20StockToken(token) {
+  const key = (token ?? "").trim();
+  if (!key) return null;
+  const fromCatalog = catalogBySymbol.get(key.toLowerCase());
+  if (fromCatalog) return fromCatalog;
+  try {
+    return catalogByAddress.get(viem.getAddress(key).toLowerCase()) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function canonicalizeEvmTokenInput(token) {
+  const raw = (token ?? "").trim();
+  if (!raw || viem.isAddress(raw)) return raw;
+  if (!looksLikeCoinbaseStockSymbol(raw)) return raw;
+  await ensureCoinbaseB20StockCatalog().catch(() => []);
+  const hit = lookupCoinbaseB20StockToken(raw);
+  if (!hit) {
+    throw new Error(
+      `Unknown Coinbase stock ticker "${raw}". It is not in the live tokenized-stocks catalog.`
+    );
+  }
+  return hit.address;
+}
+var COINBASE_B20_STOCK_DECIMALS, COINBASE_B20_ASSET_PREFIX, COINBASE_TOKENIZED_STOCKS_API_URL, CATALOG_TTL_MS, CATALOG_MAX, catalogRows, catalogAt, catalogInflight, catalogBySymbol, catalogByAddress;
+var init_coinbaseB20 = __esm({
+  "src/protocols/evm/shared/coinbaseB20.ts"() {
+    COINBASE_B20_STOCK_DECIMALS = 8;
+    COINBASE_B20_ASSET_PREFIX = "0xb200000000000000000000";
+    COINBASE_TOKENIZED_STOCKS_API_URL = "https://api.coinbase.com/v1/tokenized-stocks";
+    CATALOG_TTL_MS = 15 * 60 * 1e3;
+    CATALOG_MAX = 500;
+    catalogRows = null;
+    catalogAt = 0;
+    catalogInflight = null;
+    catalogBySymbol = /* @__PURE__ */ new Map();
+    catalogByAddress = /* @__PURE__ */ new Map();
+  }
+});
 function isAerodromeChainSupported(chainId) {
   const n = typeof chainId === "number" ? chainId : Number.parseInt(String(chainId), 10);
   return n === AERODROME_CHAIN_ID;
@@ -946,6 +1064,9 @@ var UNISWAP_V4_LP_COLLECT_DEFAULT_GAS_UNITS = 900000n;
 var UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK = 100000n;
 var UNISWAP_V4_LP_WETH_DEPOSIT_FALLBACK = 120000n;
 var UNISWAP_V4_LP_PERMIT2_APPROVE_FALLBACK = 100000n;
+
+// src/protocols/evm/uniswap-v4/quote.ts
+init_coinbaseB20();
 viem.parseAbi([
   "function isAllowed(address account, uint8 permission) view returns (bool)",
   "function PERMISSIONED_TOKEN() view returns (address)"
@@ -1312,6 +1433,11 @@ function messageFromUniswapHttpResponseBody(text, status, statusText = "") {
   return short;
 }
 async function uniswapTradeQuote(args) {
+  args = {
+    ...args,
+    tokenIn: await canonicalizeEvmTokenInput(args.tokenIn),
+    tokenOut: await canonicalizeEvmTokenInput(args.tokenOut)
+  };
   const apiKey = (args.uniswapApiKey || "").trim();
   if (!apiKey) {
     throw new Error("uniswapApiKey (x-api-key) is required");
@@ -1431,6 +1557,7 @@ function parseUniswapQuoteClassicInOut(res) {
 }
 
 // src/protocols/evm/uniswap-v4/swapMultisign.ts
+init_coinbaseB20();
 init_defiEvmClient();
 function parseOptionalGasLimitString(raw) {
   if (raw == null) return null;
@@ -1763,7 +1890,7 @@ async function buildEvmMultisignBodyUniswapV4NativeInOnly(args, quoteInputWei) {
   });
 }
 async function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(args) {
-  const tokenIn = viem.getAddress(args.tokenIn);
+  const tokenIn = viem.getAddress(await canonicalizeEvmTokenInput(args.tokenIn));
   const parsedInOut = parseUniswapQuoteClassicInOut(args.fullQuoteSnapshot);
   const quoteInputWei = parsedInOut?.inputWei;
   if (quoteInputWei == null || quoteInputWei <= 0n) {
@@ -2038,6 +2165,7 @@ async function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(args) {
 var UNISWAP_V4_LP_POOL_LOOKUP_HINT = "Pool may not be initialized on this chain. Call ctm_uniswap_v4_list_lp_pools for other presets, pass a custom existingPool.poolReference, or use newPool to initialize a pool.";
 
 // src/protocols/evm/uniswap-v4/liquidityApi.ts
+init_coinbaseB20();
 var LP_HEADERS_BASE = {
   "Content-Type": "application/json",
   Accept: "application/json",
@@ -2142,36 +2270,47 @@ function extractUniswapLpTokenAmounts(response) {
   return { token0: read("token0"), token1: read("token1") };
 }
 async function uniswapLpCreatePosition(args) {
+  const independentAddress = await canonicalizeEvmTokenInput(args.independentToken.tokenAddress);
+  const existingPool = args.existingPool ? {
+    ...args.existingPool,
+    token0Address: await canonicalizeEvmTokenInput(args.existingPool.token0Address),
+    token1Address: await canonicalizeEvmTokenInput(args.existingPool.token1Address)
+  } : void 0;
+  const newPool = args.newPool ? {
+    ...args.newPool,
+    token0Address: await canonicalizeEvmTokenInput(args.newPool.token0Address),
+    token1Address: await canonicalizeEvmTokenInput(args.newPool.token1Address)
+  } : void 0;
   const body = {
     protocol: "V4",
     walletAddress: trimAddr2(args.walletAddress),
     chainId: args.chainId,
     independentToken: {
-      tokenAddress: trimAddr2(args.independentToken.tokenAddress),
+      tokenAddress: trimAddr2(independentAddress),
       amount: String(args.independentToken.amount).trim()
     },
     slippageTolerance: args.slippageTolerance ?? UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT,
     deadline: args.deadline ?? lpDeadlineUnix(),
     simulateTransaction: args.simulateTransaction ?? false
   };
-  if (args.existingPool) {
+  if (existingPool) {
     body.existingPool = {
-      token0Address: trimAddr2(args.existingPool.token0Address),
-      token1Address: trimAddr2(args.existingPool.token1Address),
-      poolReference: trimAddr2(args.existingPool.poolReference)
+      token0Address: trimAddr2(existingPool.token0Address),
+      token1Address: trimAddr2(existingPool.token1Address),
+      poolReference: trimAddr2(existingPool.poolReference)
     };
   }
-  if (args.newPool) {
+  if (newPool) {
     body.newPool = {
-      token0Address: trimAddr2(args.newPool.token0Address),
-      token1Address: trimAddr2(args.newPool.token1Address),
-      fee: args.newPool.fee,
-      tickSpacing: args.newPool.tickSpacing,
-      initialPrice: String(args.newPool.initialPrice).trim(),
-      ...args.newPool.hooks ? { hooks: trimAddr2(args.newPool.hooks) } : {}
+      token0Address: trimAddr2(newPool.token0Address),
+      token1Address: trimAddr2(newPool.token1Address),
+      fee: newPool.fee,
+      tickSpacing: newPool.tickSpacing,
+      initialPrice: String(newPool.initialPrice).trim(),
+      ...newPool.hooks ? { hooks: trimAddr2(newPool.hooks) } : {}
     };
   }
-  if (!args.existingPool && !args.newPool) {
+  if (!existingPool && !newPool) {
     throw new Error("Provide existingPool or newPool for LP create.");
   }
   if (args.priceBounds) {
@@ -2206,11 +2345,11 @@ async function uniswapLpIncreasePosition(args) {
     protocol: "V4",
     walletAddress: trimAddr2(args.walletAddress),
     chainId: args.chainId,
-    token0Address: trimAddr2(args.token0Address),
-    token1Address: trimAddr2(args.token1Address),
+    token0Address: trimAddr2(await canonicalizeEvmTokenInput(args.token0Address)),
+    token1Address: trimAddr2(await canonicalizeEvmTokenInput(args.token1Address)),
     nftTokenId: String(args.nftTokenId),
     independentToken: {
-      tokenAddress: trimAddr2(args.independentToken.tokenAddress),
+      tokenAddress: trimAddr2(await canonicalizeEvmTokenInput(args.independentToken.tokenAddress)),
       amount: String(args.independentToken.amount).trim()
     },
     slippageTolerance: args.slippageTolerance ?? UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT,
@@ -2820,6 +2959,7 @@ async function swapExactInput(args) {
 }
 
 // src/protocols/evm/uniswap-v4/limitOrder.ts
+init_coinbaseB20();
 function trimAddr3(a) {
   return a.trim();
 }
@@ -2920,6 +3060,11 @@ async function uniswapLimitOrderQuote(args) {
       args.nodeReadAuth ?? { bearerOnGet: true, jwt: null }
     );
   }
+  args = {
+    ...args,
+    tokenIn: await canonicalizeEvmTokenInput(args.tokenIn),
+    tokenOut: await canonicalizeEvmTokenInput(args.tokenOut)
+  };
   const chainIdForGuard = parseUniswapChainId(resolveInputChainId(args));
   assertUniswapLimitOrderChain(chainIdForGuard);
   const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : "https://trade-api.gateway.uniswap.org/v1";
@@ -3372,6 +3517,7 @@ async function loadFullCurveSessionForRpc(rpcUrl) {
 var CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS = 1200000n;
 
 // src/protocols/evm/curve-dao/multisign.ts
+init_coinbaseB20();
 init_defiEvmClient();
 var ETH_PLACEHOLDER2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 function txToViemStep(tx) {
@@ -3387,7 +3533,7 @@ function txToViemStep(tx) {
   return { to, data, value };
 }
 async function buildEvmMultisignBodyCurveDaoBatch(args) {
-  const tokenIn = viem.getAddress(args.tokenIn);
+  const tokenIn = viem.getAddress(await canonicalizeEvmTokenInput(args.tokenIn));
   const executor = viem.getAddress(args.executorAddress);
   const session = await loadFullCurveSessionForRpc(args.rpcUrl);
   if (!session?.curve?.router?.populateSwap) {
@@ -3396,7 +3542,7 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
   const { curve, wrappedNative } = session;
   const wn = wrappedNative;
   const tokenInId = toCurveRouterTokenId(tokenIn, wn);
-  const outTrim = (args.tokenOut ?? "").trim();
+  const outTrim = (await canonicalizeEvmTokenInput(args.tokenOut ?? "")).trim();
   const tokenOutId = toCurveRouterTokenId(
     outTrim.toLowerCase() === ETH_PLACEHOLDER2 ? ETH_PLACEHOLDER2 : viem.getAddress(outTrim),
     wn