@cloakely/sdk 0.8.3 → 0.8.5

package/dist/deployments.d.ts

@@ -60,6 +60,8 @@ export interface CloakDeployment {
     dropFactoryBlock?: bigint;
     /** CloakSpotBook: WL spot sales on top of drops; winners name the wallets to whitelist. */
     spotBook?: Address;
+    /** CloakEscrowDropFactory: sealed auctions of NFTs that already exist (listed with the drops). */
+    escrowDropFactory?: Address;
     hypePool: Address;
     whype: Address;
     /** Hosted relayer (POST /relay, GET /quote). */

package/dist/deployments.js

@@ -25,18 +25,20 @@ export const deployments = {
         shared: "0x0ce2ecb0195e07899377e3d7b01e927ab3f87610",
         sharedBlock: 21426599n,
         sharedRouter: "0xe2a0769a5acbd987c1b6725247c56187a112dc7e",
-        sharedBatcher: "0xdc725bdeb0fca923bf2dc65232f54463b0f80820",
+        sharedBatcher: "0x11598b35fabc90fdd45d8a77ac41e2057c32ea14",
         // sealed NFT drops (Nov 3): GTD, then a sealed auction with the creator's price as the floor and a WL bid boost
         dropFactory: "0x2afb7d9a5baa02a2d72a7c761521fc66dce9d783",
         dropFactoryBlock: 22329730n,
         spotBook: "0x91806d96814cc205d4b642e280023a1c7b361fc8",
+        escrowDropFactory: "0x5f3efbfd5d15440947abfbfce7f2fcfffff71079",
         router: "0x343ab9a7aac93cee28321410510ea24417cc6386",
         routerBlock: 19485063n,
-        batcher: "0xc69e4bca18020ae93bc9f17093985bfb139a3203",
+        // batchers replaced Nov 6: the crossing price stays within 2% of the price when a round opened
+        batcher: "0x54a503b0683af40aa3427b99292018f4d045d43f",
         migrator: "0x86c5d8035224493f10938aaa07b179be316dadf4",
         hypePool: "0x3ACB22829bb422446caaDd8546e65ab530A53031",
         whype: "0xe44b27113D4b947c0B1bDf4a93878D0e115f4bdD",
-        relayerUrl: "https://cloak-keeper.onrender.com",
+        relayerUrl: "https://keeper.boblabs.tech",
         circuitsUrl: "https://cloak.boblabs.tech/circuits",
         assets: [
             // Elysium testnet USDC (bridged from Circle's USDC on HyperEVM): private sends and withdrawals

package/dist/drops.d.ts

@@ -18,6 +18,102 @@ export declare const DROP_MAX_PER_BID = 20;
 export declare const DROP_MAX_SUPPLY = 10000;
 /** Most entries one GTD or WL list can hold (the lists travel in one transaction). */
 export declare const DROP_LIST_MAX = 2000;
+/** Most bytes a drop's published details (images, links, lists) can take: CloakDropFactory.MAX_DETAILS. */
+export declare const DROP_MAX_DETAILS = 96000;
+/** Most existing NFTs one escrow drop can auction (they all move in when it's created). */
+export declare const ESCROW_MAX_TOKENS = 500;
+declare const ERC721_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "ownerOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "isApprovedForAll";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "setApprovalForAll";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "bool";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURI";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenOfOwnerByIndex";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }, {
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "supportsInterface";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes4";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+export { ERC721_ABI as erc721Abi };
 /** How long the keeper has to open the bids at most. Settlement doesn't wait for it once every bid is open. */
 export declare const DROP_DEFAULT_REVEAL_SECS = 1800;
 /** A WL list entry, as the drop hashes it. */
@@ -33,9 +129,23 @@ export interface GtdEntry {
     wallet: Address;
     spots: number;
 }
+export interface DropLinks {
+    website?: string;
+    x?: string;
+    discord?: string;
+    telegram?: string;
+}
+/** Keep only https links, at most 200 characters each. */
+export declare function cleanLinks(l: unknown): DropLinks | undefined;
 /** What a drop publishes about itself at creation (the DropDetails event). */
 export interface DropDetails {
     image?: string;
+    /** A wide banner for the drop page (an https:, ipfs: or small data: image). */
+    banner?: string;
+    /** Where the collection lives online. Only https links are kept. */
+    links?: DropLinks;
+    /** A category shown with the collection, like Art or PFP. */
+    category?: string;
     description?: string;
     gtd?: GtdEntry[];
     wl?: Address[];
@@ -72,12 +182,52 @@ export interface CreateDropOptions {
      * as every bid is open, so a long window only matters if the keeper is down; a bid still sealed at its end loses 10%. */
     revealSecs?: number;
     image?: string;
+    /** A wide banner for the drop page (an https:, ipfs: or small data: image). */
+    banner?: string;
+    /** Where the collection lives online. Only https links are kept. */
+    links?: DropLinks;
+    /** A category shown with the collection, like Art or PFP. */
+    category?: string;
     description?: string;
     /** A WL spot sale: published with the drop so its pages and metadata say so. */
     spots?: {
         partner: string;
     };
 }
+/** An auction of NFTs that already exist (CloakEscrowDrop): the tokens move into the drop when it's created. */
+export interface CreateEscrowDropOptions {
+    /** The ERC-721 collection the tokens belong to. */
+    collection: Address;
+    /** The token ids to auction, owned by the caller (1 to 500). */
+    tokenIds: bigint[];
+    /** The auction's name, like "ELYMPUS treasury auction". */
+    name: string;
+    symbol: string;
+    floor: bigint;
+    tickSize?: bigint;
+    numTicks?: number;
+    maxPerBid?: number;
+    wl?: {
+        list: Address[];
+        boostBps: number;
+    };
+    biddingSecs: number;
+    revealSecs?: number;
+    image?: string;
+    banner?: string;
+    links?: DropLinks;
+    category?: string;
+    description?: string;
+}
+/** Where an escrow drop's tokens come from. */
+export interface DropEscrow {
+    collection: Address;
+    tokenIds: bigint[];
+    /** How many of them the drop holds right now. */
+    held: number;
+    /** Unsold tokens already returned to the owner. */
+    returned: number;
+}
 export type DropPhase = "gtd" | "bidding" | "reveal" | "settle" | "numbering" | "settled";
 export interface DropState {
     address: Address;
@@ -113,6 +263,8 @@ export interface DropState {
     wlPrice: bigint;
     tieSupply: number;
     tieDemand: number;
+    /** Set for an auction of existing NFTs (CloakEscrowDrop). */
+    escrow?: DropEscrow;
 }
 export interface DropBid {
     id: bigint;
@@ -135,9 +287,14 @@ export declare class CloakDrops {
     readonly factory: Address;
     /** First block to read the factory's and drops' events from. */
     readonly fromBlock: bigint;
+    /** CloakEscrowDropFactory: auctions of NFTs that already exist, listed next to the drops. */
+    readonly escrowFactory?: Address | undefined;
     constructor(publicClient: PublicClient, walletClient: Wallet | undefined, factory: Address, 
     /** First block to read the factory's and drops' events from. */
-    fromBlock?: bigint);
+    fromBlock?: bigint, 
+    /** CloakEscrowDropFactory: auctions of NFTs that already exist, listed next to the drops. */
+    escrowFactory?: Address | undefined);
+    private get factories();
     /** Many reads in one multicall where the chain has multicall3, else one by one (a local chain). */
     private reads;
     private wallet;
@@ -152,6 +309,30 @@ export declare class CloakDrops {
     /** A drop's published details: its image, description and the lists behind its roots. */
     details(drop: Address): Promise<DropDetails>;
     get(drop: Address): Promise<DropState>;
+    /** Where an escrow drop's tokens come from, or undefined for a drop that mints its own. */
+    escrowOf(drop: Address): Promise<DropEscrow | undefined>;
+    /** The token ids a bid won in an escrow drop (once settled and numbered). */
+    tokensOf(drop: Address, bidId: bigint): Promise<bigint[]>;
+    /**
+     * Auction NFTs that already exist. Needs the escrow factory. Checks the caller owns every token, approves the
+     * factory for the collection if it isn't yet (one transaction), then creates the auction, which moves every token
+     * into it. Returns the drop's address.
+     */
+    createEscrow(o: CreateEscrowDropOptions): Promise<{
+        drop: Address;
+        txHash: Hex;
+        approvalTx?: Hex;
+    }>;
+    /**
+     * The token ids of `collection` a wallet holds, from the collection's Transfer events (works for any ERC-721, no
+     * enumeration needed). Capped at `max`.
+     */
+    ownedTokens(collection: Address, owner: Address, opts?: {
+        max?: number;
+        fromBlock?: bigint;
+    }): Promise<bigint[]>;
+    /** The block a contract was deployed in, by binary search on its code (0 if the node can't tell). */
+    private deployBlock;
     /** The bid level for a price: the highest level at or below it (bids snap down, never up). */
     static tickFor(s: Pick<DropState, "floor" | "tickSize" | "numTicks">, price: bigint): number;
     static priceAt(s: Pick<DropState, "floor" | "tickSize">, tick: number): bigint;

package/dist/drops.js

@@ -11,7 +11,7 @@
  * DropDetails event, so anyone can rebuild a proof; a list that doesn't match the root proves nothing.
  */
 import { encodeAbiParameters, getAddress, isAddress, keccak256, toHex } from "viem";
-import { cloakDropAbi, cloakDropFactoryAbi } from "./abis.js";
+import { cloakDropAbi, cloakDropFactoryAbi, cloakEscrowDropAbi, cloakEscrowDropFactoryAbi } from "./abis.js";
 import { commitmentOf } from "./cloak.js";
 import { drandRoundAt, drandRoundTime, sealBid, unsealBid } from "./seal.js";
 export const DROP_BPS = 10000n;
@@ -20,6 +20,22 @@ export const DROP_MAX_PER_BID = 20;
 export const DROP_MAX_SUPPLY = 10_000;
 /** Most entries one GTD or WL list can hold (the lists travel in one transaction). */
 export const DROP_LIST_MAX = 2_000;
+/** Most bytes a drop's published details (images, links, lists) can take: CloakDropFactory.MAX_DETAILS. */
+export const DROP_MAX_DETAILS = 96_000;
+/** Most existing NFTs one escrow drop can auction (they all move in when it's created). */
+export const ESCROW_MAX_TOKENS = 500;
+const ERC721_ABI = [
+    { type: "function", name: "ownerOf", stateMutability: "view", inputs: [{ type: "uint256" }], outputs: [{ type: "address" }] },
+    { type: "function", name: "isApprovedForAll", stateMutability: "view", inputs: [{ type: "address" }, { type: "address" }], outputs: [{ type: "bool" }] },
+    { type: "function", name: "setApprovalForAll", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "bool" }], outputs: [] },
+    { type: "function", name: "tokenURI", stateMutability: "view", inputs: [{ type: "uint256" }], outputs: [{ type: "string" }] },
+    { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { type: "function", name: "symbol", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+    { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }] },
+    { type: "function", name: "tokenOfOwnerByIndex", stateMutability: "view", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "uint256" }] },
+    { type: "function", name: "supportsInterface", stateMutability: "view", inputs: [{ type: "bytes4" }], outputs: [{ type: "bool" }] },
+];
+export { ERC721_ABI as erc721Abi };
 /** How long the keeper has to open the bids at most. Settlement doesn't wait for it once every bid is open. */
 export const DROP_DEFAULT_REVEAL_SECS = 1_800;
 // ───────────────────────────── Merkle lists ─────────────────────────────
@@ -59,6 +75,20 @@ export function merkleTree(leaves) {
         },
     };
 }
+const LINK_KEYS = ["website", "x", "discord", "telegram"];
+/** Keep only https links, at most 200 characters each. */
+export function cleanLinks(l) {
+    if (!l || typeof l !== "object")
+        return undefined;
+    const out = {};
+    for (const k of LINK_KEYS) {
+        const v = l[k];
+        if (typeof v === "string" && /^https:\/\/[^\s"<>]+$/.test(v.trim()) && v.trim().length <= 200)
+            out[k] = v.trim();
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+const imageOk = (v) => typeof v === "string" && /^(https:\/\/|ipfs:\/\/|data:image\/(png|jpeg|webp|gif);base64,)/.test(v);
 const PHASES = ["gtd", "bidding", "reveal", "settle", "numbering", "settled"];
 // ───────────────────────────── client ─────────────────────────────
 export class CloakDrops {
@@ -66,13 +96,20 @@ export class CloakDrops {
     walletClient;
     factory;
     fromBlock;
+    escrowFactory;
     constructor(publicClient, walletClient, factory, 
     /** First block to read the factory's and drops' events from. */
-    fromBlock = 0n) {
+    fromBlock = 0n, 
+    /** CloakEscrowDropFactory: auctions of NFTs that already exist, listed next to the drops. */
+    escrowFactory) {
         this.publicClient = publicClient;
         this.walletClient = walletClient;
         this.factory = factory;
         this.fromBlock = fromBlock;
+        this.escrowFactory = escrowFactory;
+    }
+    get factories() {
+        return this.escrowFactory ? [this.factory, this.escrowFactory] : [this.factory];
     }
     /** Many reads in one multicall where the chain has multicall3, else one by one (a local chain). */
     async reads(contracts) {
@@ -95,10 +132,13 @@ export class CloakDrops {
     }
     /** Every drop the factory made, newest last. */
     async list() {
-        const n = Number(await this.publicClient.readContract({ address: this.factory, abi: cloakDropFactoryAbi, functionName: "dropsCount" }));
-        if (!n)
-            return [];
-        return (await this.reads(Array.from({ length: n }, (_, i) => ({ address: this.factory, abi: cloakDropFactoryAbi, functionName: "drops", args: [BigInt(i)] }))));
+        const out = [];
+        for (const f of this.factories) {
+            const n = Number(await this.publicClient.readContract({ address: f, abi: cloakDropFactoryAbi, functionName: "dropsCount" }));
+            if (n)
+                out.push(...(await this.reads(Array.from({ length: n }, (_, i) => ({ address: f, abi: cloakDropFactoryAbi, functionName: "drops", args: [BigInt(i)] })))));
+        }
+        return out;
     }
     /** Create a drop. The caller is its creator. Returns the drop's address. */
     async create(o) {
@@ -144,12 +184,16 @@ export class CloakDrops {
             gtdRoot: merkleTree(gtdList.map((e) => gtdLeaf(e.wallet, e.spots))).root,
             wlRoot: merkleTree(wlList.map(wlLeaf)).root,
         };
-        const details = { v: 1, ...(o.image ? { image: o.image } : {}), ...(o.description ? { description: o.description.slice(0, 1000) } : {}), ...(gtdList.length ? { gtd: gtdList } : {}), ...(wlList.length ? { wl: wlList } : {}), ...(o.spots ? { spots: { partner: o.spots.partner.slice(0, 200) } } : {}) };
+        const links = cleanLinks(o.links);
+        const details = { v: 1, ...(o.image ? { image: o.image } : {}), ...(o.banner && imageOk(o.banner) ? { banner: o.banner } : {}), ...(links ? { links } : {}), ...(o.category?.trim() ? { category: o.category.trim().slice(0, 32) } : {}), ...(o.description ? { description: o.description.slice(0, 1000) } : {}), ...(gtdList.length ? { gtd: gtdList } : {}), ...(wlList.length ? { wl: wlList } : {}), ...(o.spots ? { spots: { partner: o.spots.partner.slice(0, 200) } } : {}) };
+        const detailsJson = JSON.stringify(details);
+        if (new TextEncoder().encode(detailsJson).length > DROP_MAX_DETAILS)
+            throw new Error("The images and lists are too big to publish together. Link the banner (https:// or ipfs://) instead of uploading it, or use a smaller image.");
         const { result, request } = await this.publicClient.simulateContract({
             address: this.factory,
             abi: cloakDropFactoryAbi,
             functionName: "createDrop",
-            args: [params, o.name.trim(), o.symbol.trim(), o.baseURI.trim(), JSON.stringify(details)],
+            args: [params, o.name.trim(), o.symbol.trim(), o.baseURI.trim(), detailsJson],
             account: w.account,
         });
         const txHash = await w.writeContract(request);
@@ -158,11 +202,14 @@ export class CloakDrops {
     }
     /** A drop's published details: its image, description and the lists behind its roots. */
     async details(drop) {
-        const logs = await this.chunked((from, to) => this.publicClient.getContractEvents({ address: this.factory, abi: cloakDropFactoryAbi, eventName: "DropDetails", args: { drop }, fromBlock: from, toBlock: to, strict: true }), true);
+        const logs = await this.chunked((from, to) => this.publicClient.getContractEvents({ address: this.factories, abi: cloakDropFactoryAbi, eventName: "DropDetails", args: { drop }, fromBlock: from, toBlock: to, strict: true }), true);
         try {
             const d = JSON.parse(logs[0]?.args.details ?? "{}");
             return {
                 image: typeof d.image === "string" ? d.image : undefined,
+                banner: imageOk(d.banner) ? d.banner : undefined,
+                links: cleanLinks(d.links),
+                category: typeof d.category === "string" ? d.category.slice(0, 32) : undefined,
                 description: typeof d.description === "string" ? d.description : undefined,
                 gtd: Array.isArray(d.gtd) ? d.gtd.filter((e) => isAddress(e?.wallet) && Number.isInteger(e?.spots)) : undefined,
                 wl: Array.isArray(d.wl) ? d.wl.filter((a) => isAddress(a)) : undefined,
@@ -218,7 +265,154 @@ export class CloakDrops {
             wlPrice,
             tieSupply: Number(r[14]),
             tieDemand: Number(r[15]),
+            escrow: await this.escrowOf(drop),
+        };
+    }
+    /** Where an escrow drop's tokens come from, or undefined for a drop that mints its own. */
+    async escrowOf(drop) {
+        const c = { address: drop, abi: cloakEscrowDropAbi };
+        const collection = await this.publicClient.readContract({ ...c, functionName: "collection" }).catch(() => undefined);
+        if (!collection)
+            return undefined;
+        const [tokenIds, held, returned] = await Promise.all([this.publicClient.readContract({ ...c, functionName: "tokenIds" }), this.publicClient.readContract({ ...c, functionName: "held" }), this.publicClient.readContract({ ...c, functionName: "unsoldMinted" })]);
+        return { collection, tokenIds: [...tokenIds], held: Number(held), returned: Number(returned) };
+    }
+    /** The token ids a bid won in an escrow drop (once settled and numbered). */
+    async tokensOf(drop, bidId) {
+        return [...(await this.publicClient.readContract({ address: drop, abi: cloakEscrowDropAbi, functionName: "tokensOf", args: [bidId] }))];
+    }
+    /**
+     * Auction NFTs that already exist. Needs the escrow factory. Checks the caller owns every token, approves the
+     * factory for the collection if it isn't yet (one transaction), then creates the auction, which moves every token
+     * into it. Returns the drop's address.
+     */
+    async createEscrow(o) {
+        const w = this.wallet();
+        if (!this.escrowFactory)
+            throw new Error("Auctions of existing NFTs aren't available on this network yet.");
+        if (!o.name.trim() || o.name.length > 64 || !o.symbol.trim() || o.symbol.length > 16)
+            throw new Error("Give the auction a name (up to 64 characters) and a symbol (up to 16).");
+        if (!isAddress(o.collection))
+            throw new Error("Enter the collection's contract address.");
+        const ids = [...new Set(o.tokenIds.map((x) => BigInt(x)))].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        if (!ids.length || ids.length > ESCROW_MAX_TOKENS)
+            throw new Error(`List 1 to ${ESCROW_MAX_TOKENS} tokens.`);
+        if (o.floor <= 0n)
+            throw new Error("Set a price above zero.");
+        const boost = o.wl?.boostBps ?? 0;
+        if (boost < 0 || boost > DROP_MAX_BOOST_BPS)
+            throw new Error("The WL boost is 0% to 30%.");
+        if ((o.wl?.list.length ?? 0) > DROP_LIST_MAX)
+            throw new Error(`A list holds up to ${DROP_LIST_MAX} wallets.`);
+        const nft = { address: getAddress(o.collection), abi: ERC721_ABI };
+        const me = w.account.address.toLowerCase();
+        const owners = await this.reads(ids.map((id) => ({ ...nft, functionName: "ownerOf", args: [id] }))).catch(() => {
+            throw new Error("That contract didn't answer like an NFT collection (ERC-721). Check the address and the token ids.");
+        });
+        const notMine = ids.filter((_, i) => String(owners[i]).toLowerCase() !== me);
+        if (notMine.length)
+            throw new Error(`This wallet doesn't own token${notMine.length > 1 ? "s" : ""} ${notMine.slice(0, 5).map(String).join(", ")}${notMine.length > 5 ? "…" : ""}.`);
+        let approvalTx;
+        if (!(await this.publicClient.readContract({ ...nft, functionName: "isApprovedForAll", args: [w.account.address, this.escrowFactory] }))) {
+            approvalTx = await w.writeContract({ ...nft, functionName: "setApprovalForAll", args: [this.escrowFactory, true], account: w.account, chain: w.chain });
+            await this.send(approvalTx);
+        }
+        const wlList = (o.wl?.list ?? []).map((a) => getAddress(a));
+        const now = Number((await this.publicClient.getBlock()).timestamp);
+        const gtdEnd = now + 90;
+        const commitEnd = gtdEnd + o.biddingSecs;
+        const tlockRound = drandRoundAt(commitEnd);
+        const revealEnd = Math.max(commitEnd + (o.revealSecs ?? DROP_DEFAULT_REVEAL_SECS), drandRoundTime(tlockRound) + 60);
+        const zero = `0x${"0".repeat(64)}`;
+        const params = {
+            creator: w.account.address,
+            supply: ids.length,
+            maxPerBid: o.maxPerBid ?? 1,
+            numTicks: o.numTicks ?? 200,
+            wlBoostBps: wlList.length ? boost : 0,
+            royaltyBps: 0,
+            gtdEnd: BigInt(gtdEnd),
+            commitEnd: BigInt(commitEnd),
+            revealEnd: BigInt(revealEnd),
+            tlockRound: BigInt(tlockRound),
+            floor: o.floor,
+            tickSize: o.tickSize ?? (o.floor / 20n || 1n),
+            gtdPrice: 0n,
+            gtdRoot: zero,
+            wlRoot: merkleTree(wlList.map(wlLeaf)).root,
         };
+        const links = cleanLinks(o.links);
+        const details = { v: 1, ...(o.image ? { image: o.image } : {}), ...(o.banner && imageOk(o.banner) ? { banner: o.banner } : {}), ...(links ? { links } : {}), ...(o.category?.trim() ? { category: o.category.trim().slice(0, 32) } : {}), ...(o.description ? { description: o.description.slice(0, 1000) } : {}), ...(wlList.length ? { wl: wlList } : {}) };
+        const detailsJson = JSON.stringify(details);
+        if (new TextEncoder().encode(detailsJson).length > DROP_MAX_DETAILS)
+            throw new Error("The images and lists are too big to publish together. Link the banner (https:// or ipfs://) instead of uploading it, or use a smaller image.");
+        const { result, request } = await this.publicClient.simulateContract({
+            address: this.escrowFactory,
+            abi: cloakEscrowDropFactoryAbi,
+            functionName: "createDrop",
+            args: [params, nft.address, ids, o.name.trim(), o.symbol.trim(), detailsJson],
+            account: w.account,
+        });
+        const txHash = await w.writeContract(request);
+        await this.send(txHash);
+        return { drop: result, txHash, approvalTx };
+    }
+    /**
+     * The token ids of `collection` a wallet holds, from the collection's Transfer events (works for any ERC-721, no
+     * enumeration needed). Capped at `max`.
+     */
+    async ownedTokens(collection, owner, opts = {}) {
+        const max = opts.max ?? ESCROW_MAX_TOKENS;
+        const c = { address: collection, abi: ERC721_ABI };
+        // ERC-721 Enumerable: read the wallet's tokens straight from the collection
+        const enumerable = await this.publicClient.readContract({ ...c, functionName: "supportsInterface", args: ["0x780e9d63"] }).catch(() => false);
+        if (enumerable) {
+            const n = Number(await this.publicClient.readContract({ ...c, functionName: "balanceOf", args: [owner] }));
+            const ids = (await this.reads(Array.from({ length: Math.min(n, max) }, (_, i) => ({ ...c, functionName: "tokenOfOwnerByIndex", args: [owner, BigInt(i)] }))));
+            return ids.sort((x, y) => (x < y ? -1 : 1));
+        }
+        // otherwise, the collection's Transfer events to the wallet, from the block it was deployed in
+        const ev = { type: "event", name: "Transfer", inputs: [{ type: "address", name: "from", indexed: true }, { type: "address", name: "to", indexed: true }, { type: "uint256", name: "tokenId", indexed: true }] };
+        const latest = await this.publicClient.getBlockNumber();
+        const from = opts.fromBlock ?? (await this.deployBlock(collection, latest));
+        const seen = new Set();
+        const get = (a, b) => this.publicClient.getLogs({ address: collection, event: ev, args: { to: owner }, fromBlock: a, toBlock: b });
+        try {
+            for (const l of await get(from, latest))
+                if (l.args.tokenId !== undefined)
+                    seen.add(l.args.tokenId);
+        }
+        catch {
+            for (let a = from; a <= latest; a += 100000n) {
+                const b = a + 99999n > latest ? latest : a + 99999n;
+                for (const l of await get(a, b).catch(() => []))
+                    if (l.args.tokenId !== undefined)
+                        seen.add(l.args.tokenId);
+            }
+        }
+        const ids = [...seen].sort((a, b) => (a < b ? -1 : 1));
+        const owners = await this.reads(ids.map((id) => ({ ...c, functionName: "ownerOf", args: [id] }))).catch(() => ids.map(() => null));
+        return ids.filter((_, i) => String(owners[i]).toLowerCase() === owner.toLowerCase()).slice(0, max);
+    }
+    /** The block a contract was deployed in, by binary search on its code (0 if the node can't tell). */
+    async deployBlock(address, latest) {
+        try {
+            let lo = 0n;
+            let hi = latest;
+            if (!(await this.publicClient.getCode({ address, blockNumber: hi })))
+                return 0n;
+            while (lo < hi) {
+                const mid = (lo + hi) / 2n;
+                if (await this.publicClient.getCode({ address, blockNumber: mid }))
+                    hi = mid;
+                else
+                    lo = mid + 1n;
+            }
+            return lo;
+        }
+        catch {
+            return 0n;
+        }
     }
     /** The bid level for a price: the highest level at or below it (bids snap down, never up). */
     static tickFor(s, price) {

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export * from "./cloak.js";
 export * from "./drops.js";
 export * from "./private/index.js";
 export * from "./spots.js";
+export * from "./names.js";

package/dist/index.js

@@ -7,3 +7,4 @@ export * from "./cloak.js";
 export * from "./drops.js";
 export * from "./private/index.js";
 export * from "./spots.js";
+export * from "./names.js";

package/dist/names.d.ts

@@ -0,0 +1,65 @@
+import { type Address, type PublicClient } from "viem";
+/**
+ * .ely names (Elysium Name Service): type `bona.ely` instead of a long address. Two read-only calls on one contract,
+ * no API key and no backend. Mainnet's address is published at launch; until then only testnet resolves.
+ */
+export declare const ELY_NAMES: Record<number, Address>;
+export declare const elyNamesAbi: readonly [{
+    readonly name: "resolve";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "string";
+        readonly name: "label";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "primaryNameOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "text";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "string";
+        readonly name: "label";
+    }, {
+        readonly type: "string";
+        readonly name: "key";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}];
+/**
+ * The label of a .ely name, or null if the input isn't one: trimmed, lowercased, a trailing `.ely` removed, then
+ * 2 to 63 of a-z, 0-9 and hyphens, not starting or ending with a hyphen.
+ */
+export declare function elyLabel(input: string): string | null;
+/** True when the input looks like a .ely name (it ends in `.ely` and its label is valid). */
+export declare const isElyName: (input: string) => boolean;
+/**
+ * The wallet a .ely name points to now, or null if the name isn't registered, has expired, or the chain has no name
+ * service. Resolve at the moment of sending and don't store the result: names expire and change hands.
+ */
+export declare function resolveEly(publicClient: PublicClient, name: string): Promise<Address | null>;
+/** A wallet's chosen .ely name (like `bona.ely`), or null if it has none. Safe to display: only the owner can set it. */
+export declare function elyNameOf(publicClient: PublicClient, address: Address): Promise<string | null>;
+/**
+ * A recipient typed by a person: a 0x address as it is, or a .ely name resolved now. Throws a readable error for
+ * anything else, and for a name that doesn't resolve (never send to the zero address).
+ */
+export declare function resolveRecipient(publicClient: PublicClient, input: string): Promise<{
+    address: Address;
+    name?: string;
+}>;