@cloakely/sdk 0.3.1 → 0.5.0

package/dist/cloak.d.ts

@@ -53,7 +53,10 @@ export interface AuctionState {
     clearingPrice: bigint;
     sold: bigint;
     raised: bigint;
+    /** The market Cloak trades: a CloakV2Market in front of a Uniswap V2 pool, or (earlier launches) a CloakPair. */
     pair: Address;
+    /** The launch's Uniswap V2 pool (token / WHYPE), tradable and tracked everywhere. Zero for a CloakPair market. */
+    uniPair: Address;
     tokenName: string;
     tokenSymbol: string;
     /** Launch fee on a successful raise, fixed when the auction was created. */
@@ -117,6 +120,7 @@ export declare class Cloak {
         creatorAlloc: bigint;
         vesting: Address;
         factory: Address;
+        index: bigint;
         legacy?: boolean;
     }[]>;
     private listLegacy;
@@ -217,8 +221,15 @@ export declare class Cloak {
             readonly name: "config_";
             readonly type: "address";
             readonly internalType: "contract CloakConfig";
+        }, {
+            readonly name: "seeder_";
+            readonly type: "address";
+            readonly internalType: "contract IMarketSeeder";
         }];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "receive";
+        readonly stateMutability: "payable";
     }, {
         readonly type: "function";
         readonly name: "DEAD";
@@ -341,6 +352,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";
@@ -807,6 +840,16 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "seeder";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "contract IMarketSeeder";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "settle";
@@ -869,6 +912,16 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "uniPair";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "withdrawProceeds";
@@ -915,6 +968,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";
@@ -1150,6 +1213,26 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "UniswapMarket";
+        readonly inputs: readonly [{
+            readonly name: "uniPair";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "market";
+            readonly type: "address";
+            readonly indexed: false;
+            readonly internalType: "address";
+        }, {
+            readonly name: "lpShares";
+            readonly type: "uint256";
+            readonly indexed: false;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
     }], "Committed", true, bigint, bigint>>;
     /**
      * Decrypt every sealed bid whose drand round has passed and reveal them in batches. Anyone can run this — it needs no

package/dist/cloak.js

@@ -120,47 +120,34 @@ export class Cloak {
     async listLaunches() {
         if (!this.factory)
             throw new Error("Cloak: factory address required");
-        const legacy = [];
-        for (const f of this.legacyFactories)
-            legacy.push(...(await this.listLegacy(f)));
-        return [...(await this.listCurrent()), ...legacy];
+        // every factory, and every launch in it, read at once (a multicall client folds them into a few requests)
+        const [current, ...legacy] = await Promise.all([this.listCurrent(), ...this.legacyFactories.map((f) => this.listLegacy(f))]);
+        return [...current, ...legacy.flat()];
     }
     async listLegacy(factory) {
         const n = await this.publicClient.readContract({ address: factory, abi: cloakFactoryAbi, functionName: "launchesCount" });
-        const out = [];
-        for (let i = 0n; i < n; i++) {
+        return Promise.all(Array.from({ length: Number(n) }, async (_, k) => {
+            const i = BigInt(k);
             // 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 });
-        }
-        return out;
+            return { auction, token, creator, launchpad, creatorAlloc, vesting: (six?.[5] ?? zeroAddress), factory, index: i, legacy: true };
+        }));
     }
     async listCurrent() {
-        if (!this.factory)
-            throw new Error("Cloak: factory address required");
-        const n = await this.publicClient.readContract({
-            address: this.factory,
-            abi: cloakFactoryAbi,
-            functionName: "launchesCount",
-        });
-        const out = [];
-        for (let i = 0n; i < n; i++) {
-            const [auction, token, creator, launchpad, creatorAlloc, vesting] = await this.publicClient.readContract({
-                address: this.factory,
-                abi: cloakFactoryAbi,
-                functionName: "launches",
-                args: [i],
-            });
-            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting, factory: this.factory });
-        }
-        return out;
+        const factory = this.factory;
+        const n = await this.publicClient.readContract({ address: factory, abi: cloakFactoryAbi, functionName: "launchesCount" });
+        return Promise.all(Array.from({ length: Number(n) }, async (_, k) => {
+            const index = BigInt(k);
+            const [auction, token, creator, launchpad, creatorAlloc, vesting] = await this.publicClient.readContract({ address: factory, abi: cloakFactoryAbi, functionName: "launches", args: [index] });
+            return { auction, token, creator, launchpad, creatorAlloc, vesting, factory, index };
+        }));
     }
     // ───────────── reads ─────────────
     async getAuction(auction) {
         const c = { address: auction, abi: cloakAuctionAbi };
         const r = this.publicClient;
-        const [params, token, phase, commits, reveals, totalDeposits, totalDemand, settled, failed, clearingTick, clearingPrice, sold, raised, pair, launchFeeBps, bidCap, depositCap, creatorOwed, feesOwed] = await Promise.all([
+        const [params, token, phase, commits, reveals, totalDeposits, totalDemand, settled, failed, clearingTick, clearingPrice, sold, raised, pair, launchFeeBps, bidCap, depositCap, creatorOwed, feesOwed, uniPair] = await Promise.all([
             r.readContract({ ...c, functionName: "params" }),
             r.readContract({ ...c, functionName: "token" }),
             r.readContract({ ...c, functionName: "phase" }),
@@ -181,6 +168,8 @@ export class Cloak {
             r.readContract({ ...c, functionName: "depositCap" }).catch(() => 0n),
             r.readContract({ ...c, functionName: "creatorOwed" }).catch(() => 0n),
             r.readContract({ ...c, functionName: "feesOwed" }).catch(() => 0n),
+            // launches from the Uniswap factory on
+            r.readContract({ ...c, functionName: "uniPair" }).catch(() => zeroAddress),
         ]);
         const [creator, saleSupply, lpReserve, minPrice, tickSize, numTicks, commitEnd, revealEnd, lpBps, noRevealPenaltyBps, lpLockUntil, tlockRound] = params;
         const [tokenName, tokenSymbol] = await Promise.all([
@@ -214,6 +203,7 @@ export class Cloak {
             sold,
             raised,
             pair,
+            uniPair,
             tokenName,
             tokenSymbol,
             launchFeeBps,

package/dist/deployments.d.ts

@@ -1,28 +1,42 @@
-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;
+    /** Earlier factories of this same deployment (newest first): their launches still list, settle and trade. */
+    earlierFactories?: Address[];
+    /** Block of this deployment's first factory: scan its launches' bids from here (defaults to `factoryBlock`). */
+    firstFactoryBlock?: bigint;
     router: Address;
     /** 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;
@@ -42,5 +56,12 @@ export interface CloakDeployment {
     previous?: PreviousDeployment[];
 }
 export declare const deployments: Record<number, CloakDeployment>;
+/** Every factory before `d.factory` whose launches should still list, newest first: this deployment's, then earlier ones'. */
+export declare function legacyFactories(d: CloakDeployment): Address[];
 /** 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,51 @@
+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, plus the Uniswap launch factory (Nov 2): 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,
+        // the Uniswap launch factory (Nov 2): every launch opens a Uniswap V2 pool at its clearing price
+        factory: "0xeac84944f5a8343edf49cde8ef74d71f4908a656",
+        factoryBlock: 21221250n,
+        earlierFactories: ["0xa88df63d7d44acc66052e5cbe5ba9503bf940993"],
+        firstFactoryBlock: 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,11 +53,14 @@ export const deployments = {
                 router: "0xfa2574cfc3afb8f7d3a0651fa2111ff4e3d2fc41",
                 routerBlock: 10973723n,
                 batcher: "0xf6582cc5a84fccf74e571e652fb7b603a2c25812",
-                migrator: "0x5f3d82a6aa1b20ba9d0f58a98d1c4933c115a0da",
             },
         ],
     },
 };
+/** Every factory before `d.factory` whose launches should still list, newest first: this deployment's, then earlier ones'. */
+export function legacyFactories(d) {
+    return [...(d.earlierFactories ?? []), ...(d.previous ?? []).map((p) => p.factory)].filter((f) => f && !/^0x0{40}$/i.test(f));
+}
 /** The Cloak deployment on `chainId`, or an error naming the chains Cloak is on. */
 export function deploymentFor(chainId) {
     const d = deployments[chainId];
@@ -45,3 +68,46 @@ 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,
+        earlierFactories: reg.earlierFactories.length ? reg.earlierFactories : base.earlierFactories,
+        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)