@cloakely/sdk 0.0.0-stage → 0.2.0

package/dist/cloak.js

@@ -0,0 +1,415 @@
+import { zeroAddress, encodeAbiParameters, keccak256, parseEventLogs, toHex, } from "viem";
+import { cloakAuctionAbi, cloakFactoryAbi, cloakPairAbi, cloakTokenAbi } from "./abis.js";
+import { drandRoundAt, sealBid, unsealBid } from "./seal.js";
+const WAD = 10n ** 18n;
+const PHASES = ["commit", "reveal", "settle", "settled"];
+/**
+ * Budget buckets: deposits are rounded up to 1, 2 or 5 × 10ⁿ wei, so the deposit only reveals the bid's order of
+ * magnitude (every bid within ~2.5× of another looks the same) at any price scale.
+ */
+export function budgetBuckets(atLeast, count = 8) {
+    const out = [];
+    let b = bucketDeposit(atLeast > 0n ? atLeast : 1n);
+    while (out.length < count) {
+        out.push(b);
+        b = nextBucket(b);
+    }
+    return out;
+}
+function nextBucket(b) {
+    const s = b.toString();
+    const lead = s[0];
+    const pow = 10n ** BigInt(s.length - 1);
+    return lead === "1" ? 2n * pow : lead === "2" ? 5n * pow : 10n * pow;
+}
+export function commitmentOf(auction, bidder, tick, quantity, salt) {
+    return keccak256(encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint16" }, { type: "uint128" }, { type: "bytes32" }], [auction, bidder, tick, quantity, salt]));
+}
+export function randomSalt() {
+    const b = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(b);
+    return toHex(b);
+}
+/** Round a required deposit up to the next 1/2/5 × 10ⁿ bucket. */
+export function bucketDeposit(cost) {
+    if (cost <= 1n)
+        return 1n;
+    const pow = 10n ** BigInt(cost.toString().length - 1);
+    for (const m of [1n, 2n, 5n, 10n])
+        if (m * pow >= cost)
+            return m * pow;
+    return 10n * pow;
+}
+/** `launches(i)` of the first CloakFactory (five fields, no vesting). */
+const LEGACY_LAUNCHES_ABI = [
+    {
+        type: "function",
+        name: "launches",
+        stateMutability: "view",
+        inputs: [{ type: "uint256" }],
+        outputs: [
+            { name: "auction", type: "address" },
+            { name: "token", type: "address" },
+            { name: "creator", type: "address" },
+            { name: "launchpad", type: "address" },
+            { name: "creatorAlloc", type: "uint256" },
+        ],
+    },
+];
+export class Cloak {
+    publicClient;
+    walletClient;
+    factory;
+    legacyFactory;
+    constructor(publicClient, walletClient, factory, 
+    /** The first deployment's factory, so its launches still list and settle. */
+    legacyFactory) {
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.factory = factory;
+        this.legacyFactory = legacyFactory;
+    }
+    wallet() {
+        if (!this.walletClient)
+            throw new Error("Cloak: a walletClient is required for this call");
+        return this.walletClient;
+    }
+    async send(hash) {
+        const r = await this.publicClient.waitForTransactionReceipt({ hash });
+        if (r.status !== "success")
+            throw new Error(`transaction reverted: ${hash}`);
+        return r;
+    }
+    // ───────────── launchpad side ─────────────
+    async createLaunch(p) {
+        if (!this.factory)
+            throw new Error("Cloak: factory address required");
+        const w = this.wallet();
+        const lock = p.lpLockUntil === undefined || p.lpLockUntil === "burn" ? 0 : p.lpLockUntil;
+        const params = {
+            creator: p.creator ?? w.account.address,
+            saleSupply: p.saleSupply,
+            lpReserve: p.lpReserve ?? p.saleSupply,
+            minPrice: p.minPrice,
+            tickSize: p.tickSize,
+            numTicks: p.numTicks ?? 100,
+            commitEnd: BigInt(p.commitEnd),
+            revealEnd: BigInt(p.revealEnd),
+            lpBps: p.lpBps ?? 5000,
+            noRevealPenaltyBps: p.noRevealPenaltyBps ?? 1000,
+            lpLockUntil: BigInt(lock),
+            tlockRound: BigInt(drandRoundAt(p.commitEnd)),
+        };
+        const txHash = await w.writeContract({
+            address: this.factory,
+            abi: cloakFactoryAbi,
+            functionName: "createLaunch",
+            args: [p.name, p.symbol, p.creatorAlloc ?? 0n, BigInt(p.creatorAlloc ? (p.creatorVestSecs ?? 90 * 86400) : 0), params, p.metadataURI ?? ""],
+        });
+        const r = await this.send(txHash);
+        const [ev] = parseEventLogs({ abi: cloakFactoryAbi, logs: r.logs, eventName: "LaunchCreated" });
+        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.
+     */
+    async listLaunches() {
+        if (!this.factory)
+            throw new Error("Cloak: factory address required");
+        const legacy = this.legacyFactory ? await this.listLegacy(this.legacyFactory) : [];
+        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 });
+        }
+        return out;
+    }
+    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 });
+        }
+        return out;
+    }
+    // ───────────── 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([
+            r.readContract({ ...c, functionName: "params" }),
+            r.readContract({ ...c, functionName: "token" }),
+            r.readContract({ ...c, functionName: "phase" }),
+            r.readContract({ ...c, functionName: "bidsCount" }),
+            r.readContract({ ...c, functionName: "revealCount" }),
+            r.readContract({ ...c, functionName: "totalDeposits" }),
+            r.readContract({ ...c, functionName: "totalDemand" }),
+            r.readContract({ ...c, functionName: "settled" }),
+            r.readContract({ ...c, functionName: "failed" }),
+            r.readContract({ ...c, functionName: "clearingTick" }),
+            r.readContract({ ...c, functionName: "clearingPrice" }),
+            r.readContract({ ...c, functionName: "sold" }),
+            r.readContract({ ...c, functionName: "raised" }),
+            r.readContract({ ...c, functionName: "pair" }),
+            // not on first-deployment auctions
+            r.readContract({ ...c, functionName: "launchFeeBps" }).catch(() => 0),
+            r.readContract({ ...c, functionName: "bidCap" }).catch(() => 0n),
+            r.readContract({ ...c, functionName: "depositCap" }).catch(() => 0n),
+            r.readContract({ ...c, functionName: "creatorOwed" }).catch(() => 0n),
+            r.readContract({ ...c, functionName: "feesOwed" }).catch(() => 0n),
+        ]);
+        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" }),
+            r.readContract({ address: token, abi: cloakTokenAbi, functionName: "symbol" }),
+        ]);
+        return {
+            address: auction,
+            token,
+            creator,
+            saleSupply,
+            lpReserve,
+            minPrice,
+            tickSize,
+            numTicks,
+            commitEnd: Number(commitEnd),
+            revealEnd: Number(revealEnd),
+            lpBps,
+            noRevealPenaltyBps,
+            lpLockUntil: Number(lpLockUntil),
+            tlockRound: Number(tlockRound),
+            phase: PHASES[phase],
+            commits: Number(commits),
+            reveals: Number(reveals),
+            totalDeposits,
+            totalDemand,
+            settled,
+            failed,
+            clearingTick,
+            clearingPrice,
+            sold,
+            raised,
+            pair,
+            tokenName,
+            tokenSymbol,
+            launchFeeBps,
+            bidCap,
+            depositCap,
+            creatorOwed,
+            feesOwed,
+        };
+    }
+    /** Revealed demand per tick (empty until the reveal phase — that is the point). */
+    async demandCurve(auction) {
+        const s = await this.getAuction(auction);
+        const curve = await this.publicClient.readContract({
+            address: auction,
+            abi: cloakAuctionAbi,
+            functionName: "demandCurve",
+        });
+        return curve.map((d, t) => ({ tick: t, price: s.minPrice + BigInt(t) * s.tickSize, demand: d }));
+    }
+    async pairPrice(pair) {
+        return this.publicClient.readContract({ address: pair, abi: cloakPairAbi, functionName: "price" });
+    }
+    // ───────────── bidder side ─────────────
+    /** Pick the tick for a max price (rounded down to a tick) and the bucketed deposit that hides the bid size. */
+    quoteBid(s, maxPrice, quantity) {
+        if (maxPrice < s.minPrice)
+            throw new Error("max price is below the auction's minimum price");
+        let tick = s.tickSize === 0n ? 0 : Number((maxPrice - s.minPrice) / s.tickSize);
+        tick = Math.min(tick, s.numTicks - 1);
+        const price = s.minPrice + BigInt(tick) * s.tickSize;
+        const cost = (price * quantity + WAD - 1n) / WAD;
+        return { tick, price, cost, deposit: bucketDeposit(cost) };
+    }
+    /**
+     * Seal and commit a bid. Only a hash and a drand-timelocked ciphertext go on-chain, so neither the sequencer nor other
+     * bidders learn the price or size. After commit closes, any keeper can decrypt and reveal it — no second visit needed.
+     */
+    async bid(auction, opts) {
+        const w = this.wallet();
+        const s = await this.getAuction(auction);
+        if (s.phase !== "commit")
+            throw new Error("commit phase is over");
+        const q = this.quoteBid(s, opts.maxPrice, opts.quantity);
+        const deposit = opts.deposit ?? q.deposit;
+        if (deposit < q.cost)
+            throw new Error("deposit is below the bid's cost");
+        const salt = randomSalt();
+        const bidder = w.account.address;
+        const commitment = commitmentOf(auction, bidder, q.tick, opts.quantity, salt);
+        const sealed = await sealBid({ auction, bidder, tick: q.tick, quantity: opts.quantity, salt }, s.tlockRound);
+        const txHash = await w.writeContract({
+            address: auction,
+            abi: cloakAuctionAbi,
+            functionName: "commit",
+            args: [commitment, sealed],
+            value: deposit,
+        });
+        const r = await this.send(txHash);
+        const [ev] = parseEventLogs({ abi: cloakAuctionAbi, logs: r.logs, eventName: "Committed" });
+        return { id: ev.args.id, auction, bidder, tick: q.tick, quantity: opts.quantity, salt, deposit, commitment, txHash };
+    }
+    async reveal(secret) {
+        const txHash = await this.wallet().writeContract({
+            address: secret.auction,
+            abi: cloakAuctionAbi,
+            functionName: "reveal",
+            args: [secret.id, secret.tick, secret.quantity, secret.salt],
+        });
+        await this.send(txHash);
+        return txHash;
+    }
+    async settle(auction) {
+        const txHash = await this.wallet().writeContract({ address: auction, abi: cloakAuctionAbi, functionName: "settle" });
+        await this.send(txHash);
+        return txHash;
+    }
+    /** Pay out a settled launch's creator proceeds, and send its launch fee to the treasury (anyone can call either). */
+    async payOut(auction) {
+        const s = await this.getAuction(auction);
+        const out = [];
+        for (const fn of [s.creatorOwed > 0n && "withdrawProceeds", s.feesOwed > 0n && "collectFees"]) {
+            if (!fn)
+                continue;
+            const h = await this.wallet().writeContract({ address: auction, abi: cloakAuctionAbi, functionName: fn });
+            await this.send(h);
+            out.push(h);
+        }
+        return out;
+    }
+    async claim(auction, ids) {
+        const txHash = await this.wallet().writeContract({
+            address: auction,
+            abi: cloakAuctionAbi,
+            functionName: "claimBatch",
+            args: [ids],
+        });
+        await this.send(txHash);
+        return txHash;
+    }
+    async bidsOf(auction, bidder, fromBlock = 0n) {
+        const logs = await this.committedLogs(auction, fromBlock);
+        const mine = logs.filter((l) => l.args.bidder.toLowerCase() === bidder.toLowerCase());
+        return Promise.all(mine.map(async (l) => {
+            const [bid, alloc] = await Promise.all([
+                this.publicClient.readContract({ address: auction, abi: cloakAuctionAbi, functionName: "getBid", args: [l.args.id] }),
+                this.publicClient.readContract({ address: auction, abi: cloakAuctionAbi, functionName: "allocationOf", args: [l.args.id] }),
+            ]);
+            return { id: l.args.id, ...bid, tokens: alloc[0], refund: alloc[1], penalty: alloc[2] };
+        }));
+    }
+    // ───────────── keeper side ─────────────
+    async committedLogs(auction, fromBlock = 0n) {
+        const latest = await this.publicClient.getBlockNumber({ cacheTime: 0 });
+        const get = (from, to) => this.publicClient.getContractEvents({
+            address: auction,
+            abi: cloakAuctionAbi,
+            eventName: "Committed",
+            strict: true,
+            fromBlock: from,
+            toBlock: to,
+        });
+        try {
+            return await get(fromBlock, latest);
+        }
+        catch {
+            // RPCs that cap eth_getLogs ranges: walk in chunks
+            const out = [];
+            const step = 10000n;
+            for (let from = fromBlock; from <= latest; from += step) {
+                const to = from + step - 1n > latest ? latest : from + step - 1n;
+                out.push(...(await get(from, to)));
+            }
+            return out;
+        }
+    }
+    /**
+     * Decrypt every sealed bid whose drand round has passed and reveal them in batches. Anyone can run this — it needs no
+     * key material, only the public beacon. Bids whose ciphertext is garbage are skipped (and get penalised at claim).
+     */
+    async revealAll(auction, opts = {}) {
+        const log = opts.log ?? (() => { });
+        const logs = await this.committedLogs(auction, opts.fromBlock ?? 0n);
+        const reveals = [];
+        for (const l of logs) {
+            const bid = await this.publicClient.readContract({
+                address: auction,
+                abi: cloakAuctionAbi,
+                functionName: "getBid",
+                args: [l.args.id],
+            });
+            if (bid.revealed)
+                continue;
+            try {
+                const p = await unsealBid(l.args.sealedBid);
+                if (p.auction.toLowerCase() !== auction.toLowerCase())
+                    throw new Error("sealed for another auction");
+                const expected = commitmentOf(auction, bid.bidder, p.tick, p.quantity, p.salt);
+                if (expected !== bid.commitment)
+                    throw new Error("ciphertext does not match commitment");
+                reveals.push({ id: l.args.id, tick: p.tick, quantity: p.quantity, salt: p.salt });
+            }
+            catch (e) {
+                log(`bid #${l.args.id}: cannot unseal (${e.message})`);
+            }
+        }
+        const size = opts.batchSize ?? 40;
+        const txs = [];
+        for (let i = 0; i < reveals.length; i += size) {
+            const txHash = await this.wallet().writeContract({
+                address: auction,
+                abi: cloakAuctionAbi,
+                functionName: "revealBatch",
+                args: [reveals.slice(i, i + size)],
+            });
+            await this.send(txHash);
+            txs.push(txHash);
+            log(`revealed ${Math.min(i + size, reveals.length)}/${reveals.length}`);
+        }
+        return { revealed: reveals.length, txs };
+    }
+    /** Claim on behalf of every bidder (tokens and refunds always go to the bidder, never the caller). */
+    async claimAll(auction, opts = {}) {
+        const logs = await this.committedLogs(auction, opts.fromBlock ?? 0n);
+        const ids = [];
+        for (const l of logs) {
+            const bid = await this.publicClient.readContract({
+                address: auction,
+                abi: cloakAuctionAbi,
+                functionName: "getBid",
+                args: [l.args.id],
+            });
+            if (!bid.claimed)
+                ids.push(l.args.id);
+        }
+        const size = opts.batchSize ?? 40;
+        const txs = [];
+        for (let i = 0; i < ids.length; i += size)
+            txs.push(await this.claim(auction, ids.slice(i, i + size)));
+        return { claimed: ids.length, txs };
+    }
+}

