@cloakely/sdk 0.7.0 → 0.7.1

package/dist/deployments.d.ts

@@ -48,6 +48,8 @@ export interface CloakDeployment {
     sharedBlock?: bigint;
     /** SharedRouter: private buys, sells and hidden sends for the shared vault. */
     sharedRouter?: Address;
+    /** SharedBatcher: batch rounds for the shared vault's tokens. */
+    sharedBatcher?: Address;
     hypePool: Address;
     whype: Address;
     /** Hosted relayer (POST /relay, GET /quote). */

package/dist/deployments.js

@@ -21,6 +21,7 @@ export const deployments = {
         shared: "0x0ce2ecb0195e07899377e3d7b01e927ab3f87610",
         sharedBlock: 21426599n,
         sharedRouter: "0xe2a0769a5acbd987c1b6725247c56187a112dc7e",
+        sharedBatcher: "0xdc725bdeb0fca923bf2dc65232f54463b0f80820",
         router: "0x343ab9a7aac93cee28321410510ea24417cc6386",
         routerBlock: 19485063n,
         batcher: "0xc69e4bca18020ae93bc9f17093985bfb139a3203",
@@ -103,6 +104,7 @@ export async function liveDeployment(publicClient, base) {
         shared: reg.shared ?? base.shared,
         sharedBlock: reg.sharedBlock ?? base.sharedBlock,
         sharedRouter: reg.sharedRouter ?? base.sharedRouter,
+        sharedBatcher: reg.sharedBatcher ?? base.sharedBatcher,
         hypePool,
         whype,
         previous: reg.previous.length

package/dist/private/shared.d.ts

@@ -39,7 +39,7 @@ export declare const SHARED_SWAP_DATA_ABI: readonly [{
         readonly type: "uint64";
     }];
 }];
-export type SharedRelayKind = "sharedTransact" | "sharedBuy" | "sharedSell" | "sharedSend";
+export type SharedRelayKind = "sharedTransact" | "sharedBuy" | "sharedSell" | "sharedSend" | "sharedOrderBuy" | "sharedOrderSell";
 export interface SharedRelayCall {
     kind: SharedRelayKind;
     /** The shared-vault proof (or, for sharedBuy, the HYPE vault proof). */
@@ -56,7 +56,7 @@ export type SharedSubmitter = ((call: SharedRelayCall) => Promise<Hex>) & {
 /** POST shared-vault calls to a Cloak relayer (`services/keeper` serves `/relay-shared` and `/quote-shared`). */
 export declare function sharedRelayerSubmitter(url: string): SharedSubmitter;
 /** Submit shared-vault calls from a wallet (that wallet pays gas and appears as the sender). For tests and relayers. */
-export declare function sharedWalletSubmitter(priv: CloakPrivate, wallet: Wallet, vault: Address, router: Address): SharedSubmitter;
+export declare function sharedWalletSubmitter(priv: CloakPrivate, wallet: Wallet, vault: Address, router: Address, batcher?: Address): SharedSubmitter;
 export interface SharedToken {
     token: Address;
     market: Address;
@@ -69,12 +69,16 @@ export declare class SharedVaultClient {
     readonly prover: () => Promise<Prover>;
     readonly submit: SharedSubmitter;
     readonly fromBlock: bigint;
+    /** SharedBatcher: batch rounds that hide trade size for these tokens. */
+    readonly batcher?: Address | undefined;
     tokens: SharedToken[];
     private leaves;
     private scannedUpTo;
     private notes;
     private nextBlock;
-    constructor(priv: CloakPrivate, vault: Address, router: Address, prover: () => Promise<Prover>, submit: SharedSubmitter, fromBlock?: bigint);
+    constructor(priv: CloakPrivate, vault: Address, router: Address, prover: () => Promise<Prover>, submit: SharedSubmitter, fromBlock?: bigint, 
+    /** SharedBatcher: batch rounds that hide trade size for these tokens. */
+    batcher?: Address | undefined);
     private get pub();
     /** Every token admitted to the vault, with its Uniswap market. */
     loadTokens(): Promise<SharedToken[]>;
@@ -124,4 +128,27 @@ export declare class SharedVaultClient {
     send(token: Address, amount: bigint, to: string, onStatus?: Status): Promise<Hex>;
     /** Private `token` → `to` (any address). Names the token, as any withdrawal must. */
     unshield(token: Address, amount: bigint, to: Address, onStatus?: Status): Promise<Hex>;
+    roundInfo(): Promise<{
+        round: bigint;
+        endsAt: number;
+        roundSecs: number;
+    }>;
+    /**
+     * Batched private buy or sell of a shared-vault token: the amount is split into standard sizes (1, 2, 5 × 10ⁿ), each
+     * placed by the relayer into the current round. When the round ends, buys and sells cross at the pool's average price
+     * and only the net trades on Uniswap; outputs arrive as private notes. Nobody can tell how much any one trader moved.
+     * Any remainder that isn't a standard size stays in the 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;
+    }>;
 }

package/dist/private/shared.js

@@ -1,9 +1,9 @@
-import { encodeAbiParameters, formatEther, keccak256, zeroAddress } from "viem";
-import { cloakAuctionAbi, cloakPairAbi, sharedRouterAbi, sharedVaultAbi } from "../abis.js";
+import { encodeAbiParameters, formatEther, keccak256, parseEventLogs, zeroAddress } from "viem";
+import { cloakAuctionAbi, cloakPairAbi, sharedBatcherAbi, sharedRouterAbi, sharedVaultAbi } from "../abis.js";
 import { Cloak } from "../cloak.js";
 import { MAIN_KEY, encryptFullMemo, encryptRouterMemo, noteCommitment, nullifierOf, parseCloakAddress, randomField, randomKeyIndex, readMemo } from "./crypto.js";
 import { MerkleTree } from "./tree.js";
-import { buildTransaction, selectNotes } from "./tx.js";
+import { ORDER_DATA_ABI, buildTransaction, selectNotes, splitStandard } from "./tx.js";
 /**
  * The shared launch-token vault (testnet experiment): one private vault for every Cloak launch token that opens on
  * Uniswap from now on, next to the single-token vaults of HYPE and USDC.
@@ -52,15 +52,21 @@ export function sharedRelayerSubmitter(url) {
     return submit;
 }
 /** Submit shared-vault calls from a wallet (that wallet pays gas and appears as the sender). For tests and relayers. */
-export function sharedWalletSubmitter(priv, wallet, vault, router) {
+export function sharedWalletSubmitter(priv, wallet, vault, router, batcher) {
     return async (call) => {
-        const req = call.kind === "sharedTransact"
-            ? { address: vault, abi: sharedVaultAbi, functionName: "transact", args: [call.proof, call.extData] }
-            : call.kind === "sharedBuy"
-                ? { address: router, abi: sharedRouterAbi, functionName: "buy", args: [call.proof, call.extData] }
-                : call.kind === "sharedSell"
-                    ? { address: router, abi: sharedRouterAbi, functionName: "sell", args: [call.proof, call.extData] }
-                    : { address: router, abi: sharedRouterAbi, functionName: "send", args: [call.proof, call.extData, call.feeProof, call.feeExtData] };
+        if ((call.kind === "sharedOrderBuy" || call.kind === "sharedOrderSell") && !batcher)
+            throw new Error("no shared batcher configured");
+        const req = call.kind === "sharedOrderBuy"
+            ? { address: batcher, abi: sharedBatcherAbi, functionName: "placeBuy", args: [call.proof, call.extData] }
+            : call.kind === "sharedOrderSell"
+                ? { address: batcher, abi: sharedBatcherAbi, functionName: "placeSell", args: [call.proof, call.extData] }
+                : call.kind === "sharedTransact"
+                    ? { address: vault, abi: sharedVaultAbi, functionName: "transact", args: [call.proof, call.extData] }
+                    : call.kind === "sharedBuy"
+                        ? { address: router, abi: sharedRouterAbi, functionName: "buy", args: [call.proof, call.extData] }
+                        : call.kind === "sharedSell"
+                            ? { address: router, abi: sharedRouterAbi, functionName: "sell", args: [call.proof, call.extData] }
+                            : { address: router, abi: sharedRouterAbi, functionName: "send", args: [call.proof, call.extData, call.feeProof, call.feeExtData] };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const est = await priv.publicClient.estimateContractGas({ ...req, account: wallet.account.address });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -86,18 +92,22 @@ export class SharedVaultClient {
     prover;
     submit;
     fromBlock;
+    batcher;
     tokens = [];
     leaves = [];
     scannedUpTo = 0;
     notes = [];
     nextBlock;
-    constructor(priv, vault, router, prover, submit, fromBlock = 0n) {
+    constructor(priv, vault, router, prover, submit, fromBlock = 0n, 
+    /** SharedBatcher: batch rounds that hide trade size for these tokens. */
+    batcher) {
         this.priv = priv;
         this.vault = vault;
         this.router = router;
         this.prover = prover;
         this.submit = submit;
         this.fromBlock = fromBlock;
+        this.batcher = batcher;
         this.nextBlock = fromBlock;
     }
     get pub() {
@@ -456,4 +466,93 @@ export class SharedVaultClient {
         onStatus("Relaying…");
         return this.submit({ kind: "sharedTransact", proof, extData });
     }
+    // ───────────── batch rounds (hide trade size) ─────────────
+    async roundInfo() {
+        if (!this.batcher)
+            throw new Error("no shared batcher configured");
+        const c = { address: this.batcher, abi: sharedBatcherAbi };
+        const [round, roundSecs] = await Promise.all([this.pub.readContract({ ...c, functionName: "currentRound" }), this.pub.readContract({ ...c, functionName: "roundSecs" })]);
+        return { round, roundSecs: Number(roundSecs), endsAt: Number((round + 1n) * roundSecs) };
+    }
+    /**
+     * Batched private buy or sell of a shared-vault token: the amount is split into standard sizes (1, 2, 5 × 10ⁿ), each
+     * placed by the relayer into the current round. When the round ends, buys and sells cross at the pool's average price
+     * and only the net trades on Uniswap; outputs arrive as private notes. Nobody can tell how much any one trader moved.
+     * Any remainder that isn't a standard size stays in the private balance.
+     */
+    async batch(token, side, amount, opts = {}) {
+        if (!this.batcher)
+            throw new Error("no shared batcher configured");
+        if (!this.tokens.length)
+            await this.loadTokens();
+        this.info(token);
+        const onStatus = opts.onStatus ?? (() => { });
+        const asset = asNum(token);
+        const kind = side === "buy" ? "sharedOrderBuy" : "sharedOrderSell";
+        const hypePool = this.priv.hypeMarket.pool;
+        const maxOrders = opts.maxOrders ?? 6;
+        let { sizes, rest } = splitStandard(amount, maxOrders);
+        const fee = (await this.quote(kind, token)).fee;
+        if (fee > 0n) {
+            const have = side === "buy" ? await this.priv.balance(hypePool) : await this.balance(token);
+            const reserve = (n) => (fee * BigInt(n) * 5n) / 4n + fee;
+            if (sizes.reduce((a, x) => a + x, 0n) + reserve(sizes.length) > have) {
+                // every order pays its own relayer fee: use fewer orders when that's all the balance can pay for
+                let fit = false;
+                for (let n = maxOrders; n >= 1 && !fit; n--) {
+                    const budget = have - reserve(n);
+                    if (budget <= 0n)
+                        continue;
+                    ({ sizes } = splitStandard(budget < amount ? budget : amount, n));
+                    fit = sizes.length > 0;
+                }
+                if (!fit)
+                    throw new Error("insufficient private balance");
+                rest = amount - sizes.reduce((a, x) => a + x, 0n);
+            }
+        }
+        if (sizes.length === 0)
+            throw new Error("amount too small for a standard-size order");
+        const placed = [];
+        for (let i = 0; i < sizes.length; i++) {
+            const size = sizes[i];
+            onStatus(`Order ${i + 1}/${sizes.length}: syncing…`);
+            const q = await this.quote(kind, token);
+            let inputs;
+            try {
+                inputs = side === "buy" ? await this.priv.inputsFor(hypePool, size + q.fee, onStatus) : await this.inputsFor(token, size + q.fee, onStatus);
+            }
+            catch (e) {
+                if (!placed.length || !/insufficient private balance/.test(String(e.message)))
+                    throw e;
+                rest += sizes.slice(i).reduce((a, x) => a + x, 0n);
+                break;
+            }
+            const keyIndex = randomKeyIndex();
+            const outKey = await this.priv.keys.key(keyIndex);
+            const outBlinding = randomField();
+            const data = encodeAbiParameters(ORDER_DATA_ABI, [{ token, outPubKey: outKey.pubKey, outBlinding, outMemo: encryptRouterMemo(this.priv.keys.encPub, outBlinding, keyIndex) }]);
+            const change = inputs.reduce((a, x) => a + x.amount, 0n) - size - q.fee;
+            onStatus(`Order ${i + 1}/${sizes.length}: proving on this device…`);
+            const common = {
+                inputs,
+                outputs: change > 0n ? [await this.priv.changeOutput(change)] : [],
+                extAmount: -size,
+                fee: q.fee,
+                relayer: q.relayer,
+                recipient: this.batcher,
+                data,
+                ...(await this.priv.dummy()),
+            };
+            const { proof, extData } = side === "buy"
+                ? await buildTransaction({ ...common, tree: await this.priv.treeFor(hypePool, inputs), prover: await this.priv.prover() })
+                : await buildTransaction({ ...common, tree: await this.tree(inputs[0].epoch ?? 0), asset, publicAsset: asset, prover: await this.prover() });
+            onStatus(`Order ${i + 1}/${sizes.length}: relaying…`);
+            const txHash = await this.submit({ kind, proof, extData });
+            const rc = await this.pub.waitForTransactionReceipt({ hash: txHash });
+            const ev = parseEventLogs({ abi: sharedBatcherAbi, logs: rc.logs, eventName: "OrderPlaced" })[0];
+            placed.push({ id: ev.args.id, size, round: ev.args.round, txHash });
+        }
+        return { orders: placed, rest };
+    }
 }

package/dist/registry.d.ts

@@ -42,6 +42,8 @@ export interface CloakRegistry {
     sharedBlock?: bigint;
     /** SharedRouter: private buys, sells and hidden sends for the shared vault. */
     sharedRouter?: Address;
+    /** SharedBatcher: batch rounds for the shared vault's tokens. */
+    sharedBatcher?: Address;
     factory: Address;
     factoryBlock: bigint;
     /** Earlier factories of the current version (a factory added next to the first), newest first. */

package/dist/registry.js

@@ -35,6 +35,7 @@ export async function readRegistry(publicClient, config) {
         shared: newest("shared")?.addr,
         sharedBlock: newest("shared")?.startBlock,
         sharedRouter: newest("sharedRouter")?.addr,
+        sharedBatcher: newest("sharedBatcher")?.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),

package/package.json

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