@cloakely/sdk 0.2.6 → 0.3.1

package/dist/cloak.d.ts

@@ -91,11 +91,12 @@ export declare class Cloak {
     readonly publicClient: PublicClient;
     readonly walletClient?: Wallet | undefined;
     readonly factory?: Address | undefined;
-    /** The first deployment's factory, so its launches still list and settle. */
-    readonly legacyFactory?: Address | undefined;
+    /** Earlier deployments' factories (newest first), so their launches still list and settle. */
+    readonly legacyFactory?: (Address | readonly Address[]) | undefined;
     constructor(publicClient: PublicClient, walletClient?: Wallet | undefined, factory?: Address | undefined, 
-    /** The first deployment's factory, so its launches still list and settle. */
-    legacyFactory?: Address | undefined);
+    /** Earlier deployments' factories (newest first), so their launches still list and settle. */
+    legacyFactory?: (Address | readonly Address[]) | undefined);
+    private get legacyFactories();
     private wallet;
     private send;
     createLaunch(p: LaunchParams): Promise<{
@@ -105,8 +106,8 @@ export declare class Cloak {
         block: bigint;
     }>;
     /**
-     * Every launch, newest factory first. Launches from `legacyFactory` (the first deployment) are included with
-     * `legacy: true`; they have no vesting contract.
+     * Every launch, newest factory first. Launches from the `legacyFactory` list (earlier deployments) are included with
+     * `legacy: true`; the first deployment's have no vesting contract.
      */
     listLaunches(): Promise<{
         auction: Address;
@@ -115,6 +116,7 @@ export declare class Cloak {
         launchpad: Address;
         creatorAlloc: bigint;
         vesting: Address;
+        factory: Address;
         legacy?: boolean;
     }[]>;
     private listLegacy;
@@ -722,6 +724,20 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "refundOwed";
+        readonly inputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "releaseLP";
@@ -859,6 +875,16 @@ export declare class Cloak {
         readonly inputs: readonly [];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "withdrawRefund";
+        readonly inputs: readonly [{
+            readonly name: "to";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "event";
         readonly name: "Claimed";
@@ -1039,6 +1065,41 @@ export declare class Cloak {
             readonly internalType: "uint256";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "RefundHeld";
+        readonly inputs: readonly [{
+            readonly name: "bidder";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+            readonly indexed: false;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "RefundWithdrawn";
+        readonly inputs: readonly [{
+            readonly name: "bidder";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "to";
+            readonly type: "address";
+            readonly indexed: false;
+            readonly internalType: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+            readonly indexed: false;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
     }, {
         readonly type: "event";
         readonly name: "Revealed";

package/dist/cloak.js

@@ -62,13 +62,16 @@ export class Cloak {
     factory;
     legacyFactory;
     constructor(publicClient, walletClient, factory, 
-    /** The first deployment's factory, so its launches still list and settle. */
+    /** Earlier deployments' factories (newest first), so their launches still list and settle. */
     legacyFactory) {
         this.publicClient = publicClient;
         this.walletClient = walletClient;
         this.factory = factory;
         this.legacyFactory = legacyFactory;
     }
+    get legacyFactories() {
+        return this.legacyFactory === undefined ? [] : typeof this.legacyFactory === "string" ? [this.legacyFactory] : this.legacyFactory;
+    }
     wallet() {
         if (!this.walletClient)
             throw new Error("Cloak: a walletClient is required for this call");
@@ -111,26 +114,25 @@ export class Cloak {
         return { auction: ev.args.auction, token: ev.args.token, txHash, block: r.blockNumber };
     }
     /**
-     * Every launch, newest factory first. Launches from `legacyFactory` (the first deployment) are included with
-     * `legacy: true`; they have no vesting contract.
+     * Every launch, newest factory first. Launches from the `legacyFactory` list (earlier deployments) are included with
+     * `legacy: true`; the first deployment's have no vesting contract.
      */
     async listLaunches() {
         if (!this.factory)
             throw new Error("Cloak: factory address required");
-        const legacy = this.legacyFactory ? await this.listLegacy(this.legacyFactory) : [];
+        const legacy = [];
+        for (const f of this.legacyFactories)
+            legacy.push(...(await this.listLegacy(f)));
         return [...(await this.listCurrent()), ...legacy];
     }
     async listLegacy(factory) {
         const n = await this.publicClient.readContract({ address: factory, abi: cloakFactoryAbi, functionName: "launchesCount" });
         const out = [];
         for (let i = 0n; i < n; i++) {
-            const [auction, token, creator, launchpad, creatorAlloc] = await this.publicClient.readContract({
-                address: factory,
-                abi: LEGACY_LAUNCHES_ABI,
-                functionName: "launches",
-                args: [i],
-            });
-            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting: zeroAddress, legacy: true });
+            // 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;
     }
@@ -150,7 +152,7 @@ export class Cloak {
                 functionName: "launches",
                 args: [i],
             });
-            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting });
+            out.push({ auction, token, creator, launchpad, creatorAlloc, vesting, factory: this.factory });
         }
         return out;
     }

package/dist/deployments.d.ts

@@ -1,13 +1,28 @@
 import type { Address } from "viem";
+/** An earlier deployment on the same chain: its launches still list, and `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 })`). */
+    migrator?: Address;
+}
 /** 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). */
+    version: number;
     config: Address;
     factory: Address;
+    /** Block the factory was deployed in: scan launch events from here. */
+    factoryBlock: 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). */
     migrator?: Address;
     hypePool: Address;
     whype: Address;
@@ -23,12 +38,8 @@ export interface CloakDeployment {
         decimals: number;
         fromBlock: bigint;
     }[];
-    /** The first deployment: its launches still list, and its private balances move here through `migrator`. */
-    legacy?: {
-        factory: Address;
-        router: Address;
-        routerBlock: bigint;
-    };
+    /** Earlier deployments, newest first. */
+    previous?: PreviousDeployment[];
 }
 export declare const deployments: Record<number, CloakDeployment>;
 /** The Cloak deployment on `chainId`, or an error naming the chains Cloak is on. */

package/dist/deployments.js

@@ -1,13 +1,16 @@
 export const deployments = {
+    // Cloak v3 (Oct 30): deployments/elysium-testnet-v3.json
     99801: {
         chainId: 99801,
+        version: 3,
         config: "0x9d30c7b23fa2d5c40779d3db3bb4292e18c94373",
-        factory: "0xc1fc14e84cbbd10f75dad9d91bf50f47c48757fc",
-        router: "0xd51e731467c49991496329c2b7979cb1aa220ee2",
-        routerBlock: 15856031n,
-        batcher: "0xa13ffd763a8cccfea1b868c616291723579ddb77",
-        migrator: "0xe54c02fa685f2c95e5ae98e1155547194d04d9ad",
-        hypePool: "0x4deFEC0814d11c581e5947020ac4ec41e88B55Df",
+        factory: "0xd0f4aacf339f07211a9155194925b2f94e250e29",
+        factoryBlock: 19096456n,
+        router: "0x78319bee7c21ca411166acc67c750aca10280e86",
+        routerBlock: 19096485n,
+        batcher: "0x9902d86c5be81f6c6ce059acf4c89193d06069c4",
+        migrator: "0x295f816aa6dac1901bd793120248d8f9cbbd5eec",
+        hypePool: "0x786886a61Dd77581ef03787c5939fC44B004064d",
         whype: "0xe44b27113D4b947c0B1bDf4a93878D0e115f4bdD",
         relayerUrl: "https://cloak-keeper.onrender.com",
         circuitsUrl: "https://cloak.boblabs.tech/circuits",
@@ -15,11 +18,24 @@ export const deployments = {
             // Elysium testnet USDC (bridged from Circle's USDC on HyperEVM): private sends and withdrawals
             { symbol: "USDC", token: "0x7D29d8047B905000459c0E80c34a26CeedcB47b2", pool: "0x61de30970e3c53665ce5a89323284e7ab379fa08", decimals: 6, fromBlock: 18329466n },
         ],
-        legacy: {
-            factory: "0x1dc1ea9837ecbd31ec74f0d558e1db1c303a7e1c",
-            router: "0xfa2574cfc3afb8f7d3a0651fa2111ff4e3d2fc41",
-            routerBlock: 10973723n,
-        },
+        previous: [
+            {
+                version: 2,
+                factory: "0xc1fc14e84cbbd10f75dad9d91bf50f47c48757fc",
+                router: "0xd51e731467c49991496329c2b7979cb1aa220ee2",
+                routerBlock: 15856031n,
+                batcher: "0xa13ffd763a8cccfea1b868c616291723579ddb77",
+                migrator: "0x295f816aa6dac1901bd793120248d8f9cbbd5eec",
+            },
+            {
+                version: 1,
+                factory: "0x1dc1ea9837ecbd31ec74f0d558e1db1c303a7e1c",
+                router: "0xfa2574cfc3afb8f7d3a0651fa2111ff4e3d2fc41",
+                routerBlock: 10973723n,
+                batcher: "0xf6582cc5a84fccf74e571e652fb7b603a2c25812",
+                migrator: "0x5f3d82a6aa1b20ba9d0f58a98d1c4933c115a0da",
+            },
+        ],
     },
 };
 /** The Cloak deployment on `chainId`, or an error naming the chains Cloak is on. */

package/dist/private/client.d.ts

@@ -11,6 +11,8 @@ export interface RelayCall {
     pool: Address;
     proof: ProofArgs;
     extData: ExtData;
+    /** For `migrate`: the migrator from the pool's deployment into this one (the proof pays out to it). */
+    migrator?: Address;
 }
 /** What a relayer charges for one call, paid out of the pool's own token inside the proof. */
 export interface RelayQuote {
@@ -173,9 +175,12 @@ export declare class CloakPrivate {
     /**
      * Move every private balance `legacy` (a client on the earlier router, with the earlier keys) can see into this
      * deployment, note by note, through `CloakMigrator`. Each move is one relayed transaction: the old proof withdraws to
-     * the migrator, which deposits the same amount here as a new note for one of this account's one-time keys.
+     * the migrator, which deposits the same amount here as a new note for one of this account's one-time keys. Each
+     * earlier deployment has its own migrator into this one: pass it as `opts.migrator` (default: `this.migrator`).
      */
-    migrateFrom(legacy: CloakPrivate, onStatus?: Status): Promise<{
+    migrateFrom(legacy: CloakPrivate, onStatus?: Status, opts?: {
+        migrator?: Address;
+    }): Promise<{
         token: Address;
         amount: bigint;
         txHash: Hex;

package/dist/private/client.js

@@ -36,10 +36,11 @@ export function relayerSubmitter(url) {
 export function walletSubmitter(publicClient, wallet, router, batcher, migrator) {
     return async (call) => {
         // viem cannot infer the nested tuple types through the union; the shapes match the ABI exactly.
-        if (call.kind === "migrate" && !migrator)
+        const mig = call.migrator ?? migrator;
+        if (call.kind === "migrate" && !mig)
             throw new Error("no migrator configured");
         const req = call.kind === "migrate"
-            ? { address: migrator, abi: cloakMigratorAbi, functionName: "migrate", args: [call.pool, call.proof, call.extData] }
+            ? { address: mig, abi: cloakMigratorAbi, functionName: "migrate", args: [call.pool, call.proof, call.extData] }
             : call.kind === "placeOrder"
                 ? { address: batcher, abi: privateBatcherAbi, functionName: "placeOrder", args: [call.pool, call.proof, call.extData] }
                 : call.kind === "privateSwap"
@@ -50,9 +51,11 @@ export function walletSubmitter(publicClient, wallet, router, batcher, migrator)
         if (call.kind === "placeOrder" && !batcher)
             throw new Error("no batcher configured");
         // Pad the estimate: state can change between estimation and inclusion (e.g. an order landing in a new batch round
-        // writes fresh storage, ~60k more gas). Unused gas is refunded.
+        // writes fresh storage, ~60k more gas). Unused gas is refunded. Estimate from the address, not the local account:
+        // with a local account viem estimates twice, the second time capped at the first result, so a round turning over
+        // in between made that second estimate run out of gas.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const est = await publicClient.estimateContractGas({ ...req, account: wallet.account });
+        const est = await publicClient.estimateContractGas({ ...req, account: wallet.account.address });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const hash = await wallet.writeContract({ ...req, gas: (est * 13n) / 10n + 100000n });
         const r = await publicClient.waitForTransactionReceipt({ hash });
@@ -562,9 +565,11 @@ export class CloakPrivate {
     /**
      * Move every private balance `legacy` (a client on the earlier router, with the earlier keys) can see into this
      * deployment, note by note, through `CloakMigrator`. Each move is one relayed transaction: the old proof withdraws to
-     * the migrator, which deposits the same amount here as a new note for one of this account's one-time keys.
+     * the migrator, which deposits the same amount here as a new note for one of this account's one-time keys. Each
+     * earlier deployment has its own migrator into this one: pass it as `opts.migrator` (default: `this.migrator`).
      */
-    async migrateFrom(legacy, onStatus = () => { }) {
+    async migrateFrom(legacy, onStatus = () => { }, opts = {}) {
+        const migrator = opts.migrator ?? this.migratorAddress();
         const moved = [];
         const markets = await legacy.loadMarkets();
         await this.loadMarkets();
@@ -577,7 +582,7 @@ export class CloakPrivate {
                     break;
                 const inputs = live.slice(0, 2);
                 const total = inputs.reduce((a, x) => a + x.amount, 0n);
-                const q = await legacy.relayFee("migrate", m.pool);
+                const q = await this.relayFee("migrate", m.pool); // quoted by the relayer that will submit it
                 if (total <= q.fee)
                     break; // dust that costs more to move than it's worth
                 const amount = total - q.fee;
@@ -595,13 +600,13 @@ export class CloakPrivate {
                     extAmount: -amount,
                     fee: q.fee,
                     relayer: q.relayer,
-                    recipient: this.migratorAddress(),
+                    recipient: migrator,
                     data,
                     ...(await legacy.dummy()),
                     prover: await this.prover(),
                 });
                 onStatus(`Moving ${m.symbol ?? "balance"}: relaying…`);
-                const txHash = await this.submit({ kind: "migrate", pool: m.pool, proof, extData });
+                const txHash = await this.submit({ kind: "migrate", pool: m.pool, proof, extData, migrator });
                 await this.publicClient.waitForTransactionReceipt({ hash: txHash });
                 moved.push({ token: m.token, amount, txHash });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloakely/sdk",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "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",