@lunarislab/state-sync 1.1.16 → 1.1.18

package/classes/Syncer.js

@@ -4,6 +4,7 @@ exports.Syncer = void 0;
 const Watcher_1 = require("./Watcher");
 const Saver_1 = require("./Saver");
 const SimpleEmitter_1 = require("./SimpleEmitter");
+const viem_1 = require("viem");
 class Syncer extends SimpleEmitter_1.SimpleEmitter {
     constructor(client, config) {
         super();
@@ -11,8 +12,9 @@ class Syncer extends SimpleEmitter_1.SimpleEmitter {
         this.logs = [];
         this.lastPush = 0;
         this.commitInterval = config.commitInterval || 100;
+        const checksumed = config.contracts.map(c => (0, viem_1.checksumAddress)(c));
         this.watcher = new Watcher_1.Watcher(client, {
-            contracts: config.contracts,
+            contracts: checksumed,
             event: config.event
         });
         this.saver = new Saver_1.Saver(client, {
@@ -23,35 +25,35 @@ class Syncer extends SimpleEmitter_1.SimpleEmitter {
     }
     ;
     async _commit() {
-        const date = Date.now();
-        // If the last push was less than "commitInterval" 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 });
+        // start the recursive commit process
+        await new Promise(x => setTimeout(x, this.commitInterval));
+        this._commit();
     }
+    ;
     async start() {
         await this.saver.init();
         this.watcher.on('log', async (log) => {
             this.emit('log', { log: log });
             this.logs.push(log);
-            await this._commit();
         });
-        await this.watcher.start();
+        const env = await this.saver.getEnv();
+        const fromBlock = BigInt(env.lastBlockNum);
+        await this.watcher.start(fromBlock);
+        this._commit();
     }
     ;
     async addContracts(contracts) {
-        await this.watcher.addContracts(contracts);
+        const checksumed = contracts.map(c => (0, viem_1.checksumAddress)(c));
+        await this.watcher.addContracts(checksumed);
     }
     ;
     async removeContracts(contracts) {
-        await this.watcher.removeContracts(contracts);
-        for (const contract of contracts) {
+        const checksumed = contracts.map(c => (0, viem_1.checksumAddress)(c));
+        await this.watcher.removeContracts(checksumed);
+        for (const contract of checksumed) {
             await this.saver.db.del(contract);
         }
         ;

package/classes/Watcher.d.ts

@@ -11,13 +11,14 @@ export declare class Watcher<signature extends EventSignature> {
     protected client: StateSync;
     protected emitter: EventEmitter;
     protected currentBlockNum: bigint;
-    protected contracts: Address[];
+    protected contracts: Set<Address>;
     protected event: EventSignature;
     protected requestInterval: number;
     protected started: boolean;
     constructor(client: StateSync, config: IWatcherConfig<signature>);
+    protected getContracts(): `0x${string}`[];
     protected _getLogs(contracts: Address[], fromBlock?: bigint): Promise<void>;
-    start(): Promise<void>;
+    start(fromBlock?: bigint): Promise<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

@@ -13,12 +13,15 @@ class Watcher {
         this.currentBlockNum = 0n;
         this.started = false;
         this.emitter = new events_1.EventEmitter();
-        this.contracts = config.contracts || [];
+        this.contracts = new Set(config.contracts) || new Set();
         this.requestInterval = config.requestInterval || 50;
         this.event = config.event;
         this.client.on("newBlock", ({ block }) => this.currentBlockNum = block.number);
     }
     ;
+    getContracts() {
+        return Array.from(this.contracts);
+    }
     async _getLogs(contracts, fromBlock = 0n) {
         let gap = this.currentBlockNum;
         let block = fromBlock;
@@ -44,16 +47,16 @@ class Watcher {
         }
     }
     ;
-    async start() {
+    async start(fromBlock) {
         if (this.started)
             throw new Error("Already started");
         this.currentBlockNum = await this.client.public.getBlockNumber();
         this.started = true;
-        this._getLogs(this.contracts).then(() => {
+        this._getLogs(this.getContracts(), fromBlock).then(() => {
             this.client.on("newBlock", async ({ block }) => {
                 const logs = await this.client.public.getLogs({
                     blockHash: block.hash,
-                    address: this.contracts,
+                    address: this.getContracts(),
                     event: (0, viem_1.parseAbiItem)(this.event),
                 });
                 logs.forEach(l => this.emitter.emit("log", l));
@@ -63,17 +66,11 @@ class Watcher {
     ;
     async addContracts(contracts) {
         await this._getLogs(contracts);
-        this.contracts.push(...contracts);
+        this.contracts.forEach(c => this.contracts.add(c));
     }
     ;
     async removeContracts(contracts) {
-        for (const contract of contracts) {
-            const index = this.contracts.indexOf(contract);
-            if (index === -1)
-                continue;
-            this.contracts.splice(index, 1);
-        }
-        ;
+        contracts.forEach(c => this.contracts.delete(c));
     }
     ;
     on(event, cb) {

package/package.json

@@ -8,7 +8,7 @@
     "viem": "^2.21.58"
   },
   "name": "@lunarislab/state-sync",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "main": "index.js",
   "scripts": {
     "test": "ts-node ./test.ts",

package/types/Watcher.d.ts

@@ -4,7 +4,7 @@ import { Log } from "./Log";
 export interface IWatcherConfig<signature extends EventSignature> {
     event: signature;
     requestInterval?: number;
-    contracts?: Address[];
+    contracts: Address[];
 }
 export interface IWatcherEvents {
     log: (log: Log<any>) => void;