@cloakely/sdk 0.3.1 → 0.5.0

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,48 @@
+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 factories of the current version (a factory added next to the first), newest first. */
+    earlierFactories: Address[];
+    /** 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,54 @@
+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,
+        earlierFactories: entries.filter((e) => e.kind === "factory" && e.version === factory.version && e.addr !== factory.addr).reverse().map((e) => e.addr),
+        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.5.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",