@cloakely/mcp 0.6.0 → 0.7.0

package/dist/server.d.ts

@@ -3,7 +3,7 @@ import { type Prover } from "@cloakely/sdk";
 import type { Settings } from "./config.js";
 export { loadSettings, type Settings, type Limits } from "./config.js";
 export { Spending } from "./limits.js";
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.7.0";
 export declare const HOSTED_URL = "https://cloak.boblabs.tech/mcp";
 /** Turn an SDK or chain error into one plain sentence an agent can act on. */
 export declare function explain(e: unknown): string;

package/dist/server.js

@@ -4,11 +4,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { createPublicClient, createWalletClient, erc20Abi, formatEther, formatUnits, http, isAddress, parseEther, parseUnits, zeroAddress, } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { Cloak, CloakPrivate, cloakAuctionAbi, cloakPairAbi, cloakVaultsAbi, legacyFactories, createProver, loadProver, privateRouterAbi, relayerSubmitter, shieldedPoolAbi, } from "@cloakely/sdk";
+import { Cloak, CloakPrivate, cloakAuctionAbi, cloakPairAbi, cloakVaultsAbi, legacyFactories, createProver, loadProver, createSharedProver, loadSharedProver, privateRouterAbi, relayerSubmitter, sharedRelayerSubmitter, sharedVaultAbi, SharedVaultClient, shieldedPoolAbi, } from "@cloakely/sdk";
 import { Spending } from "./limits.js";
 export { loadSettings } from "./config.js";
 export { Spending } from "./limits.js";
