@cloakely/mcp 0.1.2 → 0.3.0

package/dist/config.d.ts

@@ -23,3 +23,8 @@ export interface Limits {
     launchesPerDay: number;
 }
 export declare function loadSettings(env?: NodeJS.ProcessEnv): Settings;
+/**
+ * `settings` with the current factory, router, batcher, migrator and vaults read from CloakConfig's registry, so a
+ * router added on-chain is used without a new release. Keeps the configured deployment if the registry can't be read.
+ */
+export declare function withLiveDeployment(settings: Settings): Promise<Settings>;

package/dist/config.js

@@ -1,10 +1,10 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { defineChain, parseEther, parseUnits } from "viem";
-import { deploymentFor, elysiumTestnet } from "@cloakely/sdk";
+import { createPublicClient, defineChain, http, parseEther, parseUnits } from "viem";
+import { deploymentFor, elysiumTestnet, liveDeployment } from "@cloakely/sdk";
 const NETWORKS = {
-    testnet: { chain: elysiumTestnet, launchesFromBlock: 15855986n },
+    testnet: { chain: elysiumTestnet },
 };
 export function loadSettings(env = process.env) {
     const network = env.CLOAK_NETWORK ?? (env.CLOAK_DEPLOYMENT_FILE ? "custom" : "testnet");
@@ -23,8 +23,15 @@ export function loadSettings(env = process.env) {
         const f = JSON.parse(readFileSync(env.CLOAK_DEPLOYMENT_FILE, "utf8"));
         rpcUrl = f.rpcUrl;
         chain = defineChain({ id: f.chainId, name: `Cloak custom (${f.chainId})`, nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 }, rpcUrls: { default: { http: [rpcUrl] } }, testnet: true });
-        deployment = { ...f, routerBlock: BigInt(f.routerBlock), assets: f.assets?.map((a) => ({ ...a, fromBlock: BigInt(a.fromBlock) })) };
         launchesFromBlock = BigInt(f.launchesFromBlock ?? 0);
+        deployment = {
+            ...f,
+            version: f.version ?? 0,
+            factoryBlock: launchesFromBlock,
+            routerBlock: BigInt(f.routerBlock),
+            vaultsBlock: f.vaultsBlock === undefined ? undefined : BigInt(f.vaultsBlock),
+            assets: f.assets?.map((a) => ({ ...a, fromBlock: BigInt(a.fromBlock) })),
+        };
     }
     else {
         const n = NETWORKS[network];
@@ -32,7 +39,7 @@ export function loadSettings(env = process.env) {
             throw new Error(`unknown CLOAK_NETWORK "${network}" (use testnet)`);
         chain = n.chain;
         deployment = deploymentFor(chain.id);
-        launchesFromBlock = n.launchesFromBlock;
+        launchesFromBlock = deployment.factoryBlock;
         rpcUrl = chain.rpcUrls.default.http[0];
     }
     if (env.CLOAK_RPC_URL)
@@ -71,3 +78,13 @@ export function loadSettings(env = process.env) {
         },
     };
 }
+/**
+ * `settings` with the current factory, router, batcher, migrator and vaults read from CloakConfig's registry, so a
+ * router added on-chain is used without a new release. Keeps the configured deployment if the registry can't be read.
+ */
+export async function withLiveDeployment(settings) {
+    const pub = createPublicClient({ chain: settings.chain, transport: http(settings.rpcUrl, { retryCount: 3, timeout: 15_000 }) });
+    const deployment = await liveDeployment(pub, settings.deployment).catch(() => settings.deployment);
+    const moved = deployment.factory.toLowerCase() !== settings.deployment.factory.toLowerCase();
+    return { ...settings, deployment, launchesFromBlock: moved ? deployment.factoryBlock : settings.launchesFromBlock };
+}

package/dist/http.js

@@ -1,5 +1,5 @@
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import { loadSettings } from "./config.js";
+import { loadSettings, withLiveDeployment } from "./config.js";
 import { createCloakServer } from "./server.js";
 /**
  * The hosted MCP endpoint as a web-standard handler (Request in, Response out), for any serverless runtime.
@@ -39,6 +39,8 @@ function limited(ip) {
     return h.n > REQUESTS_PER_MINUTE ? Math.ceil((h.start + 60_000 - now) / 1000) : 0;
 }
 let settings;
+let settingsAt = 0;
+const SETTINGS_TTL = 10 * 60_000; // re-read the registry every 10 minutes
 /** `settings` defaults to Elysium testnet, without a key (tests pass their own). */
 export async function handleMcpRequest(req, opts = {}) {
     if (req.method === "OPTIONS")
@@ -75,7 +77,11 @@ export async function handleMcpRequest(req, opts = {}) {
     headers.delete("transfer-encoding");
     const forward = new Request(req.url, { method: "POST", headers });
     // never a key here, whatever the environment says
-    const s = opts.settings ?? (settings ??= loadSettings({ CLOAK_NETWORK: "testnet", CLOAK_RPC_URL: process.env.CLOAK_RPC_URL, CLOAK_RELAYER_URL: process.env.CLOAK_RELAYER_URL }));
+    if (!opts.settings && (!settings || Date.now() - settingsAt > SETTINGS_TTL)) {
+        settingsAt = Date.now();
+        settings = withLiveDeployment(loadSettings({ CLOAK_NETWORK: "testnet", CLOAK_RPC_URL: process.env.CLOAK_RPC_URL, CLOAK_RELAYER_URL: process.env.CLOAK_RELAYER_URL }));
+    }
+    const s = opts.settings ?? (await settings);
     const server = createCloakServer(s, { hosted: true });
     const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
     try {

package/dist/index.js

@@ -2,8 +2,9 @@
 // Cloak's MCP server over stdio: `npx @cloakely/mcp`. Configuration is environment variables only (see README).
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createCloakServer, loadSettings, VERSION } from "./server.js";
+import { withLiveDeployment } from "./config.js";
 try {
-    const settings = loadSettings();
+    const settings = await withLiveDeployment(loadSettings());
     const server = createCloakServer(settings);
     await server.connect(new StdioServerTransport());
     // stdout carries the protocol, so anything for humans goes to stderr

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.1.2";
+export declare const VERSION = "0.3.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,15 +4,15 @@ 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, cloakPairAbi, createProver, loadProver, privateRouterAbi, relayerSubmitter, shieldedPoolAbi, } from "@cloakely/sdk";
+import { Cloak, CloakPrivate, cloakAuctionAbi, cloakPairAbi, cloakVaultsAbi, createProver, loadProver, privateRouterAbi, relayerSubmitter, shieldedPoolAbi, } from "@cloakely/sdk";
 import { Spending } from "./limits.js";
 export { loadSettings } from "./config.js";
 export { Spending } from "./limits.js";
-export const VERSION = "0.1.2";
+export const VERSION = "0.3.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).
 
-Launches: create_launch starts a sealed-bid auction. place_sealed_bid commits a bid that nobody can read until bidding closes; bids then open by themselves (the keeper reveals them from the drand beacon), so there is nothing to come back for. Everyone who wins pays one clearing price. After settlement, claim pays out tokens and refunds (the keeper usually pushes claims already), and enable_private_trading opens a private vault for the token if nobody has yet.
+Launches: create_launch starts a sealed-bid auction. place_sealed_bid commits a bid that nobody can read until bidding closes; bids then open by themselves (the keeper reveals them from the drand beacon), so there is nothing to come back for. Everyone who wins pays one clearing price. After settlement, claim puts won tokens straight into the private balance (and refunds into the wallet); the keeper opens each launch's private vault at settlement, and pushes bids nobody claimed to wallets publicly about an hour later. enable_private_trading opens a private vault for an older launch if nobody has yet.
 
 Private balances: shield moves HYPE or USDC from the wallet into a private balance (the one public step). private_swap, batch_order, private_send and withdraw then run from that balance: each is proven on this machine and sent by a relayer, so the wallet never appears on chain. batch_order also hides trade size. withdraw lands funds at a normal address, ideally a fresh one. Amounts are in whole units ("0.5" HYPE), and send, sell and withdraw accept "max".
 
@@ -78,7 +78,12 @@ export function createCloakServer(settings, opts = {}) {
     });
     const account = settings.privateKey ? privateKeyToAccount(settings.privateKey) : undefined;
     const wallet = account ? createWalletClient({ chain: settings.chain, transport: http(settings.rpcUrl), account }) : undefined;
-    const cloak = new Cloak(pub, wallet, d.factory);
+    // earlier deployments' launches still list, settle and pay out
+    const cloak = new Cloak(pub, wallet, d.factory, (d.previous ?? []).map((p) => p.factory));
+    /** Where to start scanning a launch's bids: the current factory's deploy block, or the start for an older launch. */
+    const bidsFrom = async (auction) => (await pub.readContract({ address: auction, abi: [{ type: "function", name: "factory", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] }], functionName: "factory" }).catch(() => zeroAddress)).toLowerCase() === d.factory.toLowerCase()
+        ? settings.launchesFromBlock
+        : 0n;
     const spending = account ? new Spending(settings.limits, settings.stateDir, account.address) : undefined;
     const submit = relayerSubmitter(d.relayerUrl);
     const explorer = settings.chain.blockExplorers?.default.url;
@@ -93,8 +98,9 @@ export function createCloakServer(settings, opts = {}) {
         if (!wallet)
             throw new Error("No wallet configured: set CLOAK_KEY_FILE (or CLOAK_PRIVATE_KEY) to use private balances.");
         privP ??= (async () => {
-            const keys = await CloakPrivate.keysFromWallet(wallet, { chainId: settings.chain.id, router: d.router, verify: true });
-            const p = new CloakPrivate(pub, d.router, keys, prover, submit, d.routerBlock, d.batcher, d.migrator);
+            const keys = await CloakPrivate.keysFromWallet(wallet, { chainId: settings.chain.id, verify: true });
+            // notes are scanned from the permanent vaults' first block, whichever router is current
+            const p = new CloakPrivate(pub, d.router, keys, prover, submit, d.vaultsBlock ?? d.routerBlock, d.batcher, d.migrator);
             for (const a of d.assets ?? [])
                 p.addAsset(a);
             return p;
@@ -125,6 +131,9 @@ export function createCloakServer(settings, opts = {}) {
             symbols.set(k, await pub.readContract({ address: token, abi: erc20Abi, functionName: "symbol" }).catch(() => "?"));
         return symbols.get(k);
     }
+    async function decimalsOf(token) {
+        return Number(await pub.readContract({ address: token, abi: erc20Abi, functionName: "decimals" }).catch(() => 18));
+    }
     /** Every asset with a private vault: HYPE, USDC-like assets, and every launch token with a private market. */
     async function vaults() {
         const c = { address: d.router, abi: privateRouterAbi };
@@ -132,14 +141,20 @@ export function createCloakServer(settings, opts = {}) {
         const out = [{ kind: "hype", symbol: "HYPE", token: d.whype, pool: d.hypePool, decimals: 18 }];
         for (const a of d.assets ?? [])
             out.push({ kind: "asset", symbol: a.symbol, token: a.token, pool: a.pool, decimals: a.decimals });
-        const toks = await Promise.all(Array.from({ length: Number(n) - 1 }, (_, i) => pub.readContract({ ...c, functionName: "tokens", args: [BigInt(i + 1)] })));
+        const toks = await Promise.all(Array.from({ length: Number(n) }, (_, i) => pub.readContract({ ...c, functionName: "tokens", args: [BigInt(i)] })));
         for (const token of toks) {
+            if (out.some((a) => a.token.toLowerCase() === token.toLowerCase()))
+                continue; // HYPE, or an asset already listed
             const [pool, pair, symbol] = await Promise.all([
                 pub.readContract({ ...c, functionName: "poolOf", args: [token] }),
                 pub.readContract({ ...c, functionName: "pairOf", args: [token] }),
                 symbolOf(token),
             ]);
-            out.push({ kind: "token", symbol, token, pool, pair, decimals: 18 });
+            // a vault without a launch pair holds an existing token (USDC): an asset, not a market
+            if (pair === zeroAddress)
+                out.push({ kind: "asset", symbol, token, pool, decimals: await decimalsOf(token) });
+            else
+                out.push({ kind: "token", symbol, token, pool, pair, decimals: 18 });
         }
         return out;
     }
@@ -467,36 +482,62 @@ export function createCloakServer(settings, opts = {}) {
     server.registerTool("my_bids", { title: "My bids", description: "The wallet's bids on a launch: deposit, whether each has opened, and once settled the tokens won, refund and any penalty.", inputSchema: { auction: addr }, annotations: READ }, safe(async ({ auction }) => {
         const { account } = needWallet();
         const s = await cloak.getAuction(auction);
-        const bids = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+        const bids = await cloak.bidsOf(s.address, account.address, await bidsFrom(s.address));
         return {
             launch: s.tokenSymbol,
             phase: s.phase,
             bids: bids.map((b) => ({ id: b.id, deposit: hype(b.deposit), opened: b.revealed, claimed: b.claimed, ...(s.settled ? { tokensWon: formatEther(b.tokens), refund: hype(b.refund), penalty: hype(b.penalty) } : {}) })),
         };
     }));
-    server.registerTool("claim", { title: "Claim tokens and refunds", description: "After bids open, settle the launch if nobody has yet, then claim the wallet's tokens and refunds. Cloak's keeper usually pushes claims already.", inputSchema: { auction: addr, dry_run: dry }, annotations: WRITE }, safe(async ({ auction, dry_run }) => {
+    server.registerTool("claim", {
+        title: "Claim tokens and refunds",
+        description: "After bids open, settle the launch if nobody has yet, then claim the wallet's tokens and refunds. Won tokens go straight into the private balance (privately: true, the default) when the launch supports it, so later trades can't be linked to the bid; refunds go to the wallet. Cloak's keeper pushes unclaimed bids to wallets publicly about an hour after bidding closes.",
+        inputSchema: { auction: addr, privately: z.boolean().optional().describe("Claim won tokens into the private balance (default true where supported)"), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ auction, privately, dry_run }) => {
         const { account } = needWallet();
         let s = await cloak.getAuction(auction);
         if (s.phase === "commit" || s.phase === "reveal")
             throw new Error(`${s.tokenSymbol} can't settle yet: bids are ${s.phase === "commit" ? "still being placed" : "still opening"} until ${iso(s.phase === "commit" ? s.commitEnd : s.revealEnd)}.`);
-        const bids = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+        const bids = await cloak.bidsOf(s.address, account.address, await bidsFrom(s.address));
         const open = bids.filter((b) => !b.claimed);
+        // private claims: launches from this deployment's factory, once their private vault is open
+        const canPrivate = async () => privately !== false && !s.failed && (await bidsFrom(s.address)) === settings.launchesFromBlock && (await privateTradingOn(s.token));
         if (isDry(dry_run))
-            return { dryRun: true, wouldSettle: !s.settled, wouldClaim: open.map((b) => b.id) };
+            return { dryRun: true, wouldSettle: !s.settled, wouldClaim: open.map((b) => b.id), privately: s.settled ? await canPrivate() : privately !== false };
         return exclusive(async () => {
             const txs = [];
             if (!s.settled) {
                 txs.push(link(await cloak.settle(s.address)));
                 s = await cloak.getAuction(s.address);
             }
-            if (open.length)
-                txs.push(link(await cloak.claim(s.address, open.map((b) => b.id))));
-            const after = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+            const priv8 = await canPrivate();
+            const won = [];
+            let publicWhy;
+            if (priv8) {
+                const p = await priv();
+                for (const b of open.filter((x) => x.tokens > 0n)) {
+                    // a deposit limit can refuse a large claim; that bid is then claimed to the wallet instead
+                    const ok = await pub
+                        .simulateContract({ address: s.address, abi: cloakAuctionAbi, functionName: "claimPrivate", args: [b.id, 1n, 1n, "0x"], account: account.address })
+                        .then(() => true, (e) => ((publicWhy = explain(e)), false));
+                    if (!ok)
+                        continue;
+                    txs.push(link((await p.claimPrivately(wallet, s.address, b.id)).txHash));
+                    won.push(b);
+                }
+            }
+            const rest = open.filter((b) => !won.includes(b));
+            if (rest.length)
+                txs.push(link(await cloak.claim(s.address, rest.map((b) => b.id))));
+            const after = await cloak.bidsOf(s.address, account.address, await bidsFrom(s.address));
             return {
                 launch: s.tokenSymbol,
                 settled: s.settled,
                 ...(s.failed ? { failed: "No demand was revealed, so every bid was refunded in full." } : { clearingPrice: `${formatEther(s.clearingPrice)} HYPE per token` }),
                 claimed: open.length ? open.map((b) => b.id) : "nothing left to claim (already paid out)",
+                ...(won.length ? { claimedPrivately: won.map((b) => b.id), privateBalance: "won tokens are in the private balance (private_balance)" } : {}),
+                ...(publicWhy ? { claimedToWallet: `some won tokens went to the wallet instead of the private balance: ${publicWhy}` } : {}),
                 tokensWon: formatEther(after.reduce((a, b) => a + b.tokens, 0n)),
                 refunds: hype(after.reduce((a, b) => a + b.refund, 0n)),
                 txs,
@@ -510,13 +551,14 @@ export function createCloakServer(settings, opts = {}) {
             throw new Error(`${s.tokenSymbol} needs to settle successfully first (phase: ${s.phase}).`);
         if (await privateTradingOn(s.token))
             return { alreadyOn: true, token: s.token };
-        const idx = (await cloak.listLaunches()).findIndex((l) => l.auction.toLowerCase() === s.address.toLowerCase());
-        if (idx < 0)
-            throw new Error("This launch isn't from the current Cloak factory, so it can't get a private vault.");
+        const l = (await cloak.listLaunches()).find((x) => x.auction.toLowerCase() === s.address.toLowerCase());
+        if (!l)
+            throw new Error("This launch isn't from a Cloak factory, so it can't get a private vault.");
+        const vaults = d.vaults ?? (await pub.readContract({ address: d.router, abi: privateRouterAbi, functionName: "vaults" }));
         if (isDry(dry_run))
-            return { dryRun: true, wouldEnable: s.tokenSymbol, launchIndex: idx };
+            return { dryRun: true, wouldEnable: s.tokenSymbol, factory: l.factory, launchIndex: l.index };
         return exclusive(async () => {
-            const h = await wallet.writeContract({ address: d.router, abi: privateRouterAbi, functionName: "createPool", args: [BigInt(idx)] });
+            const h = await wallet.writeContract({ address: vaults, abi: cloakVaultsAbi, functionName: "createPool", args: [l.factory, l.index] });
             await receipt(h);
             return { enabled: true, token: s.token, vault: await pub.readContract({ address: d.router, abi: privateRouterAbi, functionName: "poolOf", args: [s.token] }), tx: link(h) };
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloakely/mcp",
   "mcpName": "io.github.NECOKIZZ/cloak",
-  "version": "0.1.2",
+  "version": "0.3.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.2.6"
+    "@cloakely/sdk": "^0.4.0"
   },
   "devDependencies": {
     "@types/node": "22.10.2",