hookit-mcp 0.7.2 → 0.8.0

package/README.md

@@ -18,7 +18,7 @@ Lets an AI agent launch a coin on [hookit.fun](https://www.hookit.fun) (Ink) by
 
 The key signs on this machine and is never sent anywhere. Give it a wallet funded for what the agent should do and nothing else.
 
-Optional env: `HOOKIT_API_URL` (default `https://www.hookit.fun`), `HOOKIT_RPC_URL` (default Ink public RPC), `HOOKIT_MAX_BUY_ETH` (largest single `buy_token` paid in ETH, default `0.5`), `HOOKIT_MAX_BUY_USD` (largest single `buy_token` paid in a token, in dollars, default `1000`), `HOOKIT_SEND_ETH_TO` (comma-separated addresses `send_eth` may pay, for example your Kraken deposit address on Ink; unset, any address), `HOOKIT_MEMORY_EVOLVE` / `HOOKIT_MEMORY_LENS` / `HOOKIT_MEMORY_FEE1` / `HOOKIT_MEMORY_FEE2` (override Memory on Evolve's pinned addresses), `HOOKIT_VELOCITY_FEE_PLUGIN` / `HOOKIT_VELOCITY_EVOLVE` / `HOOKIT_VELOCITY_EVOLVE_FEE1` / `HOOKIT_VELOCITY_EVOLVE_FEE2` (override Velocity Fee's pinned addresses), `HOOKIT_MASTER_HOOK_D` (overrides the pinned hook D, the Master hook new launches go to; coins keep trading on their own PoolKey's hook either way, this only names it in `coin_info`).
+Optional env: `HOOKIT_API_URL` (default `https://www.hookit.fun`), `HOOKIT_RPC_URL` (default Ink public RPC), `HOOKIT_RELAY_API_URL` (default `https://api.relay.link`) and `HOOKIT_RELAY_API_KEY` (a Relay API key, for higher quote limits), `HOOKIT_MAX_BUY_ETH` (largest single `buy_token` paid in ETH, default `0.5`), `HOOKIT_MAX_BUY_USD` (largest single `buy_token` paid in a token, in dollars, default `1000`), `HOOKIT_SEND_ETH_TO` (comma-separated addresses `send_eth` may pay, for example your Kraken deposit address on Ink; unset, any address), `HOOKIT_MEMORY_EVOLVE` / `HOOKIT_MEMORY_LENS` / `HOOKIT_MEMORY_FEE1` / `HOOKIT_MEMORY_FEE2` (override Memory on Evolve's pinned addresses), `HOOKIT_VELOCITY_FEE_PLUGIN` / `HOOKIT_VELOCITY_EVOLVE` / `HOOKIT_VELOCITY_EVOLVE_FEE1` / `HOOKIT_VELOCITY_EVOLVE_FEE2` (override Velocity Fee's pinned addresses), `HOOKIT_MASTER_HOOK_D` (overrides the pinned hook D, the Master hook new launches go to; coins keep trading on their own PoolKey's hook either way, this only names it in `coin_info`). `HOOKIT_EVOLVE_PLUGIN` (overrides the pinned Evolve v2 plugin, where new Evolve coins launch) and `HOOKIT_EVOLVE_V2_MEMORY_EVOLVE` / `_MEMORY_LENS` / `_MEMORY_FEE1` / `_MEMORY_FEE2` / `_VELOCITY_EVOLVE` / `_VELOCITY_EVOLVE_FEE1` / `_VELOCITY_EVOLVE_FEE2` (override Memory's and Velocity's Evolve v2 deployments; the `HOOKIT_MEMORY_*` and `HOOKIT_VELOCITY_EVOLVE*` ones are Evolve v1's).
 
 Coin names, tickers and descriptions are written by whoever launched the coin. The server hands them to the agent as untrusted data: `coin_info` withholds a description that carries a link, a handle, an address or a tool name, names and tickers that read as instructions are replaced, and every tool that signs is annotated so your MCP client can ask you before each call. Keep that confirmation on for a funded wallet, and set `HOOKIT_SEND_ETH_TO` if the agent only ever cashes out to one place.
 
@@ -65,15 +65,15 @@ Paying or receiving a token approves exactly that amount to the contract that tr
 
 ### Paying with something the coin does not trade in (Relay)
 
-`coin_info` lists what a coin trades in (`tradeIn`). When `payWith` or `receive` is not one of them, the server swaps through [Relay](https://relay.link) on Ink, the same route hookit.fun's own swap box uses: it asks `https://www.hookit.fun/api/relay/quote` for the swap (Relay's API key stays on that server), then signs Relay's transactions itself. A buy swaps first and buys with what Relay returned; a sale sells for the coin's pair first, then swaps the proceeds. `dryRun` shows both legs.
+`coin_info` lists what a coin trades in (`tradeIn`). When `payWith` or `receive` is not one of them, the server swaps through [Relay](https://relay.link) on Ink, the same route hookit.fun's own swap box uses: it asks Relay's API (`https://api.relay.link`) for the swap directly, so hookit.fun never shapes the calls the wallet signs, then signs Relay's transactions itself. A buy swaps first and buys with what Relay returned; a sale sells for the coin's pair first, then swaps the proceeds. `dryRun` shows both legs.
 
-Before signing, Relay's transactions are checked twice. First their shape: Ink only, calls only to Relay's Ink contracts (router, approval proxy, receiver, multicaller, depository), an approval only of Relay's approval proxy (replaced by an exact approval of the amount), and no more ETH than the amount. Then their effect: the approval and every call run together in one `eth_simulateV1` from the wallet, and the swap is refused unless the wallet would give at most the amount, get at least the minimum, and lose nothing else. That minimum is never the quote's word alone: it is at least the market price (Chainlink's ETH/USD as Factory C reads it, a stock's USDG pool on Ink, else hookit.fun's price) less the slippage and 5% for Relay's fees and price impact, and a quote under that floor is refused. Anything else is refused and nothing is sent. No allowance to Relay is left behind, even when a swap fails. One Relay swap converts at most the per-buy cap (`HOOKIT_MAX_BUY_ETH` / `HOOKIT_MAX_BUY_USD`), with at most 3% slippage. Relay swaps ETH or USDG with each other, kBTC and the tokenized stocks. The RPC in `HOOKIT_RPC_URL` must support `eth_simulateV1` (Ink's public RPC does).
+Before signing, Relay's transactions are checked twice. First their shape: Ink only, calls only to Relay's Ink contracts (router, approval proxy, receiver, multicaller, depository), an approval only of Relay's approval proxy (replaced by an exact approval of the amount), and no more ETH than the amount. Then their effect: the approval and every call run together in one validated `eth_simulateV1` from the wallet, priced with the same fee fields the swap is then signed with (so a called contract cannot tell the simulation by a zero gas price), and the swap is refused unless the wallet would give at most the amount, get at least the minimum, and lose nothing else. That minimum is never the quote's word alone: it is at least the market price (Chainlink's ETH/USD as Factory C reads it, a stock's USDG pool on Ink, else hookit.fun's price) less the slippage and 5% for Relay's fees and price impact, and a quote under that floor is refused. Anything else is refused and nothing is sent. No allowance to Relay is left behind, even when a swap fails. One Relay swap converts at most the per-buy cap (`HOOKIT_MAX_BUY_ETH` / `HOOKIT_MAX_BUY_USD`), with at most 3% slippage. Relay swaps ETH or USDG with each other, kBTC and the tokenized stocks. The RPC in `HOOKIT_RPC_URL` must support `eth_simulateV1` (Ink's public RPC does).
 
 When the first leg went through and the second did not, the reply is `partial: true` with what the wallet now holds: do not retry the call, or the first leg runs twice.
 
 ### What the server trusts
 
-The contracts it approves, pays or quotes from (Factory C and the Master factories, CreatorPayoutRouterC, HookitSwapRouter, the aggregator's RouteConfigC, Uniswap's V4Quoter, USDG, FloorLoanPlugin, the Gated Buy plugin, the Evolve plugin, NFT Strategy and Memory on Evolve, ModuleRegistry, Velocity Fee and Velocity on Evolve, and the Agent Pass) are pinned in the server, not read from hookit.fun: a Hookit redeploy needs a new hookit-mcp release. Since 0.7.2 the payout router is the M-01 CreatorPayoutRouterC `0x3e8E8a1F3D2279cB59042B029637c7096EeC2302` and `coin_info` names hook D `0x8a29B2c508007707bbFF1814386AA968bbeCbFff` (HookRegistry's default for new launches since 2026-10-16) next to hook C `0x4b533C432516FC1Be4b0bAEFe6BFF0942AD87FfF` (earlier coins). A launch prepared by hookit.fun is only signed when it goes to Factory C or its payout router with at most the launch fee plus `HOOKIT_MAX_BUY_ETH`. Tools that sign run one at a time, even when an agent calls several at once.
+The contracts it approves, pays or quotes from (Factory C and the Master factories, CreatorPayoutRouterC, HookitSwapRouter, the aggregator's RouteConfigC, Uniswap's V4Quoter, USDG, FloorLoanPlugin, the Gated Buy plugin, the Evolve plugin, NFT Strategy and Memory on Evolve, ModuleRegistry, Velocity Fee and Velocity on Evolve, and the Agent Pass) are pinned in the server, not read from hookit.fun: a Hookit redeploy needs a new hookit-mcp release. Since 0.7.2 the payout router is the M-01 CreatorPayoutRouterC `0x3e8E8a1F3D2279cB59042B029637c7096EeC2302` and `coin_info` names hook D `0x8a29B2c508007707bbFF1814386AA968bbeCbFff` (HookRegistry's default for new launches since 2026-10-16) next to hook C `0x4b533C432516FC1Be4b0bAEFe6BFF0942AD87FfF` (earlier coins). A launch prepared by hookit.fun is only signed when it goes to Factory C or its payout router with at most the launch fee plus `HOOKIT_MAX_BUY_ETH`, and when its calldata pays the creator fees to the `payout` asked: this wallet through Factory C, or the router's provider, account id and wallet. A TikTok handle is hashed by the server itself and a GitHub handle looked up on api.github.com before preparing; an X handle without `accountId` takes hookit.fun's lookup, and the result's `payout` shows the account id the transaction pays. Tools that sign run one at a time, even when an agent calls several at once.
 
 ## Evolve: the wallet that launches decides
 
@@ -89,6 +89,7 @@ evolve_decide({ "token": "0x…", "feePct": 2, "reason": "Heavy selling: a highe
 - A setting that raises neither the fee nor the creator share applies at once. A raise is announced on the coin page and applies after the launch's notice (1 h); a new decision replaces it, `cancel: true` drops it.
 - The reason is optional and public on chain: plain text, no links, e-mails, domains or @handles (refused before sending).
 - The decider cannot change the code, the liquidity or the name, and cannot redirect money: the caps and the sinks are fixed at launch. A lost key leaves the coin on its live setting.
+- Two Evolve versions (0.8.0): new Evolve coins launch on Evolve v2, the current module, read from the ModuleRegistry by the pinned v2 plugin's address (Evolve v1, module 5, is deprecated: no new launch on it). Coins launched on v1 keep working: every `evolve_*`, `memory_*` and `velocity_*` tool finds the plugin that knows the coin and uses that version's catalog and hooks. Until v2 has code at its address, the server launches on v1. A launch is signed only when its Evolve slot is the current module with exactly the 288 bytes of its settings: hookit-mcp never plugs hooks at launch (it plugs them with `evolve_plug`, `memory_set` and `velocity_set`). NFT Strategy is on Evolve v1 coins only for now.
 
 ## Evolve: hooks added later
 
@@ -211,7 +212,7 @@ launch_token({ "name": "…", "symbol": "…", "hookTaxPct": 3, "builderHooks":
 
 - `deploy_hook` takes the Foundry artifact (`out/<File>.sol/<Contract>.json` after `forge build`, as an absolute path: the server runs in its own folder) and refuses anything that is not a deployable plugin: built on the SDK's `HookPluginBase`, one `address` constructor, no linked libraries, code within Ink's limits. It reads regular files only, up to 16 MiB, and never quotes a file it cannot use. The constructor argument is always the ModuleRegistry pinned here, never one the agent or a website names.
 - `submit_hook` sends the manifest as the SDK wrote it and cleans the card exactly as the Workshop's form does, then signs the Workshop's submit message. Before signing, it checks that the manifest's codehash is the code deployed at its address and refuses a submission hookit.fun would refuse (a live plugin, or one that already has a submission in review or approved); it warns when the explorer names another deployer.
-- Nothing here is an audit: Hookit's review may ask for changes (a change is a new deployment and a new submission), and it can halt a plugin at any time.
+- Hookit's review may ask for changes (a change is a new deployment and a new submission), and it can halt a plugin at any time.
 - Both signing tools are dry runs unless `dryRun` is `false`: deploy or submit only once the user said to.
 
 ## Backed Floor: redeem and borrow

package/index.js

@@ -44,7 +44,7 @@ const API = (process.env.HOOKIT_API_URL || "https://www.hookit.fun").replace(/\/
 const INK_PUBLIC_RPC = "https://rpc-gel.inkonchain.com";
 const RPC = process.env.HOOKIT_RPC_URL || INK_PUBLIC_RPC;
 const KEY = process.env.HOOKIT_PRIVATE_KEY?.trim();
-const VERSION = "0.7.2";
+const VERSION = "0.8.0";
 const EXPLORER = "https://explorer.inkonchain.com";
 /**
  * The Ink deployments this server signs against. Pinned here, never taken from hookit.fun's catalog: a compromised
@@ -74,7 +74,12 @@ const PINNED = {
   aggregator: "0x6518b4b2D77F8351F8cE7C9BA1ca7E6D8631D210", // BalancedAggregatorC (USDG in / out on v2 coins)
   loanPlugin: "0xA9e9347175B1d128478D0DdA475dE5a11C33DBB4", // FloorLoanPlugin
   gatedBuyPlugin: "0x4af18ddf7Ccbb0d30DE397B8ebdc873f98BFA9f3", // GatedBuyPlugin
-  evolvePlugin: "0xC78B0195Fa8b3DeECF5f6CCe1F6F2A7902588112", // EvolvePlugin (v2 module 5; creates EvolveExtensions 0x0ef655FEC85BF298a8154c8A2f4DA5CB4Dd4aBcE), tx list c-evolve-57073-58022489
+  // ---- Evolve (spec/v2/plugins/evolve.md): v2 (§10.6, launch plugs and relays) takes every new launch; v1 keeps the
+  // coins launched on it (deprecated in the ModuleRegistry by the last v2 list, c-evolve-v1-deprecate: no new launch,
+  // its coins keep running). Each coin's tools use the plugin that knows it (`evolvePluginOf`). Until v2 has code at
+  // its address, the current Evolve is v1. HOOKIT_EVOLVE_PLUGIN overrides the v2 address.
+  evolvePlugin: "0x9E648Cbb0cf76197056aE5f61fdD9b6b95cdA1c4", // EvolvePlugin v2 (CreateX label hookit.v2.c1:c.EvolvePlugin.v2, list c-evolve-57073-58845088: module 28, EvolveExtensions 0x57c574e2764040cb1e325E591bC3475b3c035D75, relays 0x37292dEBc156Aa3Df8aD5311d1F7b41eA5198e28 / 0x3D855467718c16F106956C740E2e77eD70798D6A as modules 29 / 30); the module id is read from the ModuleRegistry
+  evolvePluginV1: "0xC78B0195Fa8b3DeECF5f6CCe1F6F2A7902588112", // EvolvePlugin v1 (module 5; creates EvolveExtensions 0x0ef655FEC85BF298a8154c8A2f4DA5CB4Dd4aBcE), tx list c-evolve-57073-58022489
   // NftStrategyEvolve f3 (KNOWN-ISSUES R9a, list c-evolve-nft-strategy-f3): Evolve hook id 8, raffle
   // 0x49eF571af836DD777C223Bcf90Fc5A4F8441B074. The first version 0x5C731E518dB36a542DF9907DEb37967a39dAAF0d (id 1) is
   // halted and was never plugged by any coin (no Announced on EvolveExtensions, 0 raffles), so nothing reads it any more.
@@ -104,6 +109,19 @@ const PINNED = {
   velocityEvolveFee2: "0x48C6b65554cB87cB04855426f7955bD355Ba6209", // VelocityEvolveFee rank 2 (asks the 3rd percent)
   agentPass: "0xe847CCD9EcD9889c39B381C83B33e0251759Cf67", // HookitAgentPass
   agentValidator: "0x7A9365784b438D327D468b717dd644fd0fB09fa7", // HookitAgentValidator (ERC-8004)
+  // ---- The Evolve v2 deployments of Memory and Velocity on Evolve (lists c-evolve-memory-57073-58845088, catalog ids
+  // 5-7, and c-velocity-evolve-57073-58845088, ids 0-2, against the v2 catalog): the memory* / velocityEvolve* pins above are v1's and serve the v1 coins. HOOKIT_EVOLVE_V2_MEMORY_EVOLVE,
+  // _MEMORY_LENS, _MEMORY_FEE1, _MEMORY_FEE2, _VELOCITY_EVOLVE, _VELOCITY_EVOLVE_FEE1, _VELOCITY_EVOLVE_FEE2 override them;
+  // nothing is used until code is there and the contracts point at the v2 plugin and catalog.
+  evolveV2: {
+    memoryEvolve: "0x68B0dE60217DC4Ca971eDc23B0c9B4B6D3A710A1",
+    memoryLens: "0xD33EAe11B39c6348e6e803Ee8a43176AeD727924",
+    memoryFee1: "0x22228e62EfEaC31da195257b4D432A0CcC707942",
+    memoryFee2: "0x76eAdF20b3Bf3e7e172A875C866bc4C796BC8828",
+    velocityEvolve: "0x0BdE0e84a8b1Faee372616AE069c1b85D74386CC",
+    velocityEvolveFee1: "0xAea32E49E128eE3472fe4CD962515Ec96f758b1E",
+    velocityEvolveFee2: "0xF73b51849495788773A1433C9980EAC1983F8cF3",
+  },
 };
 /** Tickers payWith / receive accept, besides "eth" and "usdg" (the catalog's list is only a fallback). */
 const KNOWN_ASSETS = {
@@ -937,7 +955,7 @@ async function convertAtUsd(c, from, to, amount) {
   return Number.isFinite(v) && v > 0 ? parseUnits(v.toFixed(to.decimals), to.decimals) : null;
 }
 
-/** Whether hookit.fun's Relay proxy swaps `from` into `to` on Ink: one side must be ETH or USDG. */
+/** Whether a Relay leg may swap `from` into `to` on Ink: one side must be ETH or USDG, as on hookit.fun. */
 function relayable(c, from, to) {
   if (same(from, to)) return false;
   const funding = (a) => same(a, zeroAddress) || same(a, at(c, "usdg"));
@@ -1178,6 +1196,59 @@ function feeOf(receipt) {
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/** Relay's API, asked directly: hookit.fun never shapes the calls this wallet signs. */
+const RELAY_API = (process.env.HOOKIT_RELAY_API_URL || "https://api.relay.link").replace(/\/$/, "");
+const RELAY_API_KEY = process.env.HOOKIT_RELAY_API_KEY?.trim();
+
+/**
+ * An Ink EXACT_INPUT quote for this wallet from Relay's API: { body } with the quote's requestId, amountOut,
+ * minimumAmount, impactPercent and calls (every transaction step's items), or { error, status }.
+ */
+async function relayFetchQuote(from, to, amount, slippageBps) {
+  let res;
+  try {
+    res = await fetch(`${RELAY_API}/quote/v2`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...(RELAY_API_KEY ? { "x-api-key": RELAY_API_KEY } : {}) },
+      body: JSON.stringify({
+        user: account.address,
+        recipient: account.address,
+        originChainId: ink.id,
+        destinationChainId: ink.id,
+        originCurrency: from,
+        destinationCurrency: to,
+        amount: amount.toString(),
+        tradeType: "EXACT_INPUT",
+        slippageTolerance: String(slippageBps),
+      }),
+    });
+  } catch {
+    return { error: "Relay's quote API did not answer. Retry later.", status: 0 };
+  }
+  const payload = await res.json().catch(() => null);
+  if (!res.ok || !payload || payload.errorCode) {
+    return { error: typeof payload?.message === "string" ? payload.message.slice(0, 200) : `Relay answered ${res.status}`, status: res.status };
+  }
+  const steps = Array.isArray(payload.steps) ? payload.steps : [];
+  // A signature step (permit, authorize) cannot be sent as a transaction.
+  if (steps.some((step) => step?.kind != null && step.kind !== "transaction")) return { error: "the route needs a signature", status: 502 };
+  const calls = steps
+    .flatMap((step) => (Array.isArray(step?.items) ? step.items : []))
+    .map((item) => item?.data)
+    .filter((data) => data && typeof data === "object")
+    .map((data) => ({ chainId: Number(data.chainId), to: data.to, data: data.data, value: String(data.value ?? "0") }));
+  const out = payload.details?.currencyOut;
+  return {
+    body: {
+      requestId: payload.requestId ?? "",
+      amountOut: out?.amount,
+      minimumAmount: /^\d+$/.test(out?.minimumAmount ?? "") ? out.minimumAmount : out?.amount,
+      impactPercent: payload.details?.totalImpact?.percent ?? null,
+      calls,
+    },
+  };
+}
+
 /**
  * Relay's contracts on Ink (api.relay.link/chains): a conversion only ever calls one of these, or approves one of them
  * on the token it spends. A quote that asks for anything else is refused before signing.
@@ -1231,37 +1302,19 @@ async function relayFairOut(inMeta, outMeta, amount) {
 }
 
 /**
- * A Relay quote to swap `amount` of `from` into `to` on Ink for this wallet, through hookit.fun's /api/relay/quote
- * (Relay's key stays on that server): { quote: { requestId, out, min, impact, calls } } or { error }.
+ * A Relay quote to swap `amount` of `from` into `to` on Ink for this wallet, from Relay's API:
+ * { quote: { requestId, out, min, impact, calls } } or { error }.
  */
 async function relayQuote(from, to, amount, slippageBps) {
   const [inMeta, outMeta] = await Promise.all([assetMeta(from), assetMeta(to)]);
-  let res;
-  try {
-    res = await fetch(`${API}/api/relay/quote`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        user: account.address,
-        originChainId: ink.id,
-        destinationChainId: ink.id,
-        originCurrency: from,
-        destinationCurrency: to,
-        amount: amount.toString(),
-        slippageBps,
-      }),
-    });
-  } catch {
-    return { error: "hookit.fun's Relay quote did not answer. Retry later." };
-  }
-  const body = await res.json().catch(() => null);
-  if (!res.ok) {
-    const why = body?.error ?? `hookit.fun answered ${res.status}`;
-    if (why === "Unsupported Relay pair") return { error: `Relay does not swap ${inMeta.symbol} into ${outMeta.symbol} through hookit.fun.`, unsupported: true };
-    return { error: `Relay has no ${inMeta.symbol} to ${outMeta.symbol} route right now (${why}).` };
+  const fetched = await relayFetchQuote(from, to, amount, slippageBps);
+  if (fetched.error) {
+    if (fetched.status === 0) return { error: fetched.error };
+    return { error: `Relay has no ${inMeta.symbol} to ${outMeta.symbol} route right now (${fetched.error}).` };
   }
+  const { body } = fetched;
   if (!/^\d+$/.test(body?.amountOut ?? "") || !/^\d+$/.test(body?.minimumAmount ?? "") || !Array.isArray(body?.calls)) {
-    return { error: "hookit.fun's Relay quote came back malformed. Nothing was sent." };
+    return { error: "Relay's quote came back malformed. Nothing was sent." };
   }
   const out = BigInt(body.amountOut);
   if (out <= 0n) return { error: `Relay would return no ${outMeta.symbol}.` };
@@ -1343,24 +1396,28 @@ const ETH_TRACE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 /**
  * Runs the approval and Relay's transactions together in one eth_simulateV1 from this wallet (nothing is sent) and
  * checks what the wallet would send and get: at most `amount` of `from` out, at least `min` of `to` in, nothing else
- * out. Relay contracts run arbitrary calls, so this is what stops a forged quote from paying someone else. null when
- * sound, else why not.
+ * out. Relay contracts run arbitrary calls, so this is what stops a forged quote from paying someone else. The
+ * simulation is validated and priced with `fees`, the fee fields the swap is then signed with, so a called contract
+ * cannot tell it from the real transaction by a zero gas price or base fee. null when sound, else why not.
  */
-async function relaySimulate(from, to, amount, min, plan) {
+async function relaySimulate(from, to, amount, min, plan, fees) {
   const wallet = account.address;
+  const priced = { maxFeePerGas: toHex(fees.maxFeePerGas), maxPriorityFeePerGas: toHex(fees.maxPriorityFeePerGas) };
   const calls = [];
   if (from !== zeroAddress && plan.spender) {
-    calls.push({ from: wallet, to: from, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [plan.spender, amount] }) });
+    calls.push({ from: wallet, to: from, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [plan.spender, amount] }), ...priced });
   }
-  for (const tx of plan.txs) calls.push({ from: wallet, to: tx.to, data: tx.data, value: toHex(tx.value) });
+  for (const tx of plan.txs) calls.push({ from: wallet, to: tx.to, data: tx.data, value: toHex(tx.value), ...priced });
   let result;
   try {
     result = await publicClient.request({
       method: "eth_simulateV1",
-      params: [{ blockStateCalls: [{ calls }], traceTransfers: true, validation: false }, "latest"],
+      params: [{ blockStateCalls: [{ calls }], traceTransfers: true, validation: true }, "latest"],
     });
   } catch (err) {
-    return `this RPC cannot simulate Relay's transactions (eth_simulateV1: ${shortError(err)}). Set HOOKIT_RPC_URL to an Ink RPC that supports it, such as https://rpc-gel.inkonchain.com.`;
+    const why = shortError(err);
+    if (/insufficient funds|nonce|fee cap|gas limit/i.test(why)) return `Relay's swap fails when simulated (${why})`;
+    return `this RPC cannot simulate Relay's transactions (eth_simulateV1: ${why}). Set HOOKIT_RPC_URL to an Ink RPC that supports it, such as https://rpc-gel.inkonchain.com.`;
   }
   const net = new Map();
   const add = (asset, v) => net.set(asset, (net.get(asset) ?? 0n) + v);
@@ -1384,12 +1441,18 @@ async function relaySimulate(from, to, amount, min, plan) {
   return null;
 }
 
-/** The structural and the simulated check of a Relay quote: { plan } or { error } (refused, nothing sent). */
+/**
+ * The structural and the simulated check of a Relay quote: { plan, fees } or { error } (refused, nothing sent). `fees`
+ * are the fee fields the check simulated with; the swap must be signed with them.
+ */
 async function relayCheck(from, to, amount, quote) {
   const plan = relayPlan(quote.calls, from, amount, quote.inMeta.symbol);
   if (plan.error) return plan;
-  const why = await relaySimulate(from, to, amount, quote.min, plan);
-  return why ? { error: `Refused Relay's transactions: ${why}. Nothing was sent.` } : { plan };
+  const estimated = await publicClient.estimateFeesPerGas().catch(() => null);
+  if (!estimated?.maxFeePerGas) return { error: "Could not read Ink's gas price, so Relay's swap cannot be simulated. Nothing was sent." };
+  const fees = { maxFeePerGas: estimated.maxFeePerGas, maxPriorityFeePerGas: estimated.maxPriorityFeePerGas ?? 0n };
+  const why = await relaySimulate(from, to, amount, quote.min, plan, fees);
+  return why ? { error: `Refused Relay's transactions: ${why}. Nothing was sent.` } : { plan, fees };
 }
 
 /** Sets this wallet's allowance of `asset` to `spender` to exactly `amount` (0 revokes). { hash } or { error }. */
@@ -1436,7 +1499,7 @@ async function relayStatus(requestId) {
 async function relayConvert(from, to, amount, quote) {
   const checked = await relayCheck(from, to, amount, quote);
   if (checked.error) return { error: checked.error, txs: [] };
-  const { plan } = checked;
+  const { plan, fees: feeFields } = checked;
   const txs = [];
   const receipts = [];
   const approves = from !== zeroAddress && plan.spender;
@@ -1452,13 +1515,14 @@ async function relayConvert(from, to, amount, quote) {
     for (const tx of plan.txs) {
       let gas;
       try {
-        await publicClient.call({ account, ...tx });
-        const estimated = await publicClient.estimateGas({ account, ...tx });
+        await publicClient.call({ account, ...tx, ...feeFields });
+        const estimated = await publicClient.estimateGas({ account, ...tx, ...feeFields });
         gas = estimated + estimated / 3n;
       } catch (err) {
         return { error: `Relay's swap would fail: ${shortError(err)}`, txs };
       }
-      const hash = await walletClient.sendTransaction({ ...tx, gas: gas > MAX_TX_GAS ? MAX_TX_GAS : gas });
+      // Signed with the fee fields the swap was simulated with.
+      const hash = await walletClient.sendTransaction({ ...tx, ...feeFields, gas: gas > MAX_TX_GAS ? MAX_TX_GAS : gas });
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
       txs.push(hash);
       receipts.push(receipt);
@@ -1749,6 +1813,87 @@ function launchRefusal(prepared) {
   return null;
 }
 
+/** CreatorPayoutRouterC's provider ids (web/src/lib/social-payout.ts). */
+const PAYOUT_PROVIDER = { wallet: 0, github: 1, x: 2, tiktok: 3 };
+
+/** "@Name", "name" or a profile URL → "name", as hookit.fun reads a payout handle; null when not one. */
+function payoutHandle(kind, raw) {
+  if (typeof raw !== "string" || raw.length > 200) return null;
+  const handle = raw
+    .trim()
+    .replace(/^https?:\/\/(www\.)?(github\.com|x\.com|twitter\.com|tiktok\.com)\//i, "")
+    .replace(/^@/, "")
+    .replace(/[/?#].*$/, "");
+  const pattern = { github: /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/, x: /^[A-Za-z0-9_]{1,15}$/, tiktok: /^[A-Za-z0-9_.]{2,24}$/ }[kind];
+  return pattern?.test(handle) ? handle : null;
+}
+
+/** A GitHub account's numeric id from api.github.com (not hookit.fun), so a forged lookup cannot pick the payee. */
+async function githubUserId(handle) {
+  try {
+    const res = await fetch(`https://api.github.com/users/${encodeURIComponent(handle)}`, {
+      headers: { accept: "application/vnd.github+json", "user-agent": "hookit-mcp" },
+    });
+    const body = await res.json().catch(() => null);
+    return res.ok && Number.isSafeInteger(body?.id) && body.id > 0 ? String(body.id) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Who the launch hookit.fun prepared pays the creator fees to, read from its calldata: { kind: "self" } through Factory
+ * C, else the payout router's { provider, accountId, wallet }; null when the router call does not decode.
+ */
+function launchPayoutOf(prepared) {
+  if (same(prepared.tx?.to, PINNED.factory)) return { kind: "self" };
+  try {
+    const [, provider, accountId, wallet] = decodeFunctionData({ abi: payoutRouterLaunchAbi, data: prepared.tx.data }).args;
+    return { kind: "router", provider, accountId, wallet };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Why the launch must not be signed because it pays someone other than `payout` asked, or null. A TikTok handle is
+ * hashed here and a GitHub one looked up before preparing, so only an X handle without accountId takes hookit.fun's
+ * lookup (the result shows the id the calldata pays).
+ */
+function launchPayoutRefusal(prepared, payout) {
+  const got = launchPayoutOf(prepared);
+  const kind = payout?.kind ?? "wallet";
+  const refuse = (who) => `hookit answered with a launch that pays the creator fees to someone else than ${who}. Nothing was sent.`;
+  if (!got) return refuse("asked (its payout router call does not decode)");
+  if (kind === "wallet") {
+    if (!payout?.address || same(payout.address, account?.address)) return got.kind === "self" ? null : refuse("this wallet");
+    const paid = got.kind === "router" && got.provider === PAYOUT_PROVIDER.wallet && got.accountId === 0n;
+    return paid && same(got.wallet, payout.address) ? null : refuse(payout.address);
+  }
+  const who = payout.handle ? `@${payout.handle} on ${kind}` : `${kind} account ${payout.accountId}`;
+  if (got.kind !== "router" || got.provider !== PAYOUT_PROVIDER[kind] || !same(got.wallet, zeroAddress)) return refuse(who);
+  let expected = null;
+  try {
+    if (payout.accountId) expected = BigInt(payout.accountId);
+    else if (kind === "tiktok") {
+      const handle = payoutHandle("tiktok", payout.handle);
+      expected = handle ? BigInt(keccak256(toHex(`tiktok:${handle.toLowerCase()}`))) : null;
+    }
+  } catch {
+    return refuse(who);
+  }
+  if (expected !== null) return got.accountId === expected ? null : refuse(who);
+  return kind === "x" && got.accountId > 0n ? null : refuse(who);
+}
+
+/** The creator-fee payee as the signed calldata has it (never hookit.fun's plan). */
+function launchPayoutView(prepared) {
+  const got = launchPayoutOf(prepared);
+  if (!got || got.kind === "self") return { to: "this wallet" };
+  const kind = Object.keys(PAYOUT_PROVIDER).find((k) => PAYOUT_PROVIDER[k] === got.provider) ?? `provider ${got.provider}`;
+  return kind === "wallet" ? { kind, address: got.wallet } : { kind, accountId: got.accountId.toString() };
+}
+
 /**
  * Runs the tools that sign one at a time: an agent may call several at once, and two of them sharing the wallet's
  * nonce or its balance deltas could spend what the other one just received.
@@ -2157,9 +2302,20 @@ server.registerTool(
     } else {
       delete args.builderHooks;
     }
+    // Who is paid is checked in the calldata hookit.fun prepares; a GitHub handle is pinned to its id here first.
+    if (args.payout?.kind === "github" && !args.payout.accountId) {
+      const handle = payoutHandle("github", args.payout.handle);
+      const id = handle ? await githubUserId(handle) : null;
+      if (!id) return fail("Could not look up that GitHub handle on api.github.com. Pass payout.accountId (the account's numeric id) instead.");
+      args.payout = { ...args.payout, accountId: id };
+    }
+    // The current Evolve's module id (v2 once it has code, else v1), read from the ModuleRegistry by plugin address.
+    const evolveModuleId = args.evolve ? await currentEvolveModuleId() : null;
+    if (args.evolve && evolveModuleId === null) return fail("Evolve is not registered in the ModuleRegistry (or is deprecated or halted): launch without evolve.");
     const refusalOf = (prepared) =>
       launchRefusal(prepared) ??
-      (args.evolve ? evolveLaunchRefusal(prepared, args) : null) ??
+      launchPayoutRefusal(prepared, args.payout) ??
+      (args.evolve ? evolveLaunchRefusal(prepared, args, evolveModuleId) : null) ??
       (velocity ? velocityLaunchRefusal(prepared, velocity.asked, velocity.ids) : null) ??
       (builder ? builderHooksLaunchRefusal(prepared, builder.expected, builder.entries) : null) ??
       (!args.evolve && !velocity && !builder ? unaskedSlotsRefusal(prepared) : null);
@@ -2188,6 +2344,7 @@ server.registerTool(
             ? `The launch would fail: ${launchSimulationError(prepared.simulation.error)}`
             : "The launch is valid.",
         plan: prepared.plan,
+        payout: launchPayoutView(prepared),
         ...(args.evolve ? { evolve: evolveLaunchView(prepared) } : {}),
         ...(velocity ? { velocity: velocityLaunchView(prepared) } : {}),
         ...(builder ? { builderHooks: builderHooksLaunchView(prepared, builder.expected, builder.entries) } : {}),
@@ -2225,7 +2382,7 @@ server.registerTool(
       page: token ? `${API}/token/${token}` : null,
       tx: `https://explorer.inkonchain.com/tx/${hash}`,
       settings: prepared.plan.settings,
-      payout: prepared.plan.payout,
+      payout: launchPayoutView(prepared),
       payoutAgent: agent,
       note: agent
         ? "Creator fees go to the payout target through this launch's CreatorPayoutAgent. This wallet is its controller."
@@ -2580,7 +2737,7 @@ server.registerTool(
       let firstError = null;
       // Land where the coin is cheapest: the markets of one coin can be priced far apart.
       const landings = (await landingAssets(c, coin, asset)).filter((a) => relayable(c, asset, a.address));
-      if (!landings.length) firstError = `Relay does not swap ${pay.symbol} into what this coin trades in through hookit.fun (one side must be ETH or USDG).`;
+      if (!landings.length) firstError = `Relay does not swap ${pay.symbol} into what this coin trades in (one side must be ETH or USDG).`;
       for (const landing of (await rankBuyLandings(c, coin, pay, value, landings)).slice(0, 3)) {
         const q = await relayQuote(asset, landing.address, value, relayBps);
         const checked = q.quote ? await relayCheck(asset, landing.address, value, q.quote) : q;
@@ -2797,7 +2954,7 @@ server.registerTool(
           );
         }
         const assets = await tradeAssets(c, coin);
-        const none = landings.length ? "Relay cannot swap what this coin trades in." : `Relay does not swap what this coin trades in into ${out.symbol} through hookit.fun (one side must be ETH or USDG).`;
+        const none = landings.length ? "Relay cannot swap what this coin trades in." : `Relay does not swap what this coin trades in into ${out.symbol} (one side must be ETH or USDG).`;
         return fail(`${relayError ?? firstError ?? none} This coin trades in ${assets.join(", ")}: receive ${assets.length > 1 ? "one of those" : "that"} instead.`);
       }
       const capped = await relayCapRefusal(c, leg, route.out);
@@ -3388,7 +3545,10 @@ const EVOLVE_PARAMS = parseAbiParameters(
 );
 
 /** Evolve's id in ModuleRegistry (v2 module 5, as its tx list records it). */
+/** Evolve v1's ModuleRegistry id (deprecated by the v2 deployment); a launch is checked against the current Evolve's id. */
 const EVOLVE_MODULE_ID = 5;
+/** `abi.encode(EvolvePlugin.Params)`: 9 static words. hookit-mcp never plugs hooks at launch (Evolve v2's packed plugs). */
+const EVOLVE_PARAMS_BYTES = 288;
 /** hookit.fun's defaults for what launch_token's evolve leaves out (web/src/lib/evolve-params.ts): cap 3 %, fee 1 %. */
 const EVOLVE_DEFAULT_MAX_FEE_BPS = 300;
 const EVOLVE_DEFAULT_FEE_BPS = 100;
@@ -3420,7 +3580,8 @@ function evolveLaunchDecoded(prepared) {
     if (cfg.plugins.length !== 1) return { slots: cfg.plugins.length };
     const slot = cfg.plugins[0];
     const [params] = decodeAbiParameters(EVOLVE_PARAMS, slot.initData);
-    return { slots: 1, moduleId: Number(slot.moduleId), potBps: Number(slot.potBps), params };
+    const initBytes = (String(slot.initData).length - 2) / 2;
+    return { slots: 1, moduleId: Number(slot.moduleId), potBps: Number(slot.potBps), params, initBytes };
   } catch {
     return null;
   }
@@ -3434,14 +3595,19 @@ function evolveLaunchDecoded(prepared) {
  * the pot when no preset but clean and no `modules` key routes the pot elsewhere, else Factory C's rule that every
  * route totals 100 %).
  */
-function evolveLaunchRefusal(prepared, args = {}) {
+function evolveLaunchRefusal(prepared, args = {}, evolveModuleId = EVOLVE_MODULE_ID) {
   const nothing = " Nothing was sent; update hookit-mcp or launch without evolve.";
   const d = evolveLaunchDecoded(prepared);
   if (!d || d.slots !== 1 || !same(d.params.decider, account.address)) {
     return `hookit answered with an Evolve launch whose decider is not this wallet (or with another plugin slot than Evolve's).${nothing}`;
   }
-  if (d.moduleId !== EVOLVE_MODULE_ID) {
-    return `hookit answered with a launch whose plugin slot is module ${d.moduleId}, not Evolve (module ${EVOLVE_MODULE_ID}).${nothing}`;
+  if (d.moduleId !== evolveModuleId) {
+    return `hookit answered with a launch whose plugin slot is module ${d.moduleId}, not Evolve (module ${evolveModuleId}).${nothing}`;
+  }
+  // Audit L-1: bytes after the Params are hooks plugged at launch (Evolve v2), which this server never asks for, and
+  // which Evolve v1 would ignore silently.
+  if (d.initBytes !== EVOLVE_PARAMS_BYTES) {
+    return `hookit answered with ${d.initBytes} bytes of Evolve launch data, not the ${EVOLVE_PARAMS_BYTES} bytes of its settings: hookit-mcp never plugs hooks at launch.${nothing}`;
   }
   const asked = args.evolve && typeof args.evolve === "object" ? args.evolve : {};
   const bps = (v) => (v === undefined || v === null ? undefined : Math.round(Number(v) * 100));
@@ -3526,9 +3692,108 @@ function evolveReason(raw) {
   return t;
 }
 
+/** An Evolve pin as an address, or null when it is unset, a placeholder, zero or not an address. */
+function pinnedAddress(a) {
+  return typeof a === "string" && isAddress(a) && BigInt(a) !== 0n ? getAddress(a) : null;
+}
+
+/** HOOKIT_EVOLVE_PLUGIN (v2) and HOOKIT_EVOLVE_V2_*: override the Evolve v2 pins; not an address: off. */
+{
+  const raw = process.env.HOOKIT_EVOLVE_PLUGIN?.trim();
+  if (raw) PINNED.evolvePlugin = isAddress(raw) ? getAddress(raw) : null;
+  for (const [name, env] of [
+    ["memoryEvolve", "HOOKIT_EVOLVE_V2_MEMORY_EVOLVE"],
+    ["memoryLens", "HOOKIT_EVOLVE_V2_MEMORY_LENS"],
+    ["memoryFee1", "HOOKIT_EVOLVE_V2_MEMORY_FEE1"],
+    ["memoryFee2", "HOOKIT_EVOLVE_V2_MEMORY_FEE2"],
+    ["velocityEvolve", "HOOKIT_EVOLVE_V2_VELOCITY_EVOLVE"],
+    ["velocityEvolveFee1", "HOOKIT_EVOLVE_V2_VELOCITY_EVOLVE_FEE1"],
+    ["velocityEvolveFee2", "HOOKIT_EVOLVE_V2_VELOCITY_EVOLVE_FEE2"],
+  ]) {
+    const v = process.env[env]?.trim();
+    if (v) PINNED.evolveV2[name] = isAddress(v) ? getAddress(v) : null;
+  }
+}
+
+const evolveCodeCache = new Map();
+async function evolveHasCode(a) {
+  if (!a) return false;
+  if (evolveCodeCache.get(a)) return true;
+  const code = await publicClient.getCode({ address: a }).catch(() => undefined);
+  const has = !!code && code !== "0x";
+  if (has) evolveCodeCache.set(a, true);
+  return has;
+}
+
+/** Every Evolve plugin version, current (v2) first, then v1. */
+function evolvePlugins() {
+  return [pinnedAddress(PINNED.evolvePlugin), pinnedAddress(PINNED.evolvePluginV1)].filter(Boolean);
+}
+
+/** The Evolve new launches go to: v2 once it has code at its address, else v1 (null: none). */
+async function currentEvolvePlugin() {
+  for (const p of evolvePlugins()) if (await evolveHasCode(p)) return p;
+  return null;
+}
+
+/** The current Evolve's ModuleRegistry id, found by scanning the registry for its address (live entries only), or null. */
+async function currentEvolveModuleId() {
+  const plugin = await currentEvolvePlugin();
+  const registry = pinnedAddress(PINNED.moduleRegistry);
+  if (!plugin || !registry) return null;
+  try {
+    const n = Number(await read(registry, moduleRegistryAbi, "moduleCount"));
+    for (let id = n; id >= 1; id--) {
+      const e = await read(registry, moduleRegistryAbi, "moduleEntry", [id]);
+      if (same(e.plugin, plugin)) return e.deprecated || e.halted ? null : id;
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+const evolvePluginOfCache = new Map();
+/**
+ * The Evolve plugin a coin runs on: the first version (v2, then v1) whose `extensionContext(token)` names a decider;
+ * null for a coin no Evolve knows (or not an address). A coin's plugin never changes, so a hit is cached.
+ */
+async function evolvePluginOf(token) {
+  if (typeof token !== "string" || !isAddress(token)) return null;
+  const key = token.toLowerCase();
+  if (evolvePluginOfCache.has(key)) return evolvePluginOfCache.get(key);
+  for (const p of evolvePlugins()) {
+    if (!(await evolveHasCode(p))) continue;
+    const ctx = await read(p, evolveAbi, "extensionContext", [getAddress(token)]).catch(() => null);
+    if (ctx && !same(ctx[0], zeroAddress)) {
+      evolvePluginOfCache.set(key, p);
+      return p;
+    }
+  }
+  return null;
+}
+
+/** The coin's plugin, else the current one (whose reads then answer "This coin does not run Evolve."). */
+async function evolvePluginFor(token) {
+  return (await evolvePluginOf(token)) ?? (await currentEvolvePlugin()) ?? pinnedAddress(PINNED.evolvePluginV1);
+}
+
+/** Whether `a` is the `key` contract (memoryEvolve, velocityEvolveFee1…) of either Evolve version. */
+function isEvolvePin(a, key) {
+  return [PINNED[key], PINNED.evolveV2[key]].some((p) => {
+    const pin = pinnedAddress(p);
+    return !!pin && same(a, pin);
+  });
+}
+
+/** The Memory / Velocity contracts of an Evolve version: v1's pins for v1, the evolveV2 pins for v2. */
+function evolveExtensionPins(plugin) {
+  return same(plugin, PINNED.evolvePluginV1) ? PINNED : PINNED.evolveV2;
+}
+
 /** The coin's Evolve state as a swap sees it now (a due setting counted as applied), or { error }. */
 async function evolveCoin(token) {
-  const plugin = PINNED.evolvePlugin;
+  const plugin = await evolvePluginFor(token);
   if (!plugin) return { error: "Evolve is not live in this hookit-mcp release yet." };
   let st;
   try {
@@ -3892,7 +4157,7 @@ server.registerTool(
     annotations: { readOnlyHint: true },
   },
   async () => {
-    const plugin = PINNED.evolvePlugin;
+    const plugin = await currentEvolvePlugin();
     if (!plugin) return fail("Evolve is not live in this hookit-mcp release yet.");
     const { ext, entries, truncated } = await evolveCatalog(plugin);
     return reply({
@@ -3980,14 +4245,14 @@ function nftStrategyConfigView(cfg) {
 /** A hook's config as the decider sends it, decoded for the hooks this release knows (NFT Strategy, Memory, Boss Raid). */
 async function evolveConfigView(x, cfg, quote) {
   if (same(x.ext, PINNED.evolveNftStrategy)) return { hook: "NFT Strategy", ...nftStrategyConfigView(cfg) };
-  if (same(x.ext, PINNED.memoryEvolve)) {
+  if (isEvolvePin(x.ext, "memoryEvolve")) {
     return { hook: "Memory", ...memoryConfigView(cfg, await assetMeta(getAddress(quote)).catch(() => null)) };
   }
-  if (same(x.ext, PINNED.memoryFee1) || same(x.ext, PINNED.memoryFee2)) {
+  if (isEvolvePin(x.ext, "memoryFee1") || isEvolvePin(x.ext, "memoryFee2")) {
     return { hook: "Memory fee companion", ...(cfg === "0x" ? { config: "empty, as it must be" } : { raw: cfg, invalid: "a companion takes no config (0x)" }) };
   }
-  if (same(x.ext, velocityAddress(PINNED.velocityEvolve))) return { hook: "Velocity", ...velocityConfigView(cfg) };
-  if (same(x.ext, velocityAddress(PINNED.velocityEvolveFee1)) || same(x.ext, velocityAddress(PINNED.velocityEvolveFee2))) {
+  if (isEvolvePin(x.ext, "velocityEvolve")) return { hook: "Velocity", ...velocityConfigView(cfg) };
+  if (isEvolvePin(x.ext, "velocityEvolveFee1") || isEvolvePin(x.ext, "velocityEvolveFee2")) {
     return { hook: "Velocity fee companion", ...(cfg === "0x" ? { config: "empty, as it must be" } : { raw: cfg, invalid: "a companion takes no config (0x)" }) };
   }
   if (bytes32Text(x.name) === "Boss Raid") {
@@ -4020,7 +4285,7 @@ server.registerTool(
     if (!account) return needKey();
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
-    const plugin = PINNED.evolvePlugin;
+    const plugin = await evolvePluginFor(token);
     if (!plugin) return fail("Evolve is not live in this hookit-mcp release yet.");
     const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
@@ -4071,7 +4336,7 @@ server.registerTool(
             return fail(`Hook ${hookId} is already in slot ${j + 1}: one slot per hook.`);
           }
         }
-        if (same(x.ext, PINNED.memoryEvolve)) {
+        if (isEvolvePin(x.ext, "memoryEvolve")) {
           // Memory's onAnnounce refuses a decider that is not an AI agent and a setup out of its bounds: say it first.
           if ((await read(x.ext, memoryAbi, "isAgent", [decider]).catch(() => null)) === false) return fail(memoryNotAgent(decider));
           const d = decodeMemorySetup(cfg);
@@ -4079,18 +4344,18 @@ server.registerTool(
           if (refused) return fail(`Memory would refuse this config. ${refused} memory_set builds it from plain settings.`);
           announceAbi = memoryAnnounceAbi;
           hookFailure = memoryFailure;
-        } else if (same(x.ext, PINNED.memoryFee1) || same(x.ext, PINNED.memoryFee2)) {
+        } else if (isEvolvePin(x.ext, "memoryFee1") || isEvolvePin(x.ext, "memoryFee2")) {
           if (cfg !== "0x") return fail("A Memory fee companion takes no config (0x).");
           announceAbi = memoryAnnounceAbi;
           hookFailure = memoryFailure;
-        } else if (same(x.ext, velocityAddress(PINNED.velocityEvolve))) {
+        } else if (isEvolvePin(x.ext, "velocityEvolve")) {
           // Velocity's onAnnounce refuses a setup out of its bounds and a cashback without a share (or a share without one).
           const d = decodeVelocitySetup(cfg);
           const refused = d.error ?? velocitySetupRefusal(d.setup, shareBps);
           if (refused) return fail(`Velocity would refuse this config. ${refused} velocity_set builds it from a preset and plugs its fee companions.`);
           announceAbi = velocityAnnounceAbi;
           hookFailure = velocityFailure;
-        } else if (same(x.ext, velocityAddress(PINNED.velocityEvolveFee1)) || same(x.ext, velocityAddress(PINNED.velocityEvolveFee2))) {
+        } else if (isEvolvePin(x.ext, "velocityEvolveFee1") || isEvolvePin(x.ext, "velocityEvolveFee2")) {
           if (cfg !== "0x") return fail("A Velocity fee companion takes no config (0x).");
           announceAbi = velocityAnnounceAbi;
           hookFailure = velocityFailure;
@@ -4110,12 +4375,13 @@ server.registerTool(
     // Memory leaving a slot (or its announced plug-in dropped): its companions ask while Memory runs the plug-in they
     // follow, which Memory keeps running after it leaves (until another of its plug-ins trades) unless it is retired.
     let memoryNote = null;
-    const memoryExt = PINNED.memoryEvolve;
+    const pins = evolveExtensionPins(plugin);
+    const memoryExt = pinnedAddress(pins.memoryEvolve);
     const leavingKey = !memoryExt ? null : cancel ? (announced && same(p.ext, memoryExt) ? p.key : null) : same(l.ext, memoryExt) ? l.key : null;
     const companionSlots =
       leavingKey === null
         ? []
-        : [PINNED.memoryFee1, PINNED.memoryFee2].flatMap((f) => {
+        : [pinnedAddress(pins.memoryFee1), pinnedAddress(pins.memoryFee2)].flatMap((f) => {
             const at = f ? memoryCompanionAt(h, f) : null;
             return at && at.index !== i ? [at.index + 1] : [];
           });
@@ -4133,11 +4399,11 @@ server.registerTool(
       }
     }
     // Velocity leaving a slot: its companions keep asking a (fading) malus from its last mean until they are unplugged too.
-    const velocityExt = velocityAddress(PINNED.velocityEvolve);
+    const velocityExt = velocityAddress(pins.velocityEvolve);
     const velocityLeaving = !!velocityExt && !cancel && same(l.ext, velocityExt) && !same(h.entries[hookId]?.ext, velocityExt);
     const velocityCompanionSlots = !velocityLeaving
       ? []
-      : [PINNED.velocityEvolveFee1, PINNED.velocityEvolveFee2].flatMap((f) => {
+      : [pins.velocityEvolveFee1, pins.velocityEvolveFee2].flatMap((f) => {
           const a = velocityAddress(f);
           const at = a ? memoryCompanionAt(h, a) : null;
           return at?.live && at.index !== i && !at.leaving ? [at.index + 1] : [];
@@ -4232,6 +4498,8 @@ const NFT_EVOLVE_COLLECTIONS_MAX = 64;
 const NFT_EVOLVE_CHALLENGE_SEC = 900;
 
 const NFT_EVOLVE_OFF = "NFT Strategy on Evolve is not live in this hookit-mcp release yet.";
+const NFT_EVOLVE_V2 =
+  "This coin runs Evolve v2, whose hooks do not list NFT Strategy yet (it comes back as NFT Strategy v3 after its review). evolve_hooks lists what it can plug.";
 
 /** NFT Strategy's catalog entry ({ id, entry }) in EvolveExtensions' hook list, found by its pinned address, or null. */
 function nftEvolveEntry(entries) {
@@ -4325,9 +4593,11 @@ server.registerTool(
   },
   async ({ token }) => {
     const nft = PINNED.evolveNftStrategy;
-    const plugin = PINNED.evolvePlugin;
+    // NFT Strategy (f3) is listed on Evolve v1's catalog only; v2 gets NFT Strategy v3 after its audit.
+    const plugin = pinnedAddress(PINNED.evolvePluginV1);
     if (!nft || !plugin) return fail(NFT_EVOLVE_OFF);
     if (token !== undefined && !isAddress(token)) return fail(`Not an address: ${token}`);
+    if (token !== undefined && (await evolvePluginOf(token)) && !same(await evolvePluginOf(token), plugin)) return fail(NFT_EVOLVE_V2);
     const [sweeper, raffle, floatNfts, catalog] = await Promise.all([
       read(nft, nftEvolveAbi, "SWEEPER"),
       read(nft, nftEvolveAbi, "RAFFLE"),
@@ -4434,10 +4704,11 @@ server.registerTool(
   serialized(async ({ token, collection, outcome, sharePct, slot, unplug, cancel, dryRun }) => {
     if (!account) return needKey();
     const nft = PINNED.evolveNftStrategy;
-    const plugin = PINNED.evolvePlugin;
+    const plugin = pinnedAddress(PINNED.evolvePluginV1);
     if (!nft || !plugin) return fail(NFT_EVOLVE_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
+    if ((await evolvePluginOf(token)) && !same(await evolvePluginOf(token), plugin)) return fail(NFT_EVOLVE_V2);
     const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const [decider, delay, quote] = ctx;
@@ -5352,17 +5623,21 @@ function memoryGrudge(word, now) {
   return mark === 2 ? { until, rule: Number((b >> 168n) & 0xffn), tag: (b >> 176n) & 0xffffffffn } : null;
 }
 
-let memoryCache = null;
+/** Memory's contracts per Evolve plugin (v1's pins for v1 coins, the evolveV2 pins for v2 coins). */
+const memoryCache = new Map();
 /**
  * Memory's contracts once their code is there and they belong together (the lens reads this Memory, Memory runs on
  * Evolve's EvolveExtensions, each companion follows this Memory with its rank): { memory, lens, rules, fees: [{ rank,
  * ext }] }, or null. A companion that is not configured, has no code or is not this Memory's is left out: the fee then
  * stops below its percent.
  */
-async function memoryContracts() {
-  if (memoryCache) return memoryCache;
-  const { memoryEvolve: memory, memoryLens: lens, evolvePlugin } = PINNED;
-  if (!memory || !lens || !evolvePlugin) return null;
+async function memoryContracts(evolvePlugin = PINNED.evolvePluginV1) {
+  if (!evolvePlugin) return null;
+  if (memoryCache.has(evolvePlugin)) return memoryCache.get(evolvePlugin);
+  const pins = evolveExtensionPins(evolvePlugin);
+  const memory = pinnedAddress(pins.memoryEvolve);
+  const lens = pinnedAddress(pins.memoryLens);
+  if (!memory || !lens) return null;
   const hasCode = async (a) => {
     const code = await publicClient.getCode({ address: a }).catch(() => undefined);
     return !!code && code !== "0x";
@@ -5377,16 +5652,18 @@ async function memoryContracts() {
     ]);
     if (!same(lensOf, memory) || !same(ext, extensions)) return null;
     const fees = [];
-    for (const [rank, a] of [
-      [1, PINNED.memoryFee1],
-      [2, PINNED.memoryFee2],
+    for (const [rank, raw] of [
+      [1, pins.memoryFee1],
+      [2, pins.memoryFee2],
     ]) {
+      const a = pinnedAddress(raw);
       if (!a || !(await hasCode(a))) continue;
       const [m, r] = await Promise.all([read(a, memoryFeeAbi, "MEMORY").catch(() => null), read(a, memoryFeeAbi, "RANK").catch(() => null)]);
       if (same(m, memory) && Number(r) === rank) fees.push({ rank, ext: getAddress(a) });
     }
-    memoryCache = { memory: getAddress(memory), lens: getAddress(lens), rules: getAddress(rules), fees };
-    return memoryCache;
+    const found = { memory: getAddress(memory), lens: getAddress(lens), rules: getAddress(rules), fees };
+    memoryCache.set(evolvePlugin, found);
+    return found;
   } catch {
     return null;
   }
@@ -5498,11 +5775,11 @@ server.registerTool(
     annotations: { readOnlyHint: true },
   },
   async ({ token }) => {
-    const c = await memoryContracts();
+    const c = await memoryContracts(await evolvePluginFor(token));
     if (!c) return fail(MEMORY_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
-    const plugin = PINNED.evolvePlugin;
+    const plugin = await evolvePluginFor(token);
     const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const [decider, delay, quoteAddress] = ctx;
@@ -5671,11 +5948,11 @@ server.registerTool(
   },
   serialized(async ({ token, rules, allies, feeCapPct, botTrades, reason, sharePct, slot, cancel, dryRun }) => {
     if (!account) return needKey();
-    const c = await memoryContracts();
+    const c = await memoryContracts(await evolvePluginFor(token));
     if (!c) return fail(MEMORY_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
-    const plugin = PINNED.evolvePlugin;
+    const plugin = await evolvePluginFor(token);
     const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const [decider, delay, quoteAddress] = ctx;
@@ -5926,14 +6203,14 @@ server.registerTool(
     annotations: { readOnlyHint: true },
   },
   async ({ token, wallet }) => {
-    const c = await memoryContracts();
+    const c = await memoryContracts(await evolvePluginFor(token));
     if (!c) return fail(MEMORY_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     if (wallet === undefined && !account) return fail("Give wallet (no key is set, so there is no default wallet).");
     if (wallet !== undefined && !isAddress(wallet)) return fail(`Not an address: ${wallet}`);
     token = getAddress(token);
     wallet = getAddress(wallet ?? account.address);
-    const ctx = await read(PINNED.evolvePlugin, evolveAbi, "extensionContext", [token]).catch(() => null);
+    const ctx = await read(await evolvePluginFor(token), evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const [coin, wo, quote, coinMeta, block, balance] = await Promise.all([
       read(c.memory, memoryAbi, "coinOf", [token]),
@@ -6032,7 +6309,7 @@ server.registerTool(
   },
   serialized(async ({ token, wallets, dryRun }) => {
     if (!account) return needKey();
-    const c = await memoryContracts();
+    const c = await memoryContracts(await evolvePluginFor(token));
     if (!c) return fail(MEMORY_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
@@ -6040,7 +6317,7 @@ server.registerTool(
     if (bad !== undefined) return fail(`Not an address: ${bad}`);
     const list = [...new Map(wallets.map((x) => [x.toLowerCase(), getAddress(x)])).values()];
     if (list.length > MEMORY_LIMITS.pardons) return fail(`At most ${MEMORY_LIMITS.pardons} wallets per pardon.`);
-    const plugin = PINNED.evolvePlugin;
+    const plugin = await evolvePluginFor(token);
     const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     if (!same(ctx[0], account.address)) return fail(`This wallet does not decide this coin: ${getAddress(ctx[0])} does (the wallet that launched it).`);
@@ -7067,18 +7344,21 @@ async function velocityLaunchCheck(args) {
   return { asked: a.asked, ids };
 }
 
-let velocityEvolveCache = null;
+/** Velocity on Evolve's contracts per Evolve plugin (v1's pins for v1 coins, the evolveV2 pins for v2 coins). */
+const velocityEvolveCache = new Map();
 /**
  * Velocity on Evolve once its code is there and it belongs together (Velocity runs on Evolve's EvolveExtensions, each
  * companion follows this Velocity with its rank): { velocity, ext, poolManager, fees: [{ rank, ext }] }, or null. A
  * companion that is not configured, has no code or is not this Velocity's is left out: the malus then stops below its
  * percent.
  */
-async function velocityEvolveContracts() {
-  if (velocityEvolveCache) return velocityEvolveCache;
-  const velocity = velocityAddress(PINNED.velocityEvolve);
-  const evolvePlugin = PINNED.evolvePlugin;
-  if (!velocity || !evolvePlugin) return null;
+async function velocityEvolveContracts(evolvePlugin = PINNED.evolvePluginV1) {
+  if (!evolvePlugin) return null;
+  if (velocityEvolveCache.has(evolvePlugin)) return velocityEvolveCache.get(evolvePlugin);
+  // v1's pins for a v1 coin, the evolveV2 pins for a v2 coin (`evolveExtensionPins`).
+  const pins = same(evolvePlugin, PINNED.evolvePluginV1) ? PINNED : PINNED.evolveV2;
+  const velocity = velocityAddress(pins.velocityEvolve);
+  if (!velocity) return null;
   const hasCode = async (a) => {
     const code = await publicClient.getCode({ address: a }).catch(() => undefined);
     return !!code && code !== "0x";
@@ -7094,8 +7374,8 @@ async function velocityEvolveContracts() {
     if (!same(ext, extensions) || !same(evolve, evolvePlugin)) return null;
     const fees = [];
     for (const [rank, raw] of [
-      [1, PINNED.velocityEvolveFee1],
-      [2, PINNED.velocityEvolveFee2],
+      [1, pins.velocityEvolveFee1],
+      [2, pins.velocityEvolveFee2],
     ]) {
       const a = velocityAddress(raw);
       if (!a || !(await hasCode(a))) continue;
@@ -7106,8 +7386,9 @@ async function velocityEvolveContracts() {
       ]);
       if (same(v, velocity) && Number(r) === rank && same(x, ext)) fees.push({ rank, ext: a });
     }
-    velocityEvolveCache = { velocity, ext: getAddress(ext), poolManager: getAddress(poolManager), fees };
-    return velocityEvolveCache;
+    const found = { velocity, ext: getAddress(ext), poolManager: getAddress(poolManager), fees };
+    velocityEvolveCache.set(evolvePlugin, found);
+    return found;
   } catch {
     return null;
   }
@@ -7348,7 +7629,7 @@ function velocityFailure(err) {
 
 /** The coin's Evolve context, its slots and Velocity's catalog ids, for velocity_set and velocity_status: { … } or { error }. */
 async function velocityCoin(c, token) {
-  const plugin = PINNED.evolvePlugin;
+  const plugin = await evolvePluginFor(token);
   const ctx = await read(plugin, evolveAbi, "extensionContext", [token]).catch(() => null);
   if (!ctx) return { error: "This coin does not run Evolve. Velocity on Evolve is for Evolve coins; a coin without Evolve gets Velocity Fee at launch (launch_token velocity)." };
   const [decider, delay, quoteAddress] = ctx;
@@ -7389,7 +7670,7 @@ server.registerTool(
   },
   serialized(async ({ token, preset, malusPct, cashback, cashbackPct, sharePct, slot, unplug, cancel, dryRun }) => {
     if (!account) return needKey();
-    const c = await velocityEvolveContracts();
+    const c = await velocityEvolveContracts(await evolvePluginFor(token));
     if (!c) return fail(VELOCITY_EVOLVE_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     token = getAddress(token);
@@ -7539,7 +7820,7 @@ server.registerTool(
     annotations: { readOnlyHint: true },
   },
   async ({ token, sellAmount, sellCoins }) => {
-    const c = await velocityEvolveContracts();
+    const c = await velocityEvolveContracts(await evolvePluginFor(token));
     if (!c) return fail(VELOCITY_EVOLVE_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     if (sellAmount !== undefined && sellCoins !== undefined) return fail("Give sellAmount or sellCoins, not both.");
@@ -7700,14 +7981,14 @@ server.registerTool(
     annotations: { readOnlyHint: true },
   },
   async ({ token, wallet }) => {
-    const c = await velocityEvolveContracts();
+    const c = await velocityEvolveContracts(await evolvePluginFor(token));
     if (!c) return fail(VELOCITY_EVOLVE_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     if (wallet === undefined && !account) return needKey();
     if (wallet !== undefined && !isAddress(wallet)) return fail(`Not an address: ${wallet}`);
     token = getAddress(token);
     const who = getAddress(wallet ?? account.address);
-    const ctx = await read(PINNED.evolvePlugin, evolveAbi, "extensionContext", [token]).catch(() => null);
+    const ctx = await read(await evolvePluginFor(token), evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const quote = await assetMeta(getAddress(ctx[2]));
     const owed = await read(c.velocity, velocityEvolveAbi, "cashbackOf", [token, who]);
@@ -7736,13 +8017,13 @@ server.registerTool(
   },
   serialized(async ({ token, to, dryRun }) => {
     if (!account) return needKey();
-    const c = await velocityEvolveContracts();
+    const c = await velocityEvolveContracts(await evolvePluginFor(token));
     if (!c) return fail(VELOCITY_EVOLVE_OFF);
     if (!isAddress(token)) return fail(`Not an address: ${token}`);
     if (to !== undefined && !isAddress(to)) return fail(`Not an address: ${to}`);
     token = getAddress(token);
     const recipient = getAddress(to ?? account.address);
-    const ctx = await read(PINNED.evolvePlugin, evolveAbi, "extensionContext", [token]).catch(() => null);
+    const ctx = await read(await evolvePluginFor(token), evolveAbi, "extensionContext", [token]).catch(() => null);
     if (!ctx) return fail("This coin does not run Evolve.");
     const quote = await assetMeta(getAddress(ctx[2]));
     const owed = await read(c.velocity, velocityEvolveAbi, "cashbackOf", [token, account.address]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookit-mcp",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Let an AI agent launch a coin on hookit.fun (Ink) with its own hook modules and builders' Workshop hooks, find, buy and sell coins with ETH, USDG or tokenized stocks (AI-agents-only ones too, with a Hookit Agent Pass), redeem or borrow at their Backed Floor, collect its creator fees, steer the fee split, the fee and the hooks of the Evolve coins it launched, and deploy and submit its own hook to the Workshop.",
   "type": "module",
   "bin": { "hookit-mcp": "index.js" },