@warptoad/skinny-fat-imt-js 0.0.2

package/dist/Trees.d.ts

@@ -0,0 +1,702 @@
+import { LeanIMT, type LeanIMTHashFunction } from "@zk-kit/lean-imt";
+import { type Abi, type AbiEvent, type Address, type GetContractReturnType, type Hex, type PublicClient } from "viem";
+import { type PostQueryEventFilter } from "./eventScanning.js";
+import { skinnyStorageAbi, skinnyEventAbi, fatStorageAbi, fatEventAbi, iimtEventsAbi } from "./abis.js";
+export { skinnyStorageAbi, skinnyEventAbi, fatStorageAbi, fatEventAbi, iimtEventsAbi };
+export type AnyContract = {
+    address: Address;
+    abi: Abi;
+    read: Record<string, (...args: any[]) => Promise<any>>;
+};
+type ReadableStorageAbi = readonly [
+    ...typeof skinnyStorageAbi,
+    ...typeof fatStorageAbi
+];
+type ReadableEventAbi = readonly [
+    ...typeof skinnyEventAbi,
+    ...typeof fatEventAbi,
+    ...typeof iimtEventsAbi
+];
+type ReadableAbi = readonly [...ReadableStorageAbi, ...ReadableEventAbi];
+/**
+ * A single event *entry* of the contract abi, by name. `EventLog`/`PostQueryEventFilter` want one
+ * AbiEvent, not a whole abi, and this is the exact same thing `queryEventInChunks` infers for
+ * `eventName`, so filters typed with it line up with the query they're passed to.
+ */
+type ReadableEvent<TName extends string> = Extract<ReadableAbi[number], AbiEvent & {
+    name: TName;
+}>;
+export declare const readableStorageAbi: [{
+    readonly inputs: readonly [];
+    readonly name: "NotInitialized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyDepth";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyLeaves";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyLeavesBaseSlot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyRoot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnySideNodes";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnySize";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EndIndexOutOfRange";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "LevelOutOfRange";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitialized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatDepth";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatLeaves";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatLeavesBaseSlot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "level";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatNodes";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatRoot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatSize";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export declare const readableEventAbi: [{
+    readonly inputs: readonly [];
+    readonly name: "NotInitialized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyDepth";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnyRoot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnySideNodes";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getSkinnySize";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EndIndexOutOfRange";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "LevelOutOfRange";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitialized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatDepth";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatLeaves";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "firstIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "endIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "level";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatNodes";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatRoot";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getFatSize";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "leaf";
+        readonly type: "uint256";
+    }];
+    readonly name: "NewLeaf";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "root";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "size";
+        readonly type: "uint256";
+    }];
+    readonly name: "NewRoot";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }];
+    readonly name: "NewTree";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "startIndex";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "nextIndex";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "leaf";
+        readonly type: "uint256";
+    }];
+    readonly name: "RepeatedLeafs";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "treeId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "newLeaf";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldLeaf";
+        readonly type: "uint256";
+    }];
+    readonly name: "UpdatedLeaf";
+    readonly type: "event";
+}];
+export type ReadableContract = GetContractReturnType<ReadableAbi, PublicClient>;
+export type ReadableContractStorage = GetContractReturnType<ReadableStorageAbi, PublicClient>;
+export type ReadableContractEvent = GetContractReturnType<ReadableEventAbi, PublicClient>;
+export type ReadableContractSkinnyEvent = GetContractReturnType<typeof skinnyEventAbi, PublicClient>;
+export type ReadableContractSkinnyStorage = GetContractReturnType<typeof skinnyStorageAbi, PublicClient>;
+export type ReadableContractFatEvent = GetContractReturnType<typeof fatEventAbi, PublicClient>;
+export type ReadableContractFatStorage = GetContractReturnType<typeof fatStorageAbi, PublicClient>;
+export declare const ERC165_IDS: {
+    readonly skinnyEvent: `0x${string}`;
+    readonly skinnyStorage: `0x${string}`;
+    readonly fatEvent: `0x${string}`;
+    readonly fatStorage: `0x${string}`;
+};
+declare enum TREE_TYPE {
+    UNKNOWN = 0,
+    FAT_STORAGE = 1,
+    FAT_EVENT = 2,
+    SKINNY_STORAGE = 3,
+    SKINNY_EVENT = 4,
+    NO_INTERFACE = 5
+}
+export declare const LeanIMTHashFuncPoseidon2: LeanIMTHashFunction;
+export type CachedTree = {
+    tree: LeanIMT<bigint>;
+    type: TREE_TYPE;
+    lastSynced: bigint;
+    insertOnlyTree?: boolean;
+};
+/**
+ * A detached LeanIMT holding the same leaves *and* internal nodes as `tree`, so it can be grown
+ * without touching the original. Copies the nodes rather than replaying the leaves on purpose:
+ * `new LeanIMT(hash, tree.leaves)` would rehash the whole tree, which is the exact cost a caller
+ * growing a cached tree is trying to avoid. This is array copies only, no hashing.
+ */
+export declare function copyTree(tree: LeanIMT<bigint>, hashFunc: LeanIMTHashFunction): LeanIMT<bigint>;
+export declare class Trees {
+    private trees;
+    /** last known size per tree, with the block it was read at. See {@link getTreeSizeStorage}. */
+    private sizes;
+    contractAddress: Address;
+    contract: ReadableContract;
+    hashFunc: LeanIMTHashFunction;
+    private publicClient;
+    constructor(contractAddress: Address, client: PublicClient, hashFunc?: LeanIMTHashFunction);
+    sync(treeIds?: bigint[] | undefined, { fullNodeMode, attemptFastSizeMatch, syncToRoot, eventChunkSize, storageChunkSize, insertOnlyTree, autoDiscovery, hasRepeatedLeafs, blockNumber }?: {
+        fullNodeMode?: boolean;
+        blockNumber?: bigint;
+        attemptFastSizeMatch?: boolean;
+        syncToRoot?: bigint;
+        eventChunkSize?: bigint;
+        storageChunkSize?: bigint;
+        hasRepeatedLeafs?: boolean;
+        insertOnlyTree?: boolean;
+        autoDiscovery?: boolean | undefined;
+    }): Promise<{
+        [treeId: `0x${string}`]: CachedTree;
+    }>;
+    /**
+     * Reads trees straight from contract storage, at `blockNumber` (defaults to the safe block).
+     *
+     * `attemptFastSizeMatch` (default true) bets that the cached tree is still the right *prefix* of the
+     * onchain one, so only the difference in size has to be dealt with: read the leaves past the
+     * cache's end, or drop the ones past the onchain size. It is a hope, not a promise, so it always
+     * ends in a root check — a tree that had an update(), or was reset and regrown with different
+     * leaves, fails that check and is re-read in full. Turning it off re-reads every leaf up front.
+     */
+    syncTreesStorage(treeIds?: bigint[] | undefined, { chunkSize, attemptFastSizeMatch, blockNumber }?: {
+        attemptFastSizeMatch?: boolean;
+        chunkSize?: bigint;
+        blockNumber?: bigint;
+    }): Promise<{
+        [treeId: Hex]: CachedTree;
+    }>;
+    /**
+     * The leaves of `[startIndex, endIndex)`, read in chunks of `chunkSize`. Same range as
+     * {@link Trees#getLeavesStorage}, which does it in a single call, but split up so a big range
+     * doesn't have to fit in one eth_call. What the caller does with them (build a tree, grow one)
+     * is up to it.
+     */
+    private readLeavesStorage;
+    syncTreesEvent(treeIds?: bigint[] | undefined, { blockNumber, attemptFastSizeMatch, syncToRoot, chunkSize, insertOnlyTree, autoDiscovery, hasRepeatedLeafs }?: {
+        blockNumber?: bigint;
+        attemptFastSizeMatch?: boolean;
+        syncToRoot?: bigint;
+        chunkSize?: bigint;
+        hasRepeatedLeafs?: boolean;
+        insertOnlyTree?: boolean;
+        autoDiscovery?: boolean | undefined;
+    }): Promise<{
+        [treeId: `0x${string}`]: CachedTree;
+    }>;
+    getContract(): Promise<ReadableContract>;
+    getOldestSyncTreeId(treeIds: Hex[]): Hex;
+    getOldestSyncBlock(treeIds: bigint[]): bigint;
+    getTreeType(treeId: Hex, chainId: number): Promise<TREE_TYPE>;
+    getLeavesStorage(treeId: Hex, chainId: number, startIndex: bigint, endIndex: bigint, blockNumber: bigint): Promise<readonly bigint[]>;
+    getTreeSizeStorage(treeId: Hex, chainId: number, blockNumber: bigint): Promise<bigint>;
+    getRootStorage(treeId: Hex, chainId: number, blockNumber: bigint): Promise<bigint>;
+    initTree(treeId: Hex, chainId: number): Promise<CachedTree>;
+}
+export declare function identifyTree(treeId: bigint, contract: AnyContract): Promise<TREE_TYPE>;
+type SyncState = {
+    lastBlockSynced: bigint;
+    unsyncedIds: Set<Hex>;
+    treeCache: {
+        [treeId: Hex]: CachedTree;
+    };
+    treeState: {
+        [treeId: Hex]: {
+            expectedRoot: bigint;
+            tree?: LeanIMT<bigint>;
+            leaves: bigint[];
+            count: bigint;
+            targetSize: bigint;
+            lastSynced: bigint;
+        };
+    };
+};
+type IMTEventFilter = PostQueryEventFilter<ReadableEvent<"NewRoot" | "NewLeaf" | "UpdatedLeaf" | "RepeatedLeafs">>;
+export declare function getEventFilter(firstBlock: bigint, syncState: SyncState, { autoDiscover, syncToRoot, attemptFastSizeMatch, hashFunc }?: {
+    hashFunc?: LeanIMTHashFunction;
+    attemptFastSizeMatch?: boolean;
+    autoDiscover?: boolean;
+    syncToRoot?: bigint;
+}): IMTEventFilter;
+//# sourceMappingURL=Trees.d.ts.map