@cloakely/sdk 0.4.0 → 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. */
@@ -218,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";
@@ -830,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";
@@ -892,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";
@@ -1183,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, index: i, 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, index: i });
-        }
-        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

@@ -28,6 +28,10 @@ export interface CloakDeployment {
     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;
@@ -52,6 +56,8 @@ 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;
 /**

package/dist/deployments.js

@@ -1,7 +1,7 @@
 import { privateRouterAbi } from "./abis.js";
 import { readRegistry } from "./registry.js";
 export const deployments = {
-    // Cloak v4 (Oct 31), the permanent vaults: deployments/elysium-testnet-v4.json. CloakConfig's registry lists all of it;
+    // 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,
@@ -9,8 +9,11 @@ export const deployments = {
         config: "0x9fdf166f0671166148ea98cdd3ef0118d256167f",
         vaults: "0x24bc1d369aab3a2d741a48f8cac1af5dfd9f3d43",
         vaultsBlock: 19485039n,
-        factory: "0xa88df63d7d44acc66052e5cbe5ba9503bf940993",
-        factoryBlock: 19484794n,
+        // 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",
@@ -54,6 +57,10 @@ export const deployments = {
         ],
     },
 };
+/** 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];
@@ -81,6 +88,7 @@ export async function liveDeployment(publicClient, base) {
         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,

package/dist/registry.d.ts

@@ -39,6 +39,8 @@ export interface CloakRegistry {
     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[];
 }

package/dist/registry.js

@@ -34,6 +34,7 @@ export async function readRegistry(publicClient, config) {
         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);

package/package.json

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