-export const VERSION = "0.6.0";
+export const VERSION = "0.7.0";
 export const HOSTED_URL = "https://cloak.boblabs.tech/mcp";
 const INSTRUCTIONS = `Cloak: sealed-bid token launches and private trading on Kinetiq's Elysium (HYPE is the gas and base currency).
 
@@ -94,6 +94,26 @@ export function createCloakServer(settings, opts = {}) {
         (() => (proverP ??= settings.circuitsDir
             ? Promise.resolve(createProver(readFileSync(join(settings.circuitsDir, "transaction2x2.wasm")), readFileSync(join(settings.circuitsDir, "transaction2x2_final.zkey"))))
             : loadProver(d.circuitsUrl)));
+    let sharedProverP;
+    const sharedProver = () => (sharedProverP ??= settings.circuitsDir
+        ? Promise.resolve(createSharedProver(readFileSync(join(settings.circuitsDir, "transactionMA2x2.wasm")), readFileSync(join(settings.circuitsDir, "transactionMA2x2_final.zkey"))))
+        : loadSharedProver(d.circuitsUrl));
+    let sharedC;
+    /** The shared launch-token vault (new Uniswap launches keep their private balances there). */
+    async function shared() {
+        if (!d.shared || !d.sharedRouter)
+            throw new Error("This deployment has no shared launch-token vault.");
+        const p = await priv();
+        if (!sharedC || sharedC.priv !== p)
+            sharedC = new SharedVaultClient(p, d.shared, d.sharedRouter, sharedProver, sharedRelayerSubmitter(d.relayerUrl), d.sharedBlock ?? 0n);
+        return sharedC;
+    }
+    /** Private balance of one asset, wherever its vault is. */
+    async function balanceOf(a) {
+        if (a.kind === "token" && a.shared)
+            return (await shared()).balance(a.token);
+        return (await priv()).balance(a.pool);
+    }
     let privP;
     async function priv() {
         if (!wallet)
@@ -157,6 +177,18 @@ export function createCloakServer(settings, opts = {}) {
             else
                 out.push({ kind: "token", symbol, token, pool, pair, decimals: 18 });
         }
+        // tokens in the shared launch-token vault (every Uniswap launch from Nov 2 on)
+        if (d.shared) {
+            const v = { address: d.shared, abi: sharedVaultAbi };
+            const m = Number(await pub.readContract({ ...v, functionName: "tokensCount" }));
+            for (let i = 0; i < m; i++) {
+                const token = await pub.readContract({ ...v, functionName: "tokens", args: [BigInt(i)] });
+                if (out.some((a) => a.token.toLowerCase() === token.toLowerCase()))
+                    continue;
+                const [pair, symbol] = await Promise.all([pub.readContract({ ...v, functionName: "marketOf", args: [token] }), symbolOf(token)]);
+                out.push({ kind: "token", symbol, token, pool: d.shared, pair, decimals: 18, shared: true });
+            }
+        }
         return out;
     }
     /** "HYPE", "USDC", a launch token's symbol, or any of their addresses. */
@@ -185,7 +217,9 @@ export function createCloakServer(settings, opts = {}) {
             pub.readContract({ address: t.pair, abi: cloakPairAbi, functionName: "reserveToken" }),
         ]);
         const out = await pub.readContract({ address: t.pair, abi: cloakPairAbi, functionName: "getAmountOut", args: side === "buy" ? [net, rH, rT] : [net, rT, rH] });
-        const fee = await submit.quote("privateSwap", poolIn).then((q) => q.fee, () => 0n);
+        const fee = t.shared
+            ? await (side === "buy" ? sharedRelayerSubmitter(d.relayerUrl).quote("sharedBuy", t.token) : sharedRelayerSubmitter(d.relayerUrl).quote("sharedSell", t.token)).then((q) => q.fee, () => 0n)
+            : await submit.quote("privateSwap", poolIn).then((q) => q.fee, () => 0n);
         return { out, net, fee };
     }
     /** What an amount of an asset counts against: HYPE value (launch tokens at the pool's price), or USDC. */
@@ -575,7 +609,7 @@ export function createCloakServer(settings, opts = {}) {
         const out = {};
         const tokens = {};
         for (const a of await vaults()) {
-            const b = await p.balance(a.pool);
+            const b = await balanceOf(a);
             if (b === 0n && !include_zero && a.kind === "token")
                 continue;
             if (a.kind === "token")
@@ -587,13 +621,13 @@ export function createCloakServer(settings, opts = {}) {
     }));
     server.registerTool("shield", {
         title: "Shield into a private balance",
-        description: "Deposit HYPE or USDC from the wallet into the private balance. This is the one public step: it lands on a one-time key, so it can't be linked to what comes next.",
-        inputSchema: { asset: z.string().describe('"HYPE" or "USDC"'), amount: amt("Amount"), dry_run: dry },
+        description: "Deposit HYPE, USDC or a new launch token (one in the shared launch-token vault) from the wallet into the private balance. This is the one public step: it lands on a one-time key, so it can't be linked to what comes next.",
+        inputSchema: { asset: z.string().describe('"HYPE", "USDC" or a launch token in the shared vault'), amount: amt("Amount"), dry_run: dry },
         annotations: WRITE,
     }, safe(async ({ asset, amount, dry_run }) => {
         const { wallet, spending } = needWallet();
         const a = await resolve(asset);
-        if (a.kind === "token")
+        if (a.kind === "token" && !a.shared)
             throw new Error("Launch tokens enter a private balance by buying privately (private_swap), not by shielding.");
         const x = amountOf(amount, a.decimals);
         if (x === null)
@@ -604,9 +638,9 @@ export function createCloakServer(settings, opts = {}) {
             return { dryRun: true, wouldShield: fmtAmt(a, x), ...(a.kind === "asset" ? { note: "The first time takes two transactions: an approval, then the deposit." } : {}) };
         return exclusive(async () => {
             const p = await priv();
-            const h = a.kind === "hype" ? await p.shieldHype(wallet, x) : await p.shieldToken(wallet, a.token, x);
+            const h = a.kind === "hype" ? await p.shieldHype(wallet, x) : a.kind === "token" ? await (await shared()).shield(wallet, a.token, x) : await p.shieldToken(wallet, a.token, x);
             spending.record(c.budget, c.value);
-            return { shielded: fmtAmt(a, x), privateBalance: fmtAmt(a, await p.balance(a.pool)), tx: link(h) };
+            return { shielded: fmtAmt(a, x), privateBalance: fmtAmt(a, await balanceOf(a)), tx: link(h) };
         });
     }));
     server.registerTool("private_swap", {
@@ -621,7 +655,7 @@ export function createCloakServer(settings, opts = {}) {
             throw new Error(`${t.symbol} isn't a launch token: private swaps trade launch tokens against HYPE.`);
         const p = await priv();
         const poolIn = side === "buy" ? d.hypePool : t.pool;
-        const x = amountOf(amount, 18) ?? (await p.maxSpendable(poolIn, "privateSwap"));
+        const x = amountOf(amount, 18) ?? (t.shared && side === "sell" ? await (await shared()).maxWithdraw(t.token, "sharedSell") : await p.maxSpendable(d.hypePool === poolIn ? d.hypePool : poolIn, "privateSwap"));
         if (x <= 0n)
             throw new Error("Not enough private balance for this, counting the relayer's fee.");
         const c = await cost(side === "buy" ? (await vaults())[0] : t, x);
@@ -632,6 +666,14 @@ export function createCloakServer(settings, opts = {}) {
         if (isDry(dry_run))
             return { dryRun: true, wouldSwap: `${formatEther(x)} ${inSym} for about ${formatEther(q.out)} ${outSym}`, relayerFee: `${formatEther(q.fee)} ${inSym}`, slippage: `${(slippage_bps ?? 100) / 100}%` };
         return exclusive(async () => {
+            if (t.shared) {
+                const sh = await shared();
+                const h = side === "buy" ? await sh.buy(t.token, x, { slippageBps: slippage_bps ?? 100 }) : await sh.sell(t.token, x, { slippageBps: slippage_bps ?? 100 });
+                await receipt(h);
+                spending.record(c.budget, c.value);
+                const hypeA = (await vaults())[0];
+                return { swapped: `${formatEther(x)} ${inSym}`, expected: `${formatEther(q.out)} ${outSym}`, relayerFee: `${formatEther(q.fee)} HYPE or ${t.symbol}`, privateBalance: { HYPE: formatEther(await balanceOf(hypeA)), [t.symbol]: formatEther(await balanceOf(t)) }, tx: link(h), sentBy: "the relayer, not this wallet" };
+            }
             const r = await (side === "buy" ? p.buy(t.token, x, { slippageBps: slippage_bps }) : p.sell(t.token, x, { slippageBps: slippage_bps }));
             await receipt(r.txHash);
             spending.record(c.budget, c.value);
@@ -649,6 +691,8 @@ export function createCloakServer(settings, opts = {}) {
         const t = await resolve(token);
         if (t.kind !== "token")
             throw new Error(`${t.symbol} isn't a launch token: batch orders trade launch tokens against HYPE.`);
+        if (t.shared)
+            throw new Error(`${t.symbol} is in the shared launch-token vault, which has no batch rounds yet. Use private_swap.`);
         const x = amountOf(amount, 18);
         if (x === null)
             throw new Error('Give an exact amount for a batch order ("max" works for private_swap).');
@@ -672,7 +716,7 @@ export function createCloakServer(settings, opts = {}) {
     }));
     server.registerTool("private_send", {
         title: "Send privately",
-        description: "Pay someone's cloak: address from the private balance. The chain sees that a private transaction happened, but not who sent it, who got it or how much.",
+        description: "Pay someone's cloak: address from the private balance. The chain sees that a private transaction happened, but not who sent it, who got it or how much. For tokens in the shared launch-token vault it can't even tell which token (the relayer is paid from private HYPE, so keep a little private HYPE).",
         inputSchema: { asset: z.string().describe('"HYPE", "USDC" or a launch token'), to: z.string().describe("Recipient cloak: address"), amount: amt('Amount, or "max"'), dry_run: dry },
         annotations: WRITE,
     }, safe(async ({ asset, to, amount, dry_run }) => {
@@ -681,14 +725,21 @@ export function createCloakServer(settings, opts = {}) {
             throw new Error("The recipient must be a cloak: address (the receiver gets it from unlock or the Portfolio page).");
         const a = await resolve(asset);
         const p = await priv();
-        const x = amountOf(amount, a.decimals) ?? (await p.maxSpendable(a.pool, "transact"));
+        const sharedTok = a.kind === "token" && a.shared;
+        const x = amountOf(amount, a.decimals) ?? (sharedTok ? await balanceOf(a) : await p.maxSpendable(a.pool, "transact"));
         if (x <= 0n)
             throw new Error("Not enough private balance for this, counting the relayer's fee.");
         const c = await cost(a, x);
         spending.check(c.budget, c.value);
         if (isDry(dry_run))
-            return { dryRun: true, wouldSend: fmtAmt(a, x), to };
+            return { dryRun: true, wouldSend: fmtAmt(a, x), to, ...(sharedTok ? { relayerFee: "paid from your private HYPE, so the send doesn't show which token moved" } : {}) };
         return exclusive(async () => {
+            if (sharedTok) {
+                const h = await (await shared()).send(a.token, x, to);
+                await receipt(h);
+                spending.record(c.budget, c.value);
+                return { sent: fmtAmt(a, x), to, privateBalance: fmtAmt(a, await balanceOf(a)), tx: link(h), visibleOnChain: "a private transaction happened; no sender, recipient, amount, or even which token" };
+            }
             const h = await p.send(a.kind === "hype" ? p.hypeMarket.token : a.token, to, x);
             await receipt(h);
             spending.record(c.budget, c.value);
@@ -707,7 +758,8 @@ export function createCloakServer(settings, opts = {}) {
         const a = await resolve(asset);
         const p = await priv();
         const kind = a.kind === "hype" ? "unshieldHype" : "transact";
-        const x = amountOf(amount, a.decimals) ?? (await p.maxSpendable(a.pool, kind));
+        const sharedTok = a.kind === "token" && a.shared;
+        const x = amountOf(amount, a.decimals) ?? (sharedTok ? await (await shared()).maxWithdraw(a.token) : await p.maxSpendable(a.pool, kind));
         if (x <= 0n)
             throw new Error("Not enough private balance for this, counting the relayer's fee.");
         const c = await cost(a, x);
@@ -716,10 +768,10 @@ export function createCloakServer(settings, opts = {}) {
         if (isDry(dry_run))
             return { dryRun: true, wouldWithdraw: fmtAmt(a, x), arrives: fmtAmt(a, arrives), to };
         return exclusive(async () => {
-            const h = a.kind === "hype" ? await p.unshieldHype(to, x) : await p.unshieldToken(a.token, to, x);
+            const h = a.kind === "hype" ? await p.unshieldHype(to, x) : sharedTok ? await (await shared()).unshield(a.token, x, to) : await p.unshieldToken(a.token, to, x);
             await receipt(h);
             spending.record(c.budget, c.value);
-            return { withdrew: fmtAmt(a, x), arrived: fmtAmt(a, arrives), to, privateBalance: fmtAmt(a, await p.balance(a.pool)), tx: link(h) };
+            return { withdrew: fmtAmt(a, x), arrived: fmtAmt(a, arrives), to, privateBalance: fmtAmt(a, await balanceOf(a)), tx: link(h) };
         });
     }));
     return server;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloakely/mcp",
   "mcpName": "io.github.NECOKIZZ/cloak",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Cloak's MCP server: let an AI agent launch tokens with sealed bids and trade them privately on Elysium, with spending limits, testnet by default and a local signer.",
   "keywords": [
     "mcp",
@@ -47,7 +47,7 @@
     "@modelcontextprotocol/sdk": "1.32.1",
     "viem": "2.21.54",
     "zod": "4.6.7",
-    "@cloakely/sdk": "^0.6.0"
+    "@cloakely/sdk": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "22.10.2",