package/dist/deployments.d.ts

@@ -0,0 +1,27 @@
+import type { Address } from "viem";
+/** Where Cloak lives on each chain, so integrators never copy addresses by hand. */
+export interface CloakDeployment {
+    chainId: number;
+    config: Address;
+    factory: Address;
+    router: Address;
+    /** Block the router was deployed in: scan private-pool events from here. */
+    routerBlock: bigint;
+    batcher: Address;
+    migrator?: Address;
+    hypePool: Address;
+    whype: Address;
+    /** Hosted relayer (POST /relay, GET /quote). */
+    relayerUrl: string;
+    /** Hosted circuit artifacts (transaction2x2.wasm and transaction2x2_final.zkey). */
+    circuitsUrl: string;
+    /** The first deployment: its launches still list, and its private balances move here through `migrator`. */
+    legacy?: {
+        factory: Address;
+        router: Address;
+        routerBlock: bigint;
+    };
+}
+export declare const deployments: Record<number, CloakDeployment>;
+/** 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

@@ -0,0 +1,27 @@
+export const deployments = {
+    99801: {
+        chainId: 99801,
+        config: "0x9d30c7b23fa2d5c40779d3db3bb4292e18c94373",
+        factory: "0xc1fc14e84cbbd10f75dad9d91bf50f47c48757fc",
+        router: "0xd51e731467c49991496329c2b7979cb1aa220ee2",
+        routerBlock: 15856031n,
+        batcher: "0xa13ffd763a8cccfea1b868c616291723579ddb77",
+        migrator: "0xe54c02fa685f2c95e5ae98e1155547194d04d9ad",
+        hypePool: "0x4deFEC0814d11c581e5947020ac4ec41e88B55Df",
+        whype: "0xe44b27113D4b947c0B1bDf4a93878D0e115f4bdD",
+        relayerUrl: "https://cloak-keeper.onrender.com",
+        circuitsUrl: "https://cloak.boblabs.tech/circuits",
+        legacy: {
+            factory: "0x1dc1ea9837ecbd31ec74f0d558e1db1c303a7e1c",
+            router: "0xfa2574cfc3afb8f7d3a0651fa2111ff4e3d2fc41",
+            routerBlock: 10973723n,
+        },
+    },
+};
+/** The Cloak deployment on `chainId`, or an error naming the chains Cloak is on. */
+export function deploymentFor(chainId) {
+    const d = deployments[chainId];
+    if (!d)
+        throw new Error(`Cloak isn't deployed on chain ${chainId} (available: ${Object.keys(deployments).join(", ")})`);
+    return d;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./abis.js";
+export * from "./chains.js";
+export * from "./deployments.js";
+export * from "./seal.js";
+export * from "./cloak.js";
+export * from "./private/index.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./abis.js";
+export * from "./chains.js";
+export * from "./deployments.js";
+export * from "./seal.js";
+export * from "./cloak.js";
+export * from "./private/index.js";

package/dist/private/client.d.ts

@@ -0,0 +1,162 @@
+import { type Address, type Hex, type PublicClient } from "viem";
+import type { Wallet } from "../cloak.js";
+import { CloakKeys } from "./crypto.js";
+import { MerkleTree } from "./tree.js";
+import type { ProofArgs, Prover } from "./prover.js";
+import { type ExtData, type OwnedNote } from "./tx.js";
+/** A shielded call the relayer submits so the trader's wallet never appears on-chain. */
+export type RelayKind = "privateSwap" | "unshieldHype" | "transact" | "placeOrder" | "migrate";
+export interface RelayCall {
+    kind: RelayKind;
+    pool: Address;
+    proof: ProofArgs;
+    extData: ExtData;
+}
+/** What a relayer charges for one call, paid out of the pool's own token inside the proof. */
+export interface RelayQuote {
+    relayer: Address;
+    fee: bigint;
+}
+export type Submitter = ((call: RelayCall) => Promise<Hex>) & {
+    /** The relayer's fee for a call of this kind on this pool. Without it, calls carry no fee. */
+    quote?: (kind: RelayKind, pool: Address) => Promise<RelayQuote>;
+};
+export interface PrivateMarket {
+    token: Address;
+    pool: Address;
+    pair: Address | null;
+    symbol?: string;
+}
+/** POST shielded calls to a Cloak relayer (`services/keeper` serves `/relay` and `/quote`). */
+export declare function relayerSubmitter(url: string): Submitter;
+/** Submit from a wallet directly — works, but that wallet pays gas and appears as the sender. Use for tests/relayers. */
+export declare function walletSubmitter(publicClient: PublicClient, wallet: Wallet, router: Address, batcher?: Address, migrator?: Address): Submitter;
+export type Status = (msg: string) => void;
+/**
+ * Private trading for Cloak launch tokens on Elysium.
+ *
+ *   shieldHype   public HYPE → private balance (one-time key, so deposits are unlinkable)
+ *   buy / sell   private balance → launch token / back, via the PrivateRouter and the launch's CloakPair,
+ *                proven on this device and submitted by a relayer
+ *   unshield     private HYPE → any address
+ */
+export declare class CloakPrivate {
+    readonly publicClient: PublicClient;
+    readonly router: Address;
+    readonly keys: CloakKeys;
+    readonly prover: () => Promise<Prover>;
+    readonly submit: Submitter;
+    readonly fromBlock: bigint;
+    readonly batcher?: Address | undefined;
+    readonly migrator?: Address | undefined;
+    private pools;
+    markets: PrivateMarket[];
+    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).
+     */
+    static keysFromWallet(wallet: Wallet, opts: {
+        chainId: number;
+        router: Address;
+        verify?: boolean;
+    }): Promise<CloakKeys>;
+    /** Keys of the first Cloak deployment (plain signed message). Only needed to move an old balance across. */
+    static legacyKeysFromWallet(wallet: Wallet): Promise<CloakKeys>;
+    loadMarkets(): Promise<PrivateMarket[]>;
+    get hypeMarket(): PrivateMarket;
+    market(token: Address): PrivateMarket;
+    private state;
+    /** Pull new leaves from the pool's events, trial-decrypt them, and refresh spent flags. */
+    sync(pool: Address): Promise<OwnedNote[]>;
+    balance(pool: Address): Promise<bigint>;
+    /** The most a single relayed call of this kind can move from `pool`: the balance minus the relayer's fee. */
+    maxSpendable(pool: Address, kind?: RelayKind): Promise<bigint>;
+    /** The Merkle tree of one epoch (default: the epoch the given notes live in, else the newest). */
+    private tree;
+    treeFor(pool: Address, inputs: OwnedNote[]): Promise<MerkleTree>;
+    /** The relayer's fee for this call (0 when submitting from a wallet). */
+    relayFee(kind: RelayKind, pool: Address): Promise<RelayQuote>;
+    /** What a withdrawal of `amount` from `pool` delivers after the protocol's withdrawal fee. */
+    afterFee(pool: Address, amount: bigint): Promise<bigint>;
+    private changeOutput;
+    dummy(): Promise<{
+        dummyPubKey: bigint;
+        dummyMemo: (b: bigint) => `0x${string}`;
+    }>;
+    /**
+     * Get 1–2 notes (from one tree epoch) covering `target`, merging notes privately first when the balance is spread
+     * across many. Each merge is a relayed transaction and pays the relayer's fee from the merged notes.
+     */
+    private inputsFor;
+    /** Public HYPE → private balance. This one step is public (your wallet deposits); everything after is not. */
+    shieldHype(wallet: Wallet, amount: bigint): Promise<Hex>;
+    roundInfo(): Promise<{
+        round: bigint;
+        endsAt: number;
+        roundSecs: number;
+    }>;
+    /**
+     * Batched private buy/sell. The amount is split into standard-size orders (1, 2, 5 × 10ⁿ), each placed from the
+     * private balance by the relayer into the current round. When the round ends, buys and sells cross at the pool's
+     * mid-price and only the net trades through the pool; outputs arrive as private notes. Observers can't tell how
+     * much any one trader moved. Any remainder that isn't a standard size stays in your private balance.
+     */
+    batch(token: Address, side: "buy" | "sell", amount: bigint, opts?: {
+        maxOrders?: number;
+        onStatus?: Status;
+    }): Promise<{
+        orders: {
+            id: bigint;
+            size: bigint;
+            round: bigint;
+            txHash: Hex;
+        }[];
+        rest: bigint;
+    }>;
+    quote(token: Address, side: "buy" | "sell", amountIn: bigint): Promise<bigint>;
+    /** Private buy: spend private HYPE, receive private tokens. `slippageBps` defaults to 1%. */
+    buy(token: Address, hypeIn: bigint, opts?: {
+        slippageBps?: number;
+        onStatus?: Status;
+    }): Promise<{
+        txHash: `0x${string}`;
+        expectedOut: bigint;
+        minOut: bigint;
+        relayerFee: bigint;
+    }>;
+    /** Private sell: spend private tokens, receive private HYPE. */
+    sell(token: Address, tokensIn: bigint, opts?: {
+        slippageBps?: number;
+        onStatus?: Status;
+    }): Promise<{
+        txHash: `0x${string}`;
+        expectedOut: bigint;
+        minOut: bigint;
+        relayerFee: bigint;
+    }>;
+    private swap;
+    /** Private HYPE → native HYPE at `to` (use a fresh address to stay unlinkable). */
+    unshieldHype(to: Address, amount: bigint, onStatus?: Status): Promise<Hex>;
+    /** Your receiving address for private transfers. */
+    address(): Promise<string>;
+    /**
+     * Private transfer inside a pool: sender, recipient and amount all stay hidden.
+     * `token` = a launch token, or the WHYPE address / hypeMarket.token for HYPE.
+     */
+    send(token: Address, to: string, amount: bigint, onStatus?: Status): Promise<Hex>;
+    /** Private launch tokens → any address. */
+    unshieldToken(token: Address, to: Address, amount: bigint, onStatus?: Status): Promise<Hex>;
+    /**
+     * 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.
+     */
+    migrateFrom(legacy: CloakPrivate, onStatus?: Status): Promise<{
+        token: Address;
+        amount: bigint;
+        txHash: Hex;
+    }[]>;
+    private migratorAddress;
+}