@cloakely/mcp 0.5.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.5.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.5.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. */
@@ -227,7 +261,7 @@ export function createCloakServer(settings, opts = {}) {
             ...(s.settled
                 ? { clearingPrice: `${formatEther(s.clearingPrice)} HYPE per token`, sold: formatEther(s.sold), raised: hype(s.raised), pool: s.pair }
                 : {}),
-            liquidity: `${s.lpBps / 100}% of the raise seeds the pool at the clearing price; LP ${s.lpLockUntil === 0 ? "burned" : `locked until ${iso(s.lpLockUntil)}`}`,
+            liquidity: `${s.lpBps / 100}% of the raise seeds the pool at the clearing price; LP ${s.lpLockUntil === 0 ? "burned" : s.creatorFees || s.lpLockUntil >= 2 ** 63 ? "locked forever, trading fees to the creator" : `locked until ${iso(s.lpLockUntil)}`}`,
             noRevealPenalty: `${s.noRevealPenaltyBps / 100}%`,
             launchFee: `${s.launchFeeBps / 100}% of a successful raise`,
             caps: { perBid: s.bidCap ? hype(s.bidCap) : "none", total: s.depositCap ? hype(s.depositCap) : "none" },
@@ -386,7 +420,7 @@ export function createCloakServer(settings, opts = {}) {
                 ifCreatedNow: { biddingEnds: iso(commitEnd), revealsEnd: iso(revealEnd) },
                 priceRange: `${formatEther(min)} to ${formatEther(top)} HYPE per token, ${ticks} ticks`,
                 raiseIfFullySold: { atLowestPrice: hype(raise(min)), atHighestPrice: hype(raise(top)) },
-                toPool: `${lp}% of the raise, paired with tokens at the clearing price; the LP is burned unless you lock it`,
+                toPool: `${lp}% of the raise, paired with tokens at the clearing price in a Uniswap V2 pool; the LP is locked forever and its 0.3% trading fees go to you (or burned, or locked for a set time)`,
                 launchFee: "1.5% of a successful raise; nothing if the launch doesn't fill",
                 caps: "During the beta a bid can be at most 100 HYPE and an auction can take at most 10,000 HYPE.",
                 create: { onTheSite: "https://cloak.boblabs.tech/app/create", withAnAgent: "the local server's create_launch tool (see connect_full_agent)" },
@@ -420,7 +454,8 @@ export function createCloakServer(settings, opts = {}) {
             reveal_minutes: z.number().min(1).max(60 * 24).optional().describe("Time for bids to open after bidding closes (default 10)"),
             lp_percent: z.number().min(0).max(100).optional().describe("Share of the raise that seeds the pool (default 50)"),
             lp_tokens: amt("Tokens paired with that HYPE (default: same as sale_supply)").optional(),
-            lp_lock_days: z.number().min(0).optional().describe("Lock the LP for this many days instead of burning it (default: burn)"),
+            lp_lock_days: z.number().min(0).optional().describe("Lock the LP for this many days, after which the creator can take it (overrides creator_fees)"),
+            creator_fees: z.boolean().optional().describe("Lock the LP forever and pay the pool's 0.3% trading fees to the creator (default true; false burns the LP)"),
             creator_share: amt("Tokens for the creator, at most 20% of supply, vesting linearly").optional(),
             vest_days: z.number().min(30).optional().describe("Vesting length for the creator share (default 90)"),
             metadata_uri: z.string().optional(),
@@ -445,7 +480,7 @@ export function createCloakServer(settings, opts = {}) {
             commitEnd,
             revealEnd,
             lpBps: Math.round((p.lp_percent ?? 50) * 100),
-            lpLockUntil: p.lp_lock_days ? now + Math.round(p.lp_lock_days * 86400) : "burn",
+            lpLockUntil: p.lp_lock_days ? revealEnd + Math.round(p.lp_lock_days * 86400) : p.creator_fees === false ? "burn" : "fees",
             metadataURI: p.metadata_uri,
         };
         spending.check("launches", 1n);
@@ -574,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")
@@ -586,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)
@@ -603,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", {
@@ -620,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);
@@ -631,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);
@@ -648,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).');
@@ -671,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 }) => {
@@ -680,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);
@@ -706,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);
@@ -715,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.5.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.5.0"
+    "@cloakely/sdk": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "22.10.2",