@cloakely/sdk 0.8.2 → 0.8.3

package/dist/cloak.d.ts

@@ -60,8 +60,12 @@ export interface AuctionState {
     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. */
+    /** The launch's Uniswap pool: a V2 pool (token / WHYPE), or for a v4 launch its CloakV4Market. Zero for a CloakPair. */
     uniPair: Address;
+    /** Which market the launch opens: a Uniswap v4 pool with Cloak's hook, a Uniswap V2 pool, or (earlier launches) a CloakPair. */
+    pool: "v4" | "v2" | "cloak";
+    /** For a v4 launch: the hook that seeds and looks after its pool. */
+    hook?: Address;
     /** The LP is locked forever and the creator earns its trading fees (see `creatorFees`). */
     creatorFees: boolean;
     tokenName: string;
@@ -115,6 +119,8 @@ export declare class Cloak {
         txHash: Hex;
         block: bigint;
     }>;
+    /** Whether this factory's launches may lock LP until a date (false for Uniswap v4 launches). */
+    timedLocks(): Promise<boolean>;
     /**
      * 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.

package/dist/cloak.js

@@ -1,5 +1,5 @@
 import { zeroAddress, encodeAbiParameters, keccak256, parseEventLogs, toHex, } from "viem";
-import { cloakAuctionAbi, cloakFactoryAbi, cloakFeeLockerAbi, cloakPairAbi, cloakTokenAbi } from "./abis.js";
+import { cloakAuctionAbi, cloakFactoryAbi, cloakFeeLockerAbi, cloakPairAbi, cloakTokenAbi, cloakV4HookAbi } from "./abis.js";
 /** `lpLockUntil` for "locked forever, the creator earns the pool's trading fees". */
 export const LOCK_FOREVER_FEES = 2n ** 64n - 1n;
 import { drandRoundAt, sealBid, unsealBid } from "./seal.js";
@@ -91,6 +91,8 @@ export class Cloak {
             throw new Error("Cloak: factory address required");
         const w = this.wallet();
         const lock = p.lpLockUntil === undefined || p.lpLockUntil === "burn" ? 0n : p.lpLockUntil === "fees" ? LOCK_FOREVER_FEES : BigInt(p.lpLockUntil);
+        if (lock !== 0n && lock !== LOCK_FOREVER_FEES && !(await this.timedLocks()))
+            throw new Error("Launches from this factory open a Uniswap v4 pool, whose liquidity stays locked: choose \"burn\" or \"fees\" (locked forever, trading fees to the creator), not a lock date.");
         const params = {
             creator: p.creator ?? w.account.address,
             saleSupply: p.saleSupply,
@@ -115,6 +117,12 @@ export class Cloak {
         const [ev] = parseEventLogs({ abi: cloakFactoryAbi, logs: r.logs, eventName: "LaunchCreated" });
         return { auction: ev.args.auction, token: ev.args.token, txHash, block: r.blockNumber };
     }
+    /** Whether this factory's launches may lock LP until a date (false for Uniswap v4 launches). */
+    async timedLocks() {
+        if (!this.factory)
+            return true;
+        return this.publicClient.readContract({ address: this.factory, abi: cloakFactoryAbi, functionName: "timedLocks" }).catch(() => true);
+    }
     /**
      * 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.
@@ -174,6 +182,9 @@ export class Cloak {
             r.readContract({ ...c, functionName: "uniPair" }).catch(() => zeroAddress),
             r.readContract({ ...c, functionName: "creatorFees" }).catch(() => false),
         ]);
+        // a v4 launch's seeder is CloakV4Hook, the only seeder that says it can't hand LP back after a timed lock
+        const seeder = await r.readContract({ ...c, functionName: "seeder" }).catch(() => zeroAddress);
+        const v4 = seeder !== zeroAddress && (await r.readContract({ address: seeder, abi: cloakV4HookAbi, functionName: "timedLocks" }).then((t) => t === false, () => false));
         const [creator, saleSupply, lpReserve, minPrice, tickSize, numTicks, commitEnd, revealEnd, lpBps, noRevealPenaltyBps, lpLockUntil, tlockRound] = params;
         const [tokenName, tokenSymbol] = await Promise.all([
             r.readContract({ address: token, abi: cloakTokenAbi, functionName: "name" }),
@@ -207,7 +218,10 @@ export class Cloak {
             raised,
             pair,
             uniPair,
-            creatorFees,
+            pool: v4 ? "v4" : uniPair !== zeroAddress ? "v2" : "cloak",
+            ...(v4 ? { hook: seeder } : {}),
+            // a v4 launch "locked forever" pays its creator through the hook rather than the V2 fee locker
+            creatorFees: creatorFees || (v4 && BigInt(lpLockUntil) === LOCK_FOREVER_FEES),
             tokenName,
             tokenSymbol,
             launchFeeBps,
@@ -223,6 +237,18 @@ export class Cloak {
      */
     async creatorFees(auction) {
         const c = { address: auction, abi: cloakAuctionAbi };
+        const s = await this.getAuction(auction);
+        if (s.pool === "v4") {
+            if (!s.creatorFees || !s.hook || s.uniPair === zeroAddress)
+                return null;
+            // what collectFees would pay right now, without sending anything
+            const [{ result }, launch] = await Promise.all([
+                this.publicClient.simulateContract({ address: s.hook, abi: cloakV4HookAbi, functionName: "collectFees", args: [s.token] }),
+                this.publicClient.readContract({ address: s.hook, abi: cloakV4HookAbi, functionName: "launchOf", args: [s.token] }),
+            ]);
+            const [h, t] = result;
+            return { locker: s.hook, position: 0n, beneficiary: launch.feeTo, claimableLp: h + t > 0n ? 1n : 0n, tokens: t, whype: h };
+        }
         const on = await this.publicClient.readContract({ ...c, functionName: "creatorFees" }).catch(() => false);
         if (!on)
             return null;
@@ -249,6 +275,9 @@ export class Cloak {
             throw new Error("this launch has no creator fees");
         if (f.claimableLp === 0n)
             throw new Error("no fees earned yet");
+        const s = await this.getAuction(auction);
+        if (s.pool === "v4")
+            return this.send(await this.wallet().writeContract({ address: f.locker, abi: cloakV4HookAbi, functionName: "collectFees", args: [s.token] })).then((r) => r.transactionHash);
         return this.send(await this.wallet().writeContract({ address: f.locker, abi: cloakFeeLockerAbi, functionName: "claim", args: [f.position] })).then((r) => r.transactionHash);
     }
     /** Revealed demand per tick (empty until the reveal phase — that is the point). */

package/dist/deployments.d.ts

@@ -34,6 +34,10 @@ export interface CloakDeployment {
     firstFactoryBlock?: bigint;
     /** CloakSeeder: opens each settled launch's market (a Uniswap V2 pool where the chain has one). */
     seeder?: Address;
+    /** Uniswap v4's PoolManager (on testnet, Cloak's deployment of Uniswap's exact build; on mainnet, Uniswap's own). */
+    poolManager?: Address;
+    /** CloakV4Hook: seeds and looks after every v4 launch's pool. */
+    v4Hook?: Address;
     /** CloakFeeLocker: holds "locked forever" LP and pays its trading fees to the creator. */
     feeLocker?: Address;
     router: Address;

package/dist/deployments.js

@@ -9,13 +9,17 @@ export const deployments = {
         config: "0x9fdf166f0671166148ea98cdd3ef0118d256167f",
         vaults: "0x24bc1d369aab3a2d741a48f8cac1af5dfd9f3d43",
         vaultsBlock: 19485039n,
-        // the creator-fee launch factory (Nov 2): every launch opens a Uniswap V2 pool at its clearing price, and its LP can
-        // be locked forever with the trading fees going to the creator
-        factory: "0xd179bad69715f4bd4796dd7a4103be143fba02ad",
-        factoryBlock: 21312271n,
-        earlierFactories: ["0xeac84944f5a8343edf49cde8ef74d71f4908a656", "0xa88df63d7d44acc66052e5cbe5ba9503bf940993"],
+        // the Uniswap v4 launch factory (Nov 3): every launch opens a v4 pool (native HYPE / token) at its clearing price
+        // through CloakV4Hook, which keeps the liquidity forever, pays trading fees to the creator and charges an anti-snipe
+        // fee for 5 minutes after listing. The PoolManager is Uniswap's, built byte for byte like mainnet's.
+        factory: "0x1b0072684e98d9e23018e2d107ed8166ef84c077",
+        factoryBlock: 22661576n,
+        // the creator-fee V2 factory (Nov 2), then v4's first two
+        earlierFactories: ["0xd179bad69715f4bd4796dd7a4103be143fba02ad", "0xeac84944f5a8343edf49cde8ef74d71f4908a656", "0xa88df63d7d44acc66052e5cbe5ba9503bf940993"],
         firstFactoryBlock: 19484794n,
-        seeder: "0x633aa82b806dafc0ae4c84418d23f3726139a88d",
+        seeder: "0xcdc11340c5ce0b3dcbd9a5e8f7838e8a8bbaaa80",
+        poolManager: "0x51027076df8416e42ea8438b27a0c433d9662e68",
+        v4Hook: "0xcdc11340c5ce0b3dcbd9a5e8f7838e8a8bbaaa80",
         feeLocker: "0x3b74062a72b16f9a221d63515518a635414501d8",
         // the shared launch-token vault (Nov 2, testnet experiment): new Uniswap launches keep their private balances here
         shared: "0x0ce2ecb0195e07899377e3d7b01e927ab3f87610",

package/dist/private/shared.d.ts

@@ -103,7 +103,10 @@ export declare class SharedVaultClient {
     private quote;
     /** 1–2 notes of `token` covering `target`, combining notes first (a relayed send to yourself) when needed. */
     private inputsFor;
-    /** Expected output of a swap through `token`'s Uniswap market (0.3% fee), before slippage. */
+    /**
+     * Expected output of a swap through `token`'s market, before slippage. The market prices it at its own current fee:
+     * 0.3% on a Uniswap V2 pool, and on a v4 pool whatever the hook charges now (higher just after listing, then 0.3%).
+     */
     quoteSwap(token: Address, side: "buy" | "sell", amountIn: bigint): Promise<bigint>;
     /** Wallet tokens → a private note on a one-time key. This step is public (the wallet deposits). */
     shield(wallet: Wallet, token: Address, amount: bigint, onStatus?: Status): Promise<Hex>;

package/dist/private/shared.js

@@ -260,7 +260,10 @@ export class SharedVaultClient {
         }
         throw new Error("too many notes to combine");
     }
-    /** Expected output of a swap through `token`'s Uniswap market (0.3% fee), before slippage. */
+    /**
+     * Expected output of a swap through `token`'s market, before slippage. The market prices it at its own current fee:
+     * 0.3% on a Uniswap V2 pool, and on a v4 pool whatever the hook charges now (higher just after listing, then 0.3%).
+     */
     async quoteSwap(token, side, amountIn) {
         const m = this.info(token).market;
         const [rH, rT] = await Promise.all([
@@ -268,8 +271,7 @@ export class SharedVaultClient {
             this.pub.readContract({ address: m, abi: cloakPairAbi, functionName: "reserveToken" }),
         ]);
         const [rIn, rOut] = side === "buy" ? [rH, rT] : [rT, rH];
-        const a = amountIn * 997n;
-        return (a * rOut) / (rIn * 1000n + a);
+        return this.pub.readContract({ address: m, abi: cloakPairAbi, functionName: "getAmountOut", args: [amountIn, rIn, rOut] });
     }
     // ───────────── public → private ─────────────
     /** Wallet tokens → a private note on a one-time key. This step is public (the wallet deposits). */

package/package.json

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