@lunarislab/state-sync 1.0.2 → 1.1.2

package/classes/Client.d.ts

@@ -1,30 +1,18 @@
-import { AbiEvent, GetLogsReturnType, PublicClient, WalletClient } from "viem";
+import { PublicClient, WalletClient } from "viem";
 import { IClientConfig, IStateSyncEvents } from "../types/Client";
-import { Watcher } from "./Watcher";
-import { ISimplifiedWatcher, IWatcherConfig, LevelDBConstructor } from "../types/Watcher";
 import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
-import { EventEmitter } from "events";
+import { Syncer } from "./Syncer";
+import { ISyncerConfig } from "../types/Syncer";
+import { SimpleEmitter } from "./SimpleEmitter";
+import { LevelDBConstructor } from "../types/Level";
 /**
  * The StateSync client class.
  */
-export declare class StateSync implements IClientConfig {
+export declare class StateSync extends SimpleEmitter<IStateSyncEvents> {
     public: PublicClient;
     wallet: WalletClient;
     level: LevelDBConstructor;
     levelPath: string;
-    timeout: number;
-    protected watchers: Map<string, Watcher<any>>;
-    protected emitter: EventEmitter;
-    protected startBlockNum: bigint;
-    protected syncedBlockNum: bigint;
-    protected gap: bigint;
-    protected lastBlockNum: bigint;
-    protected eventCount: bigint;
     constructor(config: IClientConfig);
-    protected _setInitialBlockNumbers(): Promise<import("viem").WatchBlocksReturnType>;
-    protected _processLogs(logs: GetLogsReturnType<undefined, AbiEvent[]>): Promise<void>;
-    protected _sync(): Promise<void>;
-    on<T extends keyof IStateSyncEvents>(eventName: T, callback: IStateSyncEvents[T]): EventEmitter;
-    start(): Promise<import("viem").WatchBlocksReturnType>;
-    createWatcher<Signature extends EventSignature>(config: IWatcherConfig<Signature>): Promise<ISimplifiedWatcher>;
+    createSyncer<signature extends EventSignature>(config: ISyncerConfig<signature>): Promise<Syncer<signature>>;
 }

package/classes/Client.js

@@ -1,116 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateSync = void 0;
-const viem_1 = require("viem");
-const Watcher_1 = require("./Watcher");
-const events_1 = require("events");
+const Syncer_1 = require("./Syncer");
+const SimpleEmitter_1 = require("./SimpleEmitter");
 /**
  * The StateSync client class.
  */
-class StateSync {
+class StateSync extends SimpleEmitter_1.SimpleEmitter {
     constructor(config) {
-        this.watchers = new Map();
-        this.startBlockNum = 0n;
-        this.syncedBlockNum = 0n;
-        this.gap = 500000n;
-        this.lastBlockNum = 0n;
-        this.eventCount = 0n;
+        super();
         this.public = config.public;
         this.wallet = config.wallet;
         this.level = config.level;
         this.levelPath = config.levelPath || "";
-        this.emitter = new events_1.EventEmitter();
-        this.timeout = config.timeout || 50;
-    }
-    ;
-    async _setInitialBlockNumbers() {
-        const lastSyncedBlocksNumbers = Array.from(this.watchers.values()).map(s => s.lastSyncedBlockNumber);
-        const smalledSyncedBlockNumber = lastSyncedBlocksNumbers.reduce((min, value) => (value < min ? value : min));
-        this.startBlockNum = smalledSyncedBlockNumber;
-        this.syncedBlockNum = smalledSyncedBlockNumber;
-        this.lastBlockNum = await this.public.getBlockNumber();
-        return this.public.watchBlocks({ onBlock: (block) => this.lastBlockNum = block.number });
-    }
-    ;
-    async _processLogs(logs) {
-        // Send logs to watcher classes to handle the storing logic.
-        for (const watcher of this.watchers.values()) {
-            const eventName = watcher.event.name;
-            const watcherLogs = logs.filter(log => watcher.addresses.includes((0, viem_1.checksumAddress)(log.address)) && log.eventName === eventName);
-            // make sure logs are well ordered by logIndex
-            watcherLogs.sort((a, b) => a.logIndex - b.logIndex);
-            await watcher.onLogs(watcherLogs);
-            await watcher.setSyncedBlockNumber(this.syncedBlockNum);
-        }
-    }
-    ;
-    async _sync() {
-        const stopInitialWatcher = await this._setInitialBlockNumbers();
-        const contractsAddresses = Array.from(this.watchers.values()).map(s => s.addresses).flat(1);
-        const eventsABI = Array.from(this.watchers.values()).map(s => s.event);
-        while (this.syncedBlockNum < this.lastBlockNum) {
-            try {
-                await new Promise(x => setTimeout(x, this.timeout));
-                // Fetch logs from the network.
-                const logs = await this.public.getLogs({
-                    fromBlock: this.syncedBlockNum,
-                    toBlock: this.syncedBlockNum + this.gap,
-                    address: contractsAddresses,
-                    events: eventsABI,
-                });
-                await this._processLogs(logs);
-                this.syncedBlockNum + this.gap > this.lastBlockNum ?
-                    this.syncedBlockNum = this.lastBlockNum :
-                    this.syncedBlockNum += this.gap;
-                this.eventCount += BigInt(logs.length);
-                this.emitter.emit("sync", {
-                    startBlockNum: this.startBlockNum,
-                    endBlockNum: this.lastBlockNum,
-                    syncedBlockNum: this.syncedBlockNum,
-                    eventCount: this.eventCount
-                });
-            }
-            catch (e) {
-                const error = e;
-                if (error.name === "LimitExceededRpcError") {
-                    this.gap = this.gap / 2n;
-                    this.emitter.emit("syncRateLimitExeeded", this.gap);
-                    continue;
-                }
-                throw error;
-            }
-        }
-        stopInitialWatcher();
-    }
-    ;
-    on(eventName, callback) {
-        return this.emitter.on(eventName, callback);
-    }
-    ;
-    async start() {
-        await this._sync();
-        this.emitter.emit('ready');
-        return this.public.watchBlocks({
-            onBlock: async (block) => {
-                this.syncedBlockNum = block.number;
-                this.emitter.emit('newBlock', block.number);
-                const contractsAddresses = Array.from(this.watchers.values()).map(s => s.addresses).flat(1);
-                const eventsABI = Array.from(this.watchers.values()).map(s => s.event);
-                // Fetch logs from the network.
-                const logs = await this.public.getLogs({
-                    blockHash: block.hash,
-                    address: contractsAddresses,
-                    events: eventsABI,
-                });
-                await this._processLogs(logs);
+        this.public.watchBlocks({
+            onBlock: (block) => {
+                this.emit("newBlock", { block });
             }
         });
     }
-    async createWatcher(config) {
-        const watcher = new Watcher_1.Watcher(this, config);
-        await watcher.connect();
-        this.watchers.set(config.dbID, watcher);
-        return watcher;
+    async createSyncer(config) {
+        return new Syncer_1.Syncer(this, config);
     }
     ;
 }

package/classes/Saver.d.ts

@@ -0,0 +1,22 @@
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { ICommit, ISaverConfig, getItemIDFn, onLogFn } from "../types/Saver";
+import { StateSync } from "./Client";
+import { Log } from "../types/Log";
+import { IAbstractLevel, IDatabaseEnv, IDatabaseItem } from "../types/Level";
+export declare class Saver<signature extends EventSignature> {
+    protected client: StateSync;
+    lastBlockNum: bigint;
+    protected dbID: string;
+    protected onLog: onLogFn<signature>;
+    protected getItemID: getItemIDFn<signature>;
+    db: IAbstractLevel<string, IDatabaseItem>;
+    constructor(client: StateSync, config: ISaverConfig<signature>);
+    protected _updateEnv(): Promise<void>;
+    getEnv(): Promise<IDatabaseEnv>;
+    init(): Promise<void>;
+    /**
+     * saveLogs is optimized to not call mutiple times the db for the same item.
+     * Instead it will calculate the state in memory and save the final result in the db.
+     */
+    saveLogs(logs: Log<signature>[]): Promise<ICommit[]>;
+}

package/classes/Saver.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Saver = void 0;
+class Saver {
+    constructor(client, config) {
+        this.client = client;
+        this.lastBlockNum = 0n;
+        this.dbID = config.dbID;
+        this.onLog = config.onLog;
+        this.getItemID = config.getItemID ? config.getItemID : (log) => log.address;
+        this.db = new this.client.level(client.levelPath + `/${config.dbID}`.replace('//', "/"), { valueEncoding: "json" });
+    }
+    ;
+    // save some env variables in the db
+    async _updateEnv() {
+        const env = {
+            lastBlockNum: this.lastBlockNum.toString()
+        };
+        await this.db.put("ENV", env);
+    }
+    ;
+    async getEnv() {
+        return await this.db.get("ENV").catch(e => undefined);
+    }
+    ;
+    async init() {
+        await this.db.open();
+        const env = await this.getEnv();
+        this.lastBlockNum = env?.lastBlockNum ? BigInt(env.lastBlockNum) : 0n;
+        await this._updateEnv();
+    }
+    ;
+    /**
+     * saveLogs is optimized to not call mutiple times the db for the same item.
+     * Instead it will calculate the state in memory and save the final result in the db.
+     */
+    async saveLogs(logs) {
+        if (logs.length === 0)
+            return [];
+        const ids = logs.map((log) => this.getItemID(log));
+        const oldDatas = await this.db.getMany(ids);
+        // generate cache
+        const newDatas = new Map();
+        for (const index in ids) {
+            const oldData = oldDatas[index];
+            const log = logs[index];
+            const id = this.getItemID(log);
+            const newData = this.onLog(log, oldData);
+            newDatas.set(id, newData);
+            if (this.lastBlockNum < log.blockNumber)
+                this.lastBlockNum = log.blockNumber;
+        }
+        ;
+        // save results
+        const arr = Array.from(newDatas.entries());
+        const payload = arr.map(([address, newData]) => ({
+            type: "put",
+            key: address,
+            value: newData
+        }));
+        await this.db.batch(payload);
+        await this._updateEnv();
+        return payload;
+    }
+}
+exports.Saver = Saver;

package/classes/SimpleEmitter.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "events";
+export type BaseEvents = {
+    [key: string]: any;
+};
+export declare class SimpleEmitter<events extends BaseEvents> {
+    protected emitter: EventEmitter;
+    constructor();
+    on<E extends keyof events>(event: E, listener: (data: events[E]) => void): void;
+    once<E extends keyof events>(event: E, listener: (data: events[E]) => void): void;
+    emit<E extends keyof events>(event: E, data?: events[E]): boolean;
+    removeListener<E extends keyof events>(event: E, listener: (data: events[E]) => void): void;
+    removeAllListeners(): void;
+}

package/classes/SimpleEmitter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleEmitter = void 0;
+const events_1 = require("events");
+class SimpleEmitter {
+    constructor() {
+        this.emitter = new events_1.EventEmitter();
+    }
+    ;
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    ;
+    once(event, listener) {
+        this.emitter.once(event, listener);
+    }
+    ;
+    emit(event, data) {
+        return this.emitter.emit(event, data);
+    }
+    ;
+    removeListener(event, listener) {
+        this.emitter.removeListener(event, listener);
+    }
+    ;
+    removeAllListeners() {
+        this.emitter.removeAllListeners();
+    }
+    ;
+}
+exports.SimpleEmitter = SimpleEmitter;

package/classes/Syncer.d.ts

@@ -0,0 +1,21 @@
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { ISyncerConfig, ISyncerEvents } from "../types/Syncer";
+import { StateSync } from "./Client";
+import { Watcher } from "./Watcher";
+import { Saver } from "./Saver";
+import { Log } from "../types/Log";
+import { Address } from "abitype";
+import { SimpleEmitter } from "./SimpleEmitter";
+export declare class Syncer<signature extends EventSignature> extends SimpleEmitter<ISyncerEvents<signature>> {
+    protected client: StateSync;
+    protected logs: Log<signature>[];
+    protected lastPush: number;
+    protected watcher: Watcher<signature>;
+    protected saver: Saver<signature>;
+    protected commitInterval: number;
+    constructor(client: StateSync, config: ISyncerConfig<signature>);
+    protected _commit(): Promise<void>;
+    start(): Promise<void>;
+    addContracts(contracts: Address[]): Promise<void>;
+    removeContracts(contracts: Address[]): Promise<void>;
+}

package/classes/Syncer.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Syncer = void 0;
+const Watcher_1 = require("./Watcher");
+const Saver_1 = require("./Saver");
+const SimpleEmitter_1 = require("./SimpleEmitter");
+class Syncer extends SimpleEmitter_1.SimpleEmitter {
+    constructor(client, config) {
+        super();
+        this.client = client;
+        this.logs = [];
+        this.lastPush = 0;
+        this.commitInterval = config.commitInterval || 100;
+        this.watcher = new Watcher_1.Watcher(client, {
+            contracts: config.contracts,
+            event: config.event
+        });
+        this.saver = new Saver_1.Saver(client, {
+            dbID: config.dbID,
+            getItemID: config.getItemID,
+            onLog: config.onLog
+        });
+    }
+    ;
+    async _commit() {
+        const date = Date.now();
+        // If the last push was less than waitTime ago, don't commit
+        if (this.lastPush > date - this.commitInterval)
+            return;
+        this.lastPush = date;
+        // Wait for commit interval to avoid letting some logs in the queue
+        await new Promise(x => setTimeout(x, this.commitInterval));
+        // Clear queue and save logs
+        const logs = this.logs.splice(0, this.logs.length);
+        const commits = await this.saver.saveLogs(logs);
+        this.emit("commit", { commits });
+    }
+    async start() {
+        await this.saver.init();
+        this.watcher.on('log', async (log) => {
+            this.logs.push(log);
+            await this._commit();
+        });
+        await this.watcher.start();
+    }
+    ;
+    async addContracts(contracts) {
+        await this.watcher.addContracts(contracts);
+    }
+    ;
+    async removeContracts(contracts) {
+        await this.watcher.removeContracts(contracts);
+        for (const contract of contracts) {
+            await this.saver.db.del(contract);
+        }
+        ;
+    }
+    ;
+}
+exports.Syncer = Syncer;

package/classes/Watcher.d.ts

@@ -1,27 +1,24 @@
-import { AbiEvent, Address } from "viem";
-import { IWatcherEvents, Log } from "../types/Watcher";
-import { IAbstractLevel, IWatcherConfig, WatcherSchema } from "../types/Watcher";
+import { Address } from "viem";
 import { StateSync } from "./Client";
-import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
 import { EventEmitter } from "events";
-export declare class Watcher<Signature extends EventSignature> {
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { IWatcherConfig, IWatcherEvents } from "../types/Watcher";
+/**
+ * Watcher class is a reader class that watch events from the blockchain and send them as events via event emitter.
+ * Events can then be received by the "Saver" class witch will save them in a local DB.
+ */
+export declare class Watcher<signature extends EventSignature> {
     protected client: StateSync;
-    protected config: IWatcherConfig<Signature>;
-    protected id: string;
-    event: AbiEvent;
-    addresses: Address[];
-    lastSyncedBlockNumber: bigint;
     protected emitter: EventEmitter;
-    db: IAbstractLevel<string, WatcherSchema>;
-    constructor(client: StateSync, config: IWatcherConfig<Signature>);
-    protected _updateEnv(): Promise<void>;
-    on<T extends keyof IWatcherEvents>(eventName: T, callback: IWatcherEvents[T]): EventEmitter;
-    setSyncedBlockNumber(blockNumber: bigint): Promise<void>;
-    connect(): Promise<void>;
-    onLog(log: Log<any>): Promise<void>;
-    /**
-     * onLogs is optimized to not call mutiple times the db for the same contract.
-     * Instead it will calculate the state in memory and save the final result in the db.
-     */
-    onLogs(logs: Log<any>[]): Promise<void>;
+    protected currentBlockNum: bigint;
+    protected contracts: Address[];
+    protected event: EventSignature;
+    protected requestInterval: number;
+    protected started: boolean;
+    constructor(client: StateSync, config: IWatcherConfig<signature>);
+    protected _getLogs(contracts: Address[], fromBlock?: bigint): Promise<void>;
+    start(): void;
+    addContracts(contracts: Address[]): Promise<void>;
+    removeContracts(contracts: Address[]): Promise<void>;
+    on<Evt extends keyof IWatcherEvents>(event: Evt, cb: IWatcherEvents[Evt]): EventEmitter;
 }

package/classes/Watcher.js

@@ -3,87 +3,73 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Watcher = void 0;
 const viem_1 = require("viem");
 const events_1 = require("events");
+/**
+ * Watcher class is a reader class that watch events from the blockchain and send them as events via event emitter.
+ * Events can then be received by the "Saver" class witch will save them in a local DB.
+ */
 class Watcher {
     constructor(client, config) {
         this.client = client;
-        this.config = config;
-        this.db = new this.client.level(client.levelPath + `/${config.dbID}`.replace('//', "/"), { valueEncoding: "json" });
-        this.id = config.dbID;
-        this.event = (0, viem_1.parseAbiItem)(config.event);
-        this.addresses = config.addresses.map(add => (0, viem_1.checksumAddress)(add));
-        this.lastSyncedBlockNumber = 0n;
+        this.currentBlockNum = 0n;
+        this.started = false;
         this.emitter = new events_1.EventEmitter();
+        this.contracts = config.contracts || [];
+        this.requestInterval = config.requestInterval || 50;
+        this.event = config.event;
+        this.client.on("newBlock", ({ block }) => this.currentBlockNum = block.number);
     }
     ;
-    // save some env variables in the db
-    async _updateEnv() {
-        const env = {
-            lastSyncedBlockNumber: this.lastSyncedBlockNumber.toString()
-        };
-        await this.db.put("ENV", env);
-    }
-    ;
-    on(eventName, callback) {
-        return this.emitter.on(eventName, callback);
-    }
-    ;
-    async setSyncedBlockNumber(blockNumber) {
-        this.lastSyncedBlockNumber = blockNumber;
-        await this._updateEnv();
+    async _getLogs(contracts, fromBlock = 0n) {
+        let gap = this.currentBlockNum;
+        let block = fromBlock;
+        while (block < this.currentBlockNum) {
+            await new Promise(x => setTimeout(x, this.requestInterval));
+            try {
+                const logs = await this.client.public.getLogs({
+                    fromBlock: block,
+                    toBlock: block + gap,
+                    address: contracts,
+                    event: (0, viem_1.parseAbiItem)(this.event),
+                });
+                logs.forEach(l => this.emitter.emit("logs", l));
+            }
+            catch (e) {
+                const err = e;
+                if (err.name !== "LimitExceededRpcError")
+                    throw err;
+                gap = gap / 2n;
+                continue;
+            }
+        }
     }
     ;
-    async connect() {
-        await this.db.open();
-        const env = await this.db.get("ENV").catch(e => undefined);
-        this.lastSyncedBlockNumber = env?.lastSyncedBlockNumber ? BigInt(env.lastSyncedBlockNumber) : 0n;
+    start() {
+        if (this.started)
+            throw new Error("Already started");
+        this.started = true;
+        this._getLogs(this.contracts).then(() => {
+            this.client.on("newBlock", () => this._getLogs(this.contracts));
+        });
     }
     ;
-    async onLog(log) {
-        const oldData = await this.db.get((0, viem_1.checksumAddress)(log.address));
-        const newData = this.config.onLog(log, oldData);
-        this.lastSyncedBlockNumber = log.blockNumber;
-        await this.db.put(log.address, newData);
-        await this._updateEnv();
-        this.emitter.emit("change", {
-            id: log.address,
-            state: newData
-        });
+    async addContracts(contracts) {
+        await this._getLogs(contracts);
+        this.contracts.push(...contracts);
     }
     ;
-    /**
-     * onLogs is optimized to not call mutiple times the db for the same contract.
-     * Instead it will calculate the state in memory and save the final result in the db.
-     */
-    async onLogs(logs) {
-        if (logs.length === 0)
-            return;
-        const addresses = logs.map((l) => (0, viem_1.checksumAddress)(l.address));
-        const oldData = await this.db.getMany(addresses);
-        // generate Watchers
-        const newDatas = new Map();
-        for (const index in addresses) {
-            const watcher = oldData[index];
-            const log = logs[index];
-            const identifier = this.config.extractIdentifier ? this.config.extractIdentifier(log) : addresses[index];
-            const newData = this.config.onLog(log, watcher);
-            newDatas.set(identifier, newData);
-            this.emitter.emit("change", {
-                id: identifier,
-                state: newData
-            });
+    async removeContracts(contracts) {
+        for (const contract of contracts) {
+            const index = this.contracts.indexOf(contract);
+            if (index === -1)
+                continue;
+            this.contracts.splice(index, 1);
         }
         ;
-        // save results
-        const arr = Array.from(newDatas.entries());
-        const payload = arr.map(([address, newData]) => ({
-            type: "put",
-            key: address,
-            value: newData
-        }));
-        await this.db.batch(payload);
-        await this._updateEnv();
+    }
+    ;
+    on(event, cb) {
+        return this.emitter.on(event, cb);
     }
     ;
 }
 exports.Watcher = Watcher;
-;

package/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./classes/Client";
-export * from "./classes/Watcher";
+export * from "./classes/Saver";
 export * from "./types/Client";
-export * from "./types/Watcher";
+export * from "./types/Saver";

package/index.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./classes/Client"), exports);
-__exportStar(require("./classes/Watcher"), exports);
+__exportStar(require("./classes/Saver"), exports);
 __exportStar(require("./types/Client"), exports);
-__exportStar(require("./types/Watcher"), exports);
+__exportStar(require("./types/Saver"), exports);

package/package.json

@@ -4,17 +4,17 @@
     "abitype": "^1.0.8",
     "abstract-level": "^2.0.2",
     "events": "^3.3.0",
-    "level": "^9.0.0",
     "path": "^0.12.7",
     "viem": "^2.21.58"
   },
   "name": "@lunarislab/state-sync",
-  "version": "1.0.2",
+  "version": "1.1.2",
   "main": "index.js",
   "scripts": {
     "test": "ts-node ./test.ts",
     "build": "tsc && cp package.json dist/ && cp README.md dist/",
-    "sendNpm": "cd ./dist && npm version patch && npm publish --access=public"
+    "sendNpm": "cd ./dist && npm version patch && npm publish --access=public",
+    "publish": "tsc && cp package.json dist/ && cp README.md dist/ && cd ./dist && npm publish --access=public && cd ../ && npm version patch"
   },
   "author": "",
   "license": "ISC",

package/types/Client.d.ts

@@ -1,5 +1,5 @@
-import { PublicClient, WalletClient } from "viem";
-import { LevelDBConstructor } from "./Watcher";
+import { Block, PublicClient, WalletClient } from "viem";
+import { LevelDBConstructor } from "./Level";
 export interface IClientConfig {
     public: PublicClient;
     wallet: WalletClient;
@@ -14,8 +14,7 @@ export interface SyncParams {
     eventCount: bigint;
 }
 export interface IStateSyncEvents {
-    sync: (params: SyncParams) => void;
-    ready: () => void;
-    newBlock: (blockNumber: bigint) => void;
-    syncRateLimitExceeded: (newBlockRange: number) => void;
+    newBlock: {
+        block: Block;
+    };
 }

package/types/Level.d.ts

@@ -0,0 +1,81 @@
+import { AbstractBatchOperation, AbstractBatchOptions, AbstractChainedBatch, AbstractIterator, AbstractIteratorOptions, AbstractKeyIterator, AbstractKeyIteratorOptions, AbstractOpenOptions, AbstractValueIterator, AbstractValueIteratorOptions } from "abstract-level";
+export interface IDatabaseItem {
+    [key: string]: number | boolean | string;
+}
+export interface IDatabaseEnv {
+    lastBlockNum: string;
+}
+/**
+ * For more modularity, LevelDB instance is injected by user, so we need to provide a generic type for LevelDB.
+ * Every LevelDB implementation must implement this (minimized) interface to avoid errors.
+ */
+export interface LevelDBConstructor<K = any, V = any> {
+    new (path: string, options?: any): IAbstractLevel<K, V>;
+}
+export declare class IAbstractLevel<KDefault = string, VDefault = string> {
+    /**
+    * Open the database.
+    */
+    open(): Promise<void>;
+    open(options: AbstractOpenOptions): Promise<void>;
+    /**
+     * Get a value from the database by {@link key}.
+     */
+    get(key: KDefault): Promise<VDefault>;
+    get(key: KDefault, callback: (err: any, value: VDefault) => void): Promise<VDefault>;
+    /**
+     * Get multiple values from the database by an array of {@link keys}.
+     */
+    getMany(keys: KDefault[]): Promise<VDefault[]>;
+    /**
+     * Add a new entry or overwrite an existing entry.
+     */
+    put(key: KDefault, value: VDefault): Promise<void>;
+    /**
+     * Delete an entry by {@link key}.
+     */
+    del(key: KDefault): Promise<void>;
+    /**
+     * Perform multiple _put_ and/or _del_ operations in bulk.
+     */
+    batch(operations: Array<AbstractBatchOperation<typeof this, KDefault, VDefault>>): Promise<void>;
+    batch<K = KDefault, V = VDefault>(operations: Array<AbstractBatchOperation<typeof this, K, V>>, options: AbstractBatchOptions<K, V>): Promise<void>;
+    batch(): AbstractChainedBatch<typeof this, KDefault, VDefault>;
+    /**
+        * Create an iterator. For example:
+        *
+        * ```js
+        * for await (const [key, value] of db.iterator({ gte: 'a' })) {
+        *   console.log([key, value])
+        * }
+        * ```
+        */
+    iterator(): AbstractIterator<typeof this, KDefault, VDefault>;
+    iterator<K = KDefault, V = VDefault>(options: AbstractIteratorOptions<K, V>): AbstractIterator<typeof this, K, V>;
+    /**
+     * Create a key iterator. For example:
+     *
+     * ```js
+     * for await (const key of db.keys({ gte: 'a' })) {
+     *   console.log(key)
+     * }
+     * ```
+     */
+    keys(): AbstractKeyIterator<typeof this, KDefault>;
+    keys<K = KDefault>(options: AbstractKeyIteratorOptions<K>): AbstractKeyIterator<typeof this, K>;
+    /**
+     * Create a value iterator. For example:
+     *
+     * ```js
+     * for await (const value of db.values({ gte: 'a' })) {
+     *   console.log(value)
+     * }
+     * ```
+     */
+    values(): AbstractValueIterator<typeof this, KDefault, VDefault>;
+    values<K = KDefault, V = VDefault>(options: AbstractValueIteratorOptions<K, V>): AbstractValueIterator<typeof this, K, V>;
+    /**
+     * Delete all entries or a range.
+     */
+    clear(): Promise<void>;
+}

package/types/Level.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;

package/types/Log.d.ts

@@ -0,0 +1,30 @@
+import { ParseAbiItem, AbiParametersToPrimitiveTypes, AbiParameter } from 'abitype';
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { Log as viemLog } from "viem";
+/**
+ * Convert the signature to ABI type with `ParseAbiItem` and extract the inputs as `AbiParameter[]`.
+ * So the returned type can be used in `AbiParametersToPrimitiveTypes`.
+ */
+export type EventAbiInputs<signature extends EventSignature> = ParseAbiItem<signature> extends {
+    inputs: infer Inputs;
+} ? Inputs extends readonly AbiParameter[] ? Inputs : never : never;
+/**
+ * Not necessary but more readable, it just wrap the `AbiParametersToPrimitiveTypes` with the previous type `EventAbiInputs`.
+ */
+export type EventArgsTypes<signature extends EventSignature> = AbiParametersToPrimitiveTypes<EventAbiInputs<signature>>;
+/**
+ * Check if all the keys have a name. To decide if final type is object or array.
+ */
+type HasAllNames<Inputs extends {
+    name: string;
+}[]> = undefined extends Inputs[number]['name'] ? false : true;
+/**
+ * Create the object using both EventAbiInputs for keys and the converted types for values.
+ */
+export type EventArgs<signature extends EventSignature> = HasAllNames<EventAbiInputs<signature>> extends true ? {
+    [K in EventAbiInputs<signature>[number]['name']]: EventArgsTypes<signature>[number];
+} : EventArgsTypes<signature>;
+export type Log<signature extends EventSignature> = viemLog & {
+    args: EventArgs<signature>;
+};
+export {};

package/types/Log.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Saver.d.ts

@@ -0,0 +1,16 @@
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { Log } from "./Log";
+import { IDatabaseItem } from "./Level";
+import { Address } from "abitype";
+export type onLogFn<signature extends EventSignature> = (event: Log<signature>, oldData?: IDatabaseItem) => IDatabaseItem;
+export type getItemIDFn<signature extends EventSignature> = (log: Log<signature>) => Address;
+export interface ISaverConfig<signature extends EventSignature> {
+    dbID: string;
+    getItemID?: getItemIDFn<signature>;
+    onLog: onLogFn<signature>;
+}
+export interface ICommit {
+    type: "put";
+    key: string;
+    value: IDatabaseItem;
+}

package/types/Saver.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/types/Syncer.d.ts

@@ -0,0 +1,20 @@
+import { IDatabaseItem } from "./Level";
+import { ISaverConfig } from "./Saver";
+import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
+import { IWatcherConfig } from "./Watcher";
+import { Log } from "./Log";
+export type ISyncerConfig<signature extends EventSignature> = ISaverConfig<signature> & IWatcherConfig<signature> & {
+    commitInterval?: number;
+};
+export interface ISyncerEvents<signature extends EventSignature> {
+    commit: {
+        commits: {
+            type: "put";
+            key: string;
+            value: IDatabaseItem;
+        }[];
+    };
+    log: {
+        log: Log<signature>;
+    };
+}

package/types/Syncer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Watcher.d.ts

@@ -1,131 +1,11 @@
-import { AbstractBatchOperation, AbstractBatchOptions, AbstractChainedBatch, AbstractIterator, AbstractIteratorOptions, AbstractKeyIterator, AbstractKeyIteratorOptions, AbstractOpenOptions, AbstractValueIterator, AbstractValueIteratorOptions } from "abstract-level";
-import { AbiEvent, Address, Log as viemLog } from "viem";
-import { ParseAbiItem, AbiParametersToPrimitiveTypes, AbiParameter } from 'abitype';
 import { EventSignature } from "abitype/dist/types/human-readable/types/signatures";
-/**
- * Convert the signature to ABI type with `ParseAbiItem` and extract the inputs as `AbiParameter[]`.
- * So the returned type can be used in `AbiParametersToPrimitiveTypes`.
- */
-export type EventAbiInputs<signature extends EventSignature> = ParseAbiItem<signature> extends {
-    inputs: infer Inputs;
-} ? Inputs extends readonly AbiParameter[] ? Inputs : never : never;
-/**
- * Not necessary but more readable, it just wrap the `AbiParametersToPrimitiveTypes` with the previous type `EventAbiInputs`.
- */
-export type EventArgsTypes<signature extends EventSignature> = AbiParametersToPrimitiveTypes<EventAbiInputs<signature>>;
-/**
- * Check if all the keys have a name. To decide if final type is object or array.
- */
-type HasAllNames<Inputs extends {
-    name: string;
-}[]> = undefined extends Inputs[number]['name'] ? false : true;
-/**
- * Create the object using both EventAbiInputs for keys and the converted types for values.
- */
-export type EventArgs<signature extends EventSignature> = HasAllNames<EventAbiInputs<signature>> extends true ? {
-    [K in EventAbiInputs<signature>[number]['name']]: EventArgsTypes<signature>[number];
-} : EventArgsTypes<signature>;
-export type Log<signature extends EventSignature> = viemLog & {
-    args: EventArgs<signature>;
-};
-export interface ISimplifiedWatcher {
-    db: IAbstractLevel<string, WatcherSchema>;
-    event: AbiEvent;
-    addresses: Address[];
-    lastSyncedBlockNumber: bigint;
-    on: <T extends keyof IWatcherEvents>(eventName: T, callback: IWatcherEvents[T]) => void;
-}
-export interface IWatcherEvents {
-    change: (data: {
-        id: string;
-        state: any;
-    }) => void;
-}
-export type WatcherSchema = {
-    [key: string]: number | boolean | string;
-};
+import { Address } from "viem";
+import { Log } from "./Log";
 export interface IWatcherConfig<signature extends EventSignature> {
-    dbID: string;
     event: signature;
-    extractIdentifier?: (event: Log<signature>) => string;
-    onLog: (event: Log<signature>, oldWatcher?: WatcherSchema) => WatcherSchema;
-    addresses: Address[];
+    requestInterval?: number;
+    contracts?: Address[];
 }
-export interface IDBEnvironment {
-    lastSyncedBlockNumber?: string;
-}
-/**
- * For more modularity, LevelDB instance is injected by user, so we need to provide a generic type for LevelDB.
- * Every LevelDB implementation must implement this (minimized) interface to avoid errors.
- */
-export interface LevelDBConstructor<K = any, V = any> {
-    new (path: string, options?: any): IAbstractLevel<K, V>;
-}
-export declare class IAbstractLevel<KDefault = string, VDefault = string> {
-    /**
-    * Open the database.
-    */
-    open(): Promise<void>;
-    open(options: AbstractOpenOptions): Promise<void>;
-    /**
-     * Get a value from the database by {@link key}.
-     */
-    get(key: KDefault): Promise<VDefault>;
-    get(key: KDefault, callback: (err: any, value: VDefault) => void): Promise<VDefault>;
-    /**
-     * Get multiple values from the database by an array of {@link keys}.
-     */
-    getMany(keys: KDefault[]): Promise<VDefault[]>;
-    /**
-     * Add a new entry or overwrite an existing entry.
-     */
-    put(key: KDefault, value: VDefault): Promise<void>;
-    /**
-     * Delete an entry by {@link key}.
-     */
-    del(key: KDefault): Promise<void>;
-    /**
-     * Perform multiple _put_ and/or _del_ operations in bulk.
-     */
-    batch(operations: Array<AbstractBatchOperation<typeof this, KDefault, VDefault>>): Promise<void>;
-    batch<K = KDefault, V = VDefault>(operations: Array<AbstractBatchOperation<typeof this, K, V>>, options: AbstractBatchOptions<K, V>): Promise<void>;
-    batch(): AbstractChainedBatch<typeof this, KDefault, VDefault>;
-    /**
-        * Create an iterator. For example:
-        *
-        * ```js
-        * for await (const [key, value] of db.iterator({ gte: 'a' })) {
-        *   console.log([key, value])
-        * }
-        * ```
-        */
-    iterator(): AbstractIterator<typeof this, KDefault, VDefault>;
-    iterator<K = KDefault, V = VDefault>(options: AbstractIteratorOptions<K, V>): AbstractIterator<typeof this, K, V>;
-    /**
-     * Create a key iterator. For example:
-     *
-     * ```js
-     * for await (const key of db.keys({ gte: 'a' })) {
-     *   console.log(key)
-     * }
-     * ```
-     */
-    keys(): AbstractKeyIterator<typeof this, KDefault>;
-    keys<K = KDefault>(options: AbstractKeyIteratorOptions<K>): AbstractKeyIterator<typeof this, K>;
-    /**
-     * Create a value iterator. For example:
-     *
-     * ```js
-     * for await (const value of db.values({ gte: 'a' })) {
-     *   console.log(value)
-     * }
-     * ```
-     */
-    values(): AbstractValueIterator<typeof this, KDefault, VDefault>;
-    values<K = KDefault, V = VDefault>(options: AbstractValueIteratorOptions<K, V>): AbstractValueIterator<typeof this, K, V>;
-    /**
-     * Delete all entries or a range.
-     */
-    clear(): Promise<void>;
+export interface IWatcherEvents {
+    log: (log: Log<any>) => void;
 }
-export {};

package/types/Watcher.js

@@ -1,5 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 ;
-;
-;