@cloakely/sdk 0.3.1 → 0.4.0

package/dist/cloak.d.ts

@@ -117,6 +117,7 @@ export declare class Cloak {
         creatorAlloc: bigint;
         vesting: Address;
         factory: Address;
+        index: bigint;
         legacy?: boolean;
     }[]>;
     private listLegacy;
@@ -341,6 +342,28 @@ export declare class Cloak {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "claimPrivate";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "pubKey";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "blinding";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "memo";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "claimedCount";
@@ -915,6 +938,16 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "ClaimedPrivately";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly indexed: true;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
     }, {
         readonly type: "event";
         readonly name: "Committed";

package/dist/cloak.js

@@ -132,7 +132,7 @@ export class Cloak {
             // a factory from v2 on returns a vesting contract too; the first one returns five fields
             const six = await this.publicClient.readContract({ address: factory, abi: cloakFactoryAbi, functionName: "launches", args: [i] }).catch(() => null);
             const [auction, token, creator, launchpad, creatorAlloc] = six ?? (await this.publicClient.readContract({ address: factory, abi: LEGACY_LAUNCHES_ABI, functionName: "launches", args: [i] }));
-            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting: (six?.[5] ?? zeroAddress), factory, legacy: true });
+            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting: (six?.[5] ?? zeroAddress), factory, index: i, legacy: true });
         }
         return out;
     }
@@ -152,7 +152,7 @@ export class Cloak {
                 functionName: "launches",
                 args: [i],
             });
-            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting, factory: this.factory });
+            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting, factory: this.factory, index: i });
         }
         return out;
     }

package/dist/deployments.d.ts

@@ -1,20 +1,30 @@
-import type { Address } from "viem";
-/** An earlier deployment on the same chain: its launches still list, and `migrator` moves its private balances here. */
+import type { Address, PublicClient } from "viem";
+/** An earlier deployment on the same chain: its launches still list, and the migrator moves its private balances here. */
 export interface PreviousDeployment {
     version: number;
     factory: Address;
     router: Address;
     routerBlock: bigint;
     batcher?: Address;
-    /** Moves this deployment's private balances into the current one (`CloakPrivate.migrateFrom(…, { migrator })`). */
+    /** Moved its balances into v3 (v1 and v2 only; from v4 on, the current deployment's `migrator` moves every version). */
     migrator?: Address;
+    /** Standalone vaults outside its router (v2's USDC vault), moved too. */
+    pools?: {
+        pool: Address;
+        fromBlock: bigint;
+    }[];
 }
 /** Where Cloak lives on each chain, so integrators never copy addresses by hand. */
 export interface CloakDeployment {
     chainId: number;
-    /** Which Cloak deployment this is (3 on Elysium testnet). */
+    /** Which Cloak deployment this is (4 on Elysium testnet). */
     version: number;
+    /** CloakConfig: the rules and the registry of every Cloak contract. `liveDeployment` reads the current ones from it. */
     config: Address;
+    /** CloakVaults: the permanent vaults (v4 on). */
+    vaults?: Address;
+    /** First block of the permanent vaults: scan private notes from here, whichever router is current. */
+    vaultsBlock?: bigint;
     factory: Address;
     /** Block the factory was deployed in: scan launch events from here. */
     factoryBlock: bigint;
@@ -22,7 +32,7 @@ export interface CloakDeployment {
     /** Block the router was deployed in: scan private-pool events from here. */
     routerBlock: bigint;
     batcher: Address;
-    /** The migrator from the newest earlier deployment (each one in `previous` has its own). */
+    /** Moves balances from every earlier deployment into the permanent vaults. */
     migrator?: Address;
     hypePool: Address;
     whype: Address;
@@ -44,3 +54,8 @@ export interface CloakDeployment {
 export declare const deployments: Record<number, CloakDeployment>;
 /** The Cloak deployment on `chainId`, or an error naming the chains Cloak is on. */
 export declare function deploymentFor(chainId: number): CloakDeployment;
+/**
+ * `base` with the current factory, router, batcher, migrator and vaults read from CloakConfig's registry, so a router or
+ * batcher added on-chain is picked up without a new SDK. Earlier deployments keep what `base` knows about them.
+ */
+export declare function liveDeployment(publicClient: PublicClient, base: CloakDeployment): Promise<CloakDeployment>;

package/dist/deployments.js

@@ -1,31 +1,48 @@
+import { privateRouterAbi } from "./abis.js";
+import { readRegistry } from "./registry.js";
 export const deployments = {
-    // Cloak v3 (Oct 30): deployments/elysium-testnet-v3.json
+    // Cloak v4 (Oct 31), the permanent vaults: deployments/elysium-testnet-v4.json. CloakConfig's registry lists all of it;
+    // liveDeployment() reads the current contracts from there.
     99801: {
         chainId: 99801,
-        version: 3,
-        config: "0x9d30c7b23fa2d5c40779d3db3bb4292e18c94373",
-        factory: "0xd0f4aacf339f07211a9155194925b2f94e250e29",
-        factoryBlock: 19096456n,
-        router: "0x78319bee7c21ca411166acc67c750aca10280e86",
-        routerBlock: 19096485n,
-        batcher: "0x9902d86c5be81f6c6ce059acf4c89193d06069c4",
-        migrator: "0x295f816aa6dac1901bd793120248d8f9cbbd5eec",
-        hypePool: "0x786886a61Dd77581ef03787c5939fC44B004064d",
+        version: 4,
+        config: "0x9fdf166f0671166148ea98cdd3ef0118d256167f",
+        vaults: "0x24bc1d369aab3a2d741a48f8cac1af5dfd9f3d43",
+        vaultsBlock: 19485039n,
+        factory: "0xa88df63d7d44acc66052e5cbe5ba9503bf940993",
+        factoryBlock: 19484794n,
+        router: "0x343ab9a7aac93cee28321410510ea24417cc6386",
+        routerBlock: 19485063n,
+        batcher: "0xc69e4bca18020ae93bc9f17093985bfb139a3203",
+        migrator: "0x86c5d8035224493f10938aaa07b179be316dadf4",
+        hypePool: "0x3ACB22829bb422446caaDd8546e65ab530A53031",
         whype: "0xe44b27113D4b947c0B1bDf4a93878D0e115f4bdD",
         relayerUrl: "https://cloak-keeper.onrender.com",
         circuitsUrl: "https://cloak.boblabs.tech/circuits",
         assets: [
             // Elysium testnet USDC (bridged from Circle's USDC on HyperEVM): private sends and withdrawals
-            { symbol: "USDC", token: "0x7D29d8047B905000459c0E80c34a26CeedcB47b2", pool: "0x61de30970e3c53665ce5a89323284e7ab379fa08", decimals: 6, fromBlock: 18329466n },
+            { symbol: "USDC", token: "0x7D29d8047B905000459c0E80c34a26CeedcB47b2", pool: "0x3d5cB722490D9908a118f8B3151f83fcE943E4F0", decimals: 6, fromBlock: 19485039n },
         ],
         previous: [
+            {
+                version: 3,
+                factory: "0xd0f4aacf339f07211a9155194925b2f94e250e29",
+                router: "0x78319bee7c21ca411166acc67c750aca10280e86",
+                routerBlock: 19096485n,
+                batcher: "0x9902d86c5be81f6c6ce059acf4c89193d06069c4",
+                pools: [
+                    { pool: "0x61de30970e3c53665ce5a89323284e7ab379fa08", fromBlock: 18329466n },
+                ],
+            },
             {
                 version: 2,
                 factory: "0xc1fc14e84cbbd10f75dad9d91bf50f47c48757fc",
                 router: "0xd51e731467c49991496329c2b7979cb1aa220ee2",
                 routerBlock: 15856031n,
                 batcher: "0xa13ffd763a8cccfea1b868c616291723579ddb77",
-                migrator: "0x295f816aa6dac1901bd793120248d8f9cbbd5eec",
+                pools: [
+                    { pool: "0x61de30970e3c53665ce5a89323284e7ab379fa08", fromBlock: 18329466n },
+                ],
             },
             {
                 version: 1,
@@ -33,7 +50,6 @@ export const deployments = {
                 router: "0xfa2574cfc3afb8f7d3a0651fa2111ff4e3d2fc41",
                 routerBlock: 10973723n,
                 batcher: "0xf6582cc5a84fccf74e571e652fb7b603a2c25812",
-                migrator: "0x5f3d82a6aa1b20ba9d0f58a98d1c4933c115a0da",
             },
         ],
     },
@@ -45,3 +61,45 @@ export function deploymentFor(chainId) {
         throw new Error(`Cloak isn't deployed on chain ${chainId} (available: ${Object.keys(deployments).join(", ")})`);
     return d;
 }
+/**
+ * `base` with the current factory, router, batcher, migrator and vaults read from CloakConfig's registry, so a router or
+ * batcher added on-chain is picked up without a new SDK. Earlier deployments keep what `base` knows about them.
+ */
+export async function liveDeployment(publicClient, base) {
+    const reg = await readRegistry(publicClient, base.config).catch(() => undefined);
+    if (!reg)
+        return base;
+    const [hypePool, whype] = await Promise.all([
+        publicClient.readContract({ address: reg.router, abi: privateRouterAbi, functionName: "hypePool" }),
+        publicClient.readContract({ address: reg.router, abi: privateRouterAbi, functionName: "whype" }),
+    ]);
+    const known = new Map((base.previous ?? []).map((p) => [p.version, p]));
+    return {
+        ...base,
+        version: reg.version,
+        vaults: reg.vaults ?? base.vaults,
+        vaultsBlock: reg.vaultsBlock ?? base.vaultsBlock,
+        factory: reg.factory,
+        factoryBlock: reg.factoryBlock,
+        router: reg.router,
+        routerBlock: reg.routerBlock,
+        batcher: reg.batcher ?? base.batcher,
+        migrator: reg.migrator ?? base.migrator,
+        hypePool,
+        whype,
+        previous: reg.previous.length
+            ? reg.previous.map((p) => {
+                const k = known.get(p.version);
+                return {
+                    version: p.version,
+                    factory: p.factory ?? k?.factory ?? ("0x" + "0".repeat(40)),
+                    router: p.router ?? k?.router ?? ("0x" + "0".repeat(40)),
+                    routerBlock: p.routerBlock ?? k?.routerBlock ?? 0n,
+                    batcher: p.batcher ?? k?.batcher,
+                    migrator: k?.migrator,
+                    pools: p.pools.length ? p.pools.map((x) => ({ pool: x.addr, fromBlock: x.startBlock })) : k?.pools,
+                };
+            })
+            : base.previous,
+    };
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./abis.js";
 export * from "./chains.js";
 export * from "./deployments.js";
+export * from "./registry.js";
 export * from "./seal.js";
 export * from "./cloak.js";
 export * from "./private/index.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./abis.js";
 export * from "./chains.js";
 export * from "./deployments.js";
+export * from "./registry.js";
 export * from "./seal.js";
 export * from "./cloak.js";
 export * from "./private/index.js";

package/dist/private/client.d.ts

@@ -70,17 +70,32 @@ export declare class CloakPrivate {
     })[];
     constructor(publicClient: PublicClient, router: Address, keys: CloakKeys, prover: () => Promise<Prover>, submit: Submitter, fromBlock?: bigint, batcher?: Address | undefined, migrator?: Address | undefined);
     /**
-     * Derive the private keys from one EIP-712 signature bound to this chain and router, so a signature asked for by any
-     * other site or contract can't reproduce them. With `verify`, the wallet signs twice and the keys are refused if the
-     * two signatures differ (some smart and MPC wallets sign differently each time, which would hide earlier notes).
+     * Derive the wallet's Cloak private account from one EIP-712 signature bound to this chain (never to a contract, so
+     * the account survives every upgrade). With `verify`, the wallet signs twice and the keys are refused if the two
+     * signatures differ (some smart and MPC wallets sign differently each time, which would hide earlier notes).
      */
     static keysFromWallet(wallet: Wallet, opts: {
         chainId: number;
-        router: Address;
         verify?: boolean;
     }): Promise<CloakKeys>;
+    /** Keys of a v2 or v3 account, bound to that deployment's router. Only needed to move an old balance across. */
+    static routerKeysFromWallet(wallet: Wallet, opts: {
+        chainId: number;
+        router: Address;
+    }): Promise<CloakKeys>;
+    /** The keys an earlier deployment's notes were made for: v1 a plain message, v2 and v3 their router, v4 on the account. */
+    static keysForVersion(wallet: Wallet, opts: {
+        chainId: number;
+        version: number;
+        router: Address;
+    }): Promise<CloakKeys>;
+    private static signedKeys;
     /** Keys of the first Cloak deployment (plain signed message). Only needed to move an old balance across. */
     static legacyKeysFromWallet(wallet: Wallet): Promise<CloakKeys>;
+    /**
+     * Read the router's vaults: HYPE first, then every launch market. A vault without a launch pair (USDC) is an asset,
+     * not a market, and is added to `assets` instead.
+     */
     loadMarkets(): Promise<PrivateMarket[]>;
     get hypeMarket(): PrivateMarket;
     market(token: Address): PrivateMarket;
@@ -116,6 +131,15 @@ export declare class CloakPrivate {
      * one step is public and lands on a one-time key. Asks the wallet to approve the pool first if needed.
      */
     shieldToken(wallet: Wallet, token: Address, amount: bigint, onStatus?: Status): Promise<Hex>;
+    /**
+     * Claim a won sealed bid straight into the private vault (v4 launches): the tokens become a note for a one-time key,
+     * so later trades can't be linked to the bid. Sent from the bidder's wallet (only the bidder can claim this way); the
+     * HYPE refund, if any, still goes to the wallet. The token's vault must exist (the keeper opens it at settlement).
+     */
+    claimPrivately(wallet: Wallet, auction: Address, bidId: bigint): Promise<{
+        txHash: Hex;
+        tokens: bigint;
+    }>;
     roundInfo(): Promise<{
         round: bigint;
         endsAt: number;

package/dist/private/client.js

@@ -1,6 +1,6 @@
 import { encodeAbiParameters, parseEventLogs, zeroAddress } from "viem";
-import { cloakMigratorAbi, cloakPairAbi, privateBatcherAbi, privateRouterAbi, shieldedPoolAbi } from "../abis.js";
-import { ACCOUNT_MESSAGE, ACCOUNT_TYPED_DATA, CloakKeys, MAIN_KEY, noteCommitment, encryptFullMemo, encryptRouterMemo, formatCloakAddress, nullifierOf, parseCloakAddress, randomField, randomKeyIndex, readMemo, } from "./crypto.js";
+import { cloakAuctionAbi, cloakMigratorAbi, cloakPairAbi, privateBatcherAbi, privateRouterAbi, shieldedPoolAbi } from "../abis.js";
+import { ACCOUNT_MESSAGE, ACCOUNT_TYPED_DATA, ROUTER_ACCOUNT_TYPED_DATA, CloakKeys, MAIN_KEY, noteCommitment, encryptFullMemo, encryptRouterMemo, formatCloakAddress, nullifierOf, parseCloakAddress, randomField, randomKeyIndex, readMemo, } from "./crypto.js";
 import { MerkleTree } from "./tree.js";
 import { MOVE_DATA_ABI, ORDER_DATA_ABI, SWAP_DATA_ABI, buildTransaction, selectNotes, splitStandard } from "./tx.js";
 /** Leaf positions per tree epoch (a pool starts a new tree after 2^20 leaves). */
@@ -11,6 +11,8 @@ const ERC20_ABI = [
     { type: "function", name: "allowance", stateMutability: "view", inputs: [{ type: "address" }, { type: "address" }], outputs: [{ type: "uint256" }] },
     { type: "function", name: "approve", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }] },
     { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }] },
+    { type: "function", name: "symbol", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { type: "function", name: "decimals", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
 ];
 const json = (v) => JSON.stringify(v, (_, x) => (typeof x === "bigint" ? x.toString() : x));
 /** POST shielded calls to a Cloak relayer (`services/keeper` serves `/relay` and `/quote`). */
@@ -96,14 +98,30 @@ export class CloakPrivate {
         this.migrator = migrator;
     }
     /**
-     * Derive the private keys from one EIP-712 signature bound to this chain and router, so a signature asked for by any
-     * other site or contract can't reproduce them. With `verify`, the wallet signs twice and the keys are refused if the
-     * two signatures differ (some smart and MPC wallets sign differently each time, which would hide earlier notes).
+     * Derive the wallet's Cloak private account from one EIP-712 signature bound to this chain (never to a contract, so
+     * the account survives every upgrade). With `verify`, the wallet signs twice and the keys are refused if the two
+     * signatures differ (some smart and MPC wallets sign differently each time, which would hide earlier notes).
      */
     static async keysFromWallet(wallet, opts) {
-        const req = { account: wallet.account, ...ACCOUNT_TYPED_DATA(opts.chainId, opts.router) };
+        return CloakPrivate.signedKeys(wallet, ACCOUNT_TYPED_DATA(opts.chainId), opts.verify);
+    }
+    /** Keys of a v2 or v3 account, bound to that deployment's router. Only needed to move an old balance across. */
+    static async routerKeysFromWallet(wallet, opts) {
+        return CloakPrivate.signedKeys(wallet, ROUTER_ACCOUNT_TYPED_DATA(opts.chainId, opts.router), false);
+    }
+    /** The keys an earlier deployment's notes were made for: v1 a plain message, v2 and v3 their router, v4 on the account. */
+    static async keysForVersion(wallet, opts) {
+        if (opts.version <= 1)
+            return CloakPrivate.legacyKeysFromWallet(wallet);
+        if (opts.version <= 3)
+            return CloakPrivate.routerKeysFromWallet(wallet, opts);
+        return CloakPrivate.keysFromWallet(wallet, opts);
+    }
+    static async signedKeys(wallet, typed, verify) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const req = { account: wallet.account, ...typed };
         const sig = await wallet.signTypedData(req);
-        if (opts.verify) {
+        if (verify) {
             const again = await wallet.signTypedData(req);
             if (again.toLowerCase() !== sig.toLowerCase()) {
                 throw new Error("This wallet gives a different signature each time, so it can't hold a Cloak private account. Use a standard wallet such as MetaMask or Rabby.");
@@ -116,20 +134,42 @@ export class CloakPrivate {
         const sig = await wallet.signMessage({ account: wallet.account, message: ACCOUNT_MESSAGE });
         return CloakKeys.fromSignature(sig);
     }
+    /**
+     * Read the router's vaults: HYPE first, then every launch market. A vault without a launch pair (USDC) is an asset,
+     * not a market, and is added to `assets` instead.
+     */
     async loadMarkets() {
         const c = { address: this.router, abi: privateRouterAbi };
-        const n = await this.publicClient.readContract({ ...c, functionName: "tokensCount" });
+        const [n, whype] = await Promise.all([
+            this.publicClient.readContract({ ...c, functionName: "tokensCount" }),
+            this.publicClient.readContract({ ...c, functionName: "whype" }),
+        ]);
+        const tokens = await Promise.all(Array.from({ length: Number(n) }, (_, i) => this.publicClient.readContract({ ...c, functionName: "tokens", args: [BigInt(i)] })));
+        const rows = await Promise.all(tokens.map((token) => Promise.all([
+            this.publicClient.readContract({ ...c, functionName: "poolOf", args: [token] }),
+            this.publicClient.readContract({ ...c, functionName: "pairOf", args: [token] }),
+        ])));
         const out = [];
-        for (let i = 0n; i < n; i++) {
-            const token = await this.publicClient.readContract({ ...c, functionName: "tokens", args: [i] });
-            const [pool, pair] = await Promise.all([
-                this.publicClient.readContract({ ...c, functionName: "poolOf", args: [token] }),
-                this.publicClient.readContract({ ...c, functionName: "pairOf", args: [token] }),
-            ]);
-            out.push({ token, pool, pair: i === 0n ? null : pair });
+        let hype;
+        for (let i = 0; i < tokens.length; i++) {
+            const [pool, pair] = rows[i];
+            const token = tokens[i];
+            if (token.toLowerCase() === whype.toLowerCase())
+                hype = { token, pool, pair: null };
+            else if (pair !== zeroAddress)
+                out.push({ token, pool, pair });
+            else if (!this.assets.some((a) => a.pool.toLowerCase() === pool.toLowerCase())) {
+                const [symbol, decimals] = await Promise.all([
+                    this.publicClient.readContract({ address: token, abi: ERC20_ABI, functionName: "symbol" }).catch(() => "?"),
+                    this.publicClient.readContract({ address: token, abi: ERC20_ABI, functionName: "decimals" }).catch(() => 18),
+                ]);
+                this.addAsset({ symbol, token, pool, decimals: Number(decimals), fromBlock: this.fromBlock });
+            }
         }
-        this.markets = out;
-        return out;
+        if (!hype)
+            throw new Error("the router has no HYPE vault");
+        this.markets = [hype, ...out];
+        return this.markets;
     }
     get hypeMarket() {
         const m = this.markets[0];
@@ -343,6 +383,29 @@ export class CloakPrivate {
             throw new Error("shield reverted");
         return hash;
     }
+    /**
+     * Claim a won sealed bid straight into the private vault (v4 launches): the tokens become a note for a one-time key,
+     * so later trades can't be linked to the bid. Sent from the bidder's wallet (only the bidder can claim this way); the
+     * HYPE refund, if any, still goes to the wallet. The token's vault must exist (the keeper opens it at settlement).
+     */
+    async claimPrivately(wallet, auction, bidId) {
+        const [tokens] = await this.publicClient.readContract({ address: auction, abi: cloakAuctionAbi, functionName: "allocationOf", args: [bidId] });
+        if (tokens === 0n)
+            throw new Error("this bid won no tokens");
+        const keyIndex = randomKeyIndex();
+        const k = await this.keys.key(keyIndex);
+        const blinding = randomField();
+        const hash = await wallet.writeContract({
+            address: auction,
+            abi: cloakAuctionAbi,
+            functionName: "claimPrivate",
+            args: [bidId, k.pubKey, blinding, encryptFullMemo(this.keys.encPub, tokens, blinding, keyIndex)],
+        });
+        const r = await this.publicClient.waitForTransactionReceipt({ hash });
+        if (r.status !== "success")
+            throw new Error("private claim reverted");
+        return { txHash: hash, tokens };
+    }
     // ───────────── batch auctions (hide trade size) ─────────────
     async roundInfo() {
         if (!this.batcher)
@@ -571,11 +634,12 @@ export class CloakPrivate {
     async migrateFrom(legacy, onStatus = () => { }, opts = {}) {
         const migrator = opts.migrator ?? this.migratorAddress();
         const moved = [];
-        const markets = await legacy.loadMarkets();
+        const markets = [...(await legacy.loadMarkets()), ...legacy.assets];
         await this.loadMarkets();
+        const here = [...this.markets, ...this.assets];
         for (const m of markets) {
-            if (!this.markets.some((x) => x.token.toLowerCase() === m.token.toLowerCase()))
-                continue; // no pool here yet
+            if (!here.some((x) => x.token.toLowerCase() === m.token.toLowerCase()))
+                continue; // no vault here yet
             for (;;) {
                 const live = (await legacy.sync(m.pool)).sort((a, b) => (a.amount > b.amount ? -1 : 1));
                 if (!live.length)

package/dist/private/crypto.d.ts

@@ -7,13 +7,31 @@ export declare const MAIN_KEY = 4294967295;
 export declare const randomField: () => bigint;
 export declare const randomKeyIndex: () => number;
 export declare function poseidon(inputs: bigint[]): Promise<bigint>;
-/** The message a wallet signs to derive its Cloak private account (deterministic for standard EOAs). */
-export declare const ACCOUNT_MESSAGE = "Cloak private account v1\n\nSigning this derives your private trading keys on Elysium. It costs nothing and does not move funds.";
 /**
- * EIP-712 request whose signature derives the private keys of a Cloak v2 account. It is bound to the chain and the
- * router, so a signature collected by another site or for another contract can't reproduce the keys.
+ * EIP-712 request whose signature derives a wallet's Cloak private account (v4 on). It is bound to the chain only, never
+ * to a contract, so the account and its `cloak:` address stay the same through every upgrade.
  */
-export declare const ACCOUNT_TYPED_DATA: (chainId: number, router: `0x${string}`) => {
+export declare const ACCOUNT_TYPED_DATA: (chainId: number) => {
+    readonly domain: {
+        readonly name: "Cloak";
+        readonly version: "4";
+        readonly chainId: number;
+    };
+    readonly types: {
+        readonly PrivateAccount: readonly [{
+            readonly name: "purpose";
+            readonly type: "string";
+        }];
+    };
+    readonly primaryType: "PrivateAccount";
+    readonly message: {
+        readonly purpose: "Derive my Cloak private account. This costs nothing and moves no funds. Only sign this on cloak.boblabs.tech.";
+    };
+};
+/** The plain message v1 accounts were derived from. Only used to move an old v1 balance. */
+export declare const ACCOUNT_MESSAGE = "Cloak private account v1\n\nSigning this derives your private trading keys on Elysium. It costs nothing and does not move funds.";
+/** The EIP-712 request v2 and v3 accounts were derived from, bound to that deployment's router. Only used to move an old balance. */
+export declare const ROUTER_ACCOUNT_TYPED_DATA: (chainId: number, router: `0x${string}`) => {
     readonly domain: {
         readonly name: "Cloak";
         readonly version: "2";

package/dist/private/crypto.js

@@ -18,13 +18,22 @@ export async function poseidon(inputs) {
     _poseidon ??= await (await import("circomlibjs")).buildPoseidon(); // loaded on first use
     return _poseidon.F.toObject(_poseidon(inputs.map((x) => BigInt(x))));
 }
-/** The message a wallet signs to derive its Cloak private account (deterministic for standard EOAs). */
-export const ACCOUNT_MESSAGE = "Cloak private account v1\n\nSigning this derives your private trading keys on Elysium. It costs nothing and does not move funds.";
 /**
- * EIP-712 request whose signature derives the private keys of a Cloak v2 account. It is bound to the chain and the
- * router, so a signature collected by another site or for another contract can't reproduce the keys.
+ * EIP-712 request whose signature derives a wallet's Cloak private account (v4 on). It is bound to the chain only, never
+ * to a contract, so the account and its `cloak:` address stay the same through every upgrade.
  */
-export const ACCOUNT_TYPED_DATA = (chainId, router) => ({
+export const ACCOUNT_TYPED_DATA = (chainId) => ({
+    domain: { name: "Cloak", version: "4", chainId },
+    types: { PrivateAccount: [{ name: "purpose", type: "string" }] },
+    primaryType: "PrivateAccount",
+    message: {
+        purpose: "Derive my Cloak private account. This costs nothing and moves no funds. Only sign this on cloak.boblabs.tech.",
+    },
+});
+/** The plain message v1 accounts were derived from. Only used to move an old v1 balance. */
+export const ACCOUNT_MESSAGE = "Cloak private account v1\n\nSigning this derives your private trading keys on Elysium. It costs nothing and does not move funds.";
+/** The EIP-712 request v2 and v3 accounts were derived from, bound to that deployment's router. Only used to move an old balance. */
+export const ROUTER_ACCOUNT_TYPED_DATA = (chainId, router) => ({
     domain: { name: "Cloak", version: "2", chainId, verifyingContract: router },
     types: { PrivateAccount: [{ name: "purpose", type: "string" }] },
     primaryType: "PrivateAccount",

package/dist/registry.d.ts

@@ -0,0 +1,46 @@
+import { type Address, type PublicClient } from "viem";
+/** One contract in CloakConfig's registry. */
+export interface RegistryEntry {
+    kind: string;
+    addr: Address;
+    version: number;
+    startBlock: bigint;
+}
+/** An earlier deployment, rebuilt from the registry: what's needed to list its launches and move its balances. */
+export interface RegistryVersion {
+    version: number;
+    router?: Address;
+    routerBlock?: bigint;
+    batcher?: Address;
+    batcherBlock?: bigint;
+    factory?: Address;
+    factoryBlock?: bigint;
+    /** Standalone vaults of that deployment, outside its router (v2's USDC vault). */
+    pools: {
+        addr: Address;
+        startBlock: bigint;
+    }[];
+}
+/** Everything Cloak has deployed on a chain, read from CloakConfig, so apps only need that one address. */
+export interface CloakRegistry {
+    config: Address;
+    entries: RegistryEntry[];
+    /** Factories whose launches the vaults may list, oldest first. */
+    launchFactories: Address[];
+    /** The current version (the newest router's). */
+    version: number;
+    vaults?: Address;
+    /** First block of the permanent vaults: scan private notes from here, whichever router is current. */
+    vaultsBlock?: bigint;
+    router: Address;
+    routerBlock: bigint;
+    batcher?: Address;
+    batcherBlock?: bigint;
+    migrator?: Address;
+    factory: Address;
+    factoryBlock: bigint;
+    /** Earlier deployments, newest first. */
+    previous: RegistryVersion[];
+}
+/** Read CloakConfig's registry. Throws if it has no router or factory yet. */
+export declare function readRegistry(publicClient: PublicClient, config: Address): Promise<CloakRegistry>;

package/dist/registry.js

@@ -0,0 +1,53 @@
+import { hexToString } from "viem";
+import { cloakConfigAbi } from "./abis.js";
+const kindOf = (k) => hexToString(k, { size: 32 }).replace(/\0+$/, "");
+/** Read CloakConfig's registry. Throws if it has no router or factory yet. */
+export async function readRegistry(publicClient, config) {
+    const c = { address: config, abi: cloakConfigAbi };
+    const [n, nf] = await Promise.all([
+        publicClient.readContract({ ...c, functionName: "registryCount" }),
+        publicClient.readContract({ ...c, functionName: "launchFactoriesCount" }),
+    ]);
+    const [rows, launchFactories] = await Promise.all([
+        Promise.all(Array.from({ length: Number(n) }, (_, i) => publicClient.readContract({ ...c, functionName: "registry", args: [BigInt(i)] }))),
+        Promise.all(Array.from({ length: Number(nf) }, (_, i) => publicClient.readContract({ ...c, functionName: "launchFactories", args: [BigInt(i)] }))),
+    ]);
+    const entries = rows.map(([kind, addr, version, startBlock]) => ({ kind: kindOf(kind), addr, version: Number(version), startBlock: BigInt(startBlock) }));
+    const newest = (kind, version) => [...entries].reverse().find((e) => e.kind === kind && (version === undefined || e.version === version));
+    const router = newest("router");
+    const factory = newest("factory");
+    if (!router || !factory)
+        throw new Error(`CloakConfig ${config} has no router or factory registered yet`);
+    const batcher = newest("batcher", router.version);
+    const versions = [...new Set(entries.map((e) => e.version))].filter((v) => v < router.version).sort((a, b) => b - a);
+    return {
+        config,
+        entries,
+        launchFactories,
+        version: router.version,
+        vaults: newest("vaults")?.addr,
+        vaultsBlock: newest("vaults")?.startBlock,
+        router: router.addr,
+        routerBlock: router.startBlock,
+        batcher: batcher?.addr,
+        batcherBlock: batcher?.startBlock,
+        migrator: newest("migrator", router.version)?.addr,
+        factory: factory.addr,
+        factoryBlock: factory.startBlock,
+        previous: versions.map((v) => {
+            const r = newest("router", v);
+            const b = newest("batcher", v);
+            const f = newest("factory", v);
+            return {
+                version: v,
+                router: r?.addr,
+                routerBlock: r?.startBlock,
+                batcher: b?.addr,
+                batcherBlock: b?.startBlock,
+                factory: f?.addr,
+                factoryBlock: f?.startBlock,
+                pools: entries.filter((e) => e.kind === "pool" && e.version === v).map((e) => ({ addr: e.addr, startBlock: e.startBlock })),
+            };
+        }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloakely/sdk",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Cloak on Elysium: sealed-bid token launches and private trading (shielded balances, private swaps, batch auctions, private sends) with on-device zero-knowledge proofs.",
   "keywords": [
     "cloak",