'bump'

tenbits · tenbits · commit 937e6b599146 · 2025-08-27T13:15:13.000+02:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.1.53",
+    "version": "0.1.54",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"
diff --git a/src/contracts/ContractReader.ts b/src/contracts/ContractReader.ts
@@ -168,6 +168,11 @@ export class ContractReader implements IContractReader {
         params?: { [key: string]: any } | any[]
 
     }): Promise<RpcTypes.Filter> {
+
+        if (Array.isArray(abi) && abi.length === 1) {
+            return this.getLogsFilter(abi[0], options);
+        }
+
         let filters: Partial<RpcTypes.Filter> = {
             address: options.address,
         };
@@ -227,9 +232,15 @@ export class ContractReader implements IContractReader {
                     abi.map($abiUtils.getTopicSignature)
                 ];
                 if (options.params != null) {
-                    let paramsArr = $require.Array(options.params, `Multiple Logs are being requested. The params should be an array. `);
                     let abiInputsArr = abi.map(x => x.inputs.filter(i => i.indexed));
+
+                    let paramsArr = Array.isArray(options.params) === false
+                        ? [options.params]
+                        : options.params;
+
                     let inputsMax = alot(abiInputsArr).max(x => x.length);
+                    $require.gt(inputsMax, 0, `The ABI ${abi[0].name} has no indexed arguments.`);
+
                     for (let i = 0; i < inputsMax; i++) {
                         let options = [];
                         for (let j = 0; j < abiInputsArr.length; j++) {
diff --git a/src/indexer/EventsIndexer.ts b/src/indexer/EventsIndexer.ts
@@ -7,7 +7,7 @@ import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
 import { $date } from '@dequanto/utils/$date';
 import { $require } from '@dequanto/utils/$require';
 import { TAddress } from '@dequanto/models/TAddress';
-import { IEventsIndexerMetaStore, IEventsIndexerStore } from './storage/interfaces';
+import { IEventsIndexerMetaStore, IEventsIndexerStore, TEventsIndexerItem } from './storage/interfaces';
 import { FsEventsIndexerStore } from './storage/FsEventsIndexerStore';
 import { FsEventsMetaStore } from './storage/FsEventsMetaStore';
 import { class_Dfr } from 'atma-utils';
@@ -17,12 +17,12 @@ import { TEth } from '@dequanto/models/TEth';
 import { l } from '@dequanto/utils/$logger';
 
 
-export class EventsIndexer <T extends ContractBase> {
+export class EventsIndexer <TContract extends ContractBase> {
 
     public store: IEventsIndexerStore
     public storeMeta: IEventsIndexerMetaStore
 
-    constructor(public contract: T, public options: {
+    constructor(public contract: TContract, public options: {
         // Load events from the contract that was deployed to multiple addresses
         addresses?: TAddress[]
         name?: string
@@ -71,37 +71,40 @@ export class EventsIndexer <T extends ContractBase> {
         $require.True(this.store instanceof FsEventsIndexerStore);
         $require.True(this.storeMeta instanceof FsEventsMetaStore);
 
-        await (this.store as FsEventsIndexerStore<T>).ensureMigrated();
-        await (this.storeMeta as FsEventsMetaStore<T>).ensureMigrated();
+        await (this.store as FsEventsIndexerStore<TContract>).ensureMigrated();
+        await (this.storeMeta as FsEventsMetaStore<TContract>).ensureMigrated();
     }
 
     async getPastLogs <
-        TLogName extends GetEventLogNames<T>,
+        TLogName extends GetEventLogNames<TContract>,
     > (
         event: TLogName | TLogName[] | '*',
-        // Fetch all logs and filter later if needed
-        //- params?: T[TMethodName] extends (options: { params?: infer TParams }) => any ? TParams : never,
         filter?: {
             fromBlock?: number
             toBlock?: number
+            params?: TLogName extends keyof TContract
+                ? (TContract[TLogName] extends (options: { params?: infer TParams }) => any ? TParams : never)
+                : never,
         }
     ): Promise<{
-        logs: ITxLogItem<GetTypes<T>['Events'][TLogName]['outputParams']>[],
+        logs: ITxLogItem<GetTypes<TContract>['Events'][TLogName]['outputParams']>[],
     }> {
         let contract = this.contract;
         let client = contract.client;
         let toBlock = filter?.toBlock ?? await client.getBlockNumber();
         let events = Array.isArray(event) ? event as string[] : [ event as string ];
-        let ranges = await this.getRanges(events, this.options.initialBlockNumber, toBlock);
-        let logs = await this.getPastLogsRanges(ranges, events, toBlock, filter?.fromBlock);
-
+        let filterKey = this.getFilterKey(filter?.params);
+        let ranges = await this.getRanges(events, this.options.initialBlockNumber, toBlock, { filterKey });
+        let logs = await this.getPastLogsRanges(ranges, events, toBlock, filter?.fromBlock, {
+            params: filter?.params as any
+        });
         return {
             logs: logs as any
         };
     }
 
     async * getPastLogsStream <
-        TLogName extends GetEventLogNames<T>,
+        TLogName extends GetEventLogNames<TContract>,
     > (
         event: TLogName | TLogName[] | '*',
         // Fetch all logs and filter later if needed
@@ -110,10 +113,13 @@ export class EventsIndexer <T extends ContractBase> {
             fromBlock?: number
             toBlock?: number
             blockRangeLimits?: WClient['blockRangeLimits']
+            params?: TLogName extends keyof TContract
+                ? (TContract[TLogName] extends (options: { params?: infer TParams }) => any ? TParams : never)
+                : never,
         },
     ): AsyncGenerator<
         TLogsRangeProgress<
-            ITxLogItem<GetTypes<T>['Events'][TLogName]['outputParams'], string>
+            ITxLogItem<GetTypes<TContract>['Events'][TLogName]['outputParams'], string>
         >       // next result
         , void  // void returns
         , void  // next doesn't get any parameter
@@ -122,12 +128,16 @@ export class EventsIndexer <T extends ContractBase> {
         let client = contract.client;
         let toBlock = options?.toBlock ?? await client.getBlockNumber();
         let events = Array.isArray(event) ? event as string[] : [ event as string ];
-        let ranges = await this.getRanges(events, options?.fromBlock ?? this.options.initialBlockNumber, toBlock);
+        let filterKey = this.getFilterKey(options?.params);
+        let ranges = await this.getRanges(events, options?.fromBlock ?? this.options.initialBlockNumber, toBlock, {
+            filterKey
+        });
 
         let dfrInner = new class_Dfr<any>();
         let dfrOuter = new class_Dfr<any>();
 
         this.getPastLogsRanges(ranges, events, toBlock, options?.fromBlock, {
+            params: options?.params,
             blockRangeLimits: options?.blockRangeLimits,
             streamed: true,
             async onProgress (info) {
@@ -175,9 +185,14 @@ export class EventsIndexer <T extends ContractBase> {
         }
     }
 
-    private async getRanges (events: string[], initialBlockNumber: number, toBlock: number, fromBlock?: number): Promise<TRange[]> {
+    private async getRanges (events: string[], initialBlockNumber: number, toBlock: number, opts: {
+        fromBlock?: number
+        filterKey?: string
+    }): Promise<TRange[]> {
         let logsMetaArr = await this.storeMeta.fetch();
-        let eventsBlock = alot(logsMetaArr).toDictionary(x => x.event, x => x.lastBlock);
+        let eventsBlock = alot(logsMetaArr)
+            .filter(x => x.filterKey == opts?.filterKey)
+            .toDictionary(x => x.event, x => x.lastBlock);
         let logsMeta = events.map(event => {
             let blockNr = eventsBlock[event] ?? initialBlockNumber;
             return {
@@ -187,7 +202,7 @@ export class EventsIndexer <T extends ContractBase> {
         });
         let hasInitialBlock = logsMeta.every(x => x.lastBlock != null);
         if (hasInitialBlock === false) {
-            let blockNr = fromBlock ?? await this.getInitialBlockNumber();
+            let blockNr = opts?.fromBlock ?? await this.getInitialBlockNumber();
             logsMeta.filter(x => x.lastBlock == null).forEach(x => x.lastBlock = blockNr);
         };
 
@@ -210,7 +225,7 @@ export class EventsIndexer <T extends ContractBase> {
         }
         return ranges;
     }
-    private async getPastLogsRanges (ranges: TRange[], events: string[], toBlock: number, fromBlock?: number, options?: TEventLogOptions<TEth.Log>) {
+    private async getPastLogsRanges (ranges: TRange[], events: string[], toBlock: number, fromBlock?: number, options?: TEventLogOptions<any>) {
         // Save indexed logs every 2 minutes
         const PERSIST_INTERVAL = $date.parseTimespan('2min');
         // Save indexed logs every 10k logs
@@ -225,7 +240,8 @@ export class EventsIndexer <T extends ContractBase> {
             let arr = await this.getItemsFromStore({
                 fromBlock: fromBlock,
                 toBlock: toBlock,
-                events
+                events,
+                params: options?.params,
             });
             if (arr?.length > 0) {
                 let latestBlock = arr[arr.length - 1].blockNumber;
@@ -266,6 +282,7 @@ export class EventsIndexer <T extends ContractBase> {
                 fromBlock: fromBlock,
                 toBlock: toBlock,
                 blockRangeLimits: options?.blockRangeLimits,
+                params: options?.params,
                 onProgress: async info => {
                     onProgressCount++;
 
@@ -302,7 +319,7 @@ export class EventsIndexer <T extends ContractBase> {
                         buffer = [];
                         time = now;
                         savedCount += arr.length;
-                        await this.upsert(arr, events, info.latestBlock);
+                        await this.upsert(arr, events, info.latestBlock, options);
                     }
 
                     if (options?.onProgress) {
@@ -314,13 +331,13 @@ export class EventsIndexer <T extends ContractBase> {
             });
 
             if (buffer.length > 0) {
-                await this.upsert(buffer, events, toBlock);
+                await this.upsert(buffer, events, toBlock, options);
             }
         }
 
 
         // Upsert final, if buffer is empty, we still persist the toBlock
-        await this.upsert(buffer, events, toBlock);
+        await this.upsert(buffer, events, toBlock, options);
 
         if (isStreamed === true) {
             return;
@@ -329,7 +346,8 @@ export class EventsIndexer <T extends ContractBase> {
         let logs = await this.getItemsFromStore({
             fromBlock: fromBlock,
             toBlock: toBlock + 1,
-            events: events
+            events: events,
+            params: options?.params
         });
 
         return logs;
@@ -340,16 +358,27 @@ export class EventsIndexer <T extends ContractBase> {
         fromBlock?: number
         toBlock?: number
         events?: string[]
+        params?: Record<string, any>
     }) {
         let arr = await this.store.fetch(filter);
         let events = filter.events;
         if (events?.[0] !== '*') {
             let requestedEvents = alot(events).toDictionary(x => x);
             arr = arr.filter(x => x.event in requestedEvents);
         }
-
+        let filterKey = this.getFilterKey(filter.params);
+        arr = arr.filter(x => x.filterKey == filterKey);
         return arr;
     }
+    private getFilterKey (params) {
+        if (params == null) {
+            return;
+        }
+        let arr = Array.isArray(params)
+            ? params
+            : Object.keys(params).map(key => `${key}=${params[key]}`);
+        return arr.join('_');
+    }
 
     private async getInitialBlockNumber () {
         let client = this.contract.client;
@@ -363,11 +392,19 @@ export class EventsIndexer <T extends ContractBase> {
     }
 
     @memd.deco.queued()
-    private async upsert (logs, events: string[], latestBlock: number) {
+    private async upsert (logs: TEventsIndexerItem[], events: string[], latestBlock: number, options: { params? }) {
+        let filterKey = this.getFilterKey(options?.params);
         if (logs?.length > 0) {
+            for (let log of logs) {
+                log.filterKey = filterKey;
+            }
             await this.store.upsertMany(logs);
         }
-        const logsMeta =  events.map(event => ({ event, lastBlock: latestBlock }));
+        const logsMeta =  events.map(event => ({
+            event,
+            lastBlock: latestBlock,
+            filterKey: filterKey,
+        }));
         await this.storeMeta.upsertMany(logsMeta);
     }
 }
diff --git a/src/indexer/storage/FsEventsMetaStore.ts b/src/indexer/storage/FsEventsMetaStore.ts
@@ -33,7 +33,7 @@ export class FsEventsMetaStore <T extends ContractBase> implements IEventsIndexe
 
         this.store = new JsonArrayStore<TEventsIndexerMeta>({
             path: `${directory}meta-arr.json`,
-            key: x => x.event
+            key: x => (x.event + (x.filterKey || ''))
         });
 
         this.storeV0 = new JsonArrayStore<TEventsIndexerMeta>({
diff --git a/src/indexer/storage/interfaces.ts b/src/indexer/storage/interfaces.ts
@@ -1,20 +1,23 @@
 import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem'
 
-type TItem = ITxLogItem<any>
+export type TEventsIndexerItem = ITxLogItem<any> & {
+    filterKey?: string
+}
 
 export type TEventsIndexerMeta = {
     event: string
     lastBlock: number
+    filterKey?: string
 }
 
 export interface IEventsIndexerStore {
-    upsertMany(logs: TItem[]): Promise<TItem[]>
-    removeMany(logs: TItem[]): Promise<any>
+    upsertMany(logs: TEventsIndexerItem[]): Promise<TEventsIndexerItem[]>
+    removeMany(logs: TEventsIndexerItem[]): Promise<any>
 
     fetch (options?: {
         fromBlock?: number
         toBlock?: number
-    }): Promise<TItem[]>
+    }): Promise<TEventsIndexerItem[]>
 
     merge (store: IEventsIndexerStore): Promise<any>
 }
diff --git a/test/indexer/EventsIndexer.spec.ts b/test/indexer/EventsIndexer.spec.ts
@@ -1,6 +1,7 @@
 import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
 import { EventsIndexer } from '@dequanto/indexer/EventsIndexer';
 import { $date } from '@dequanto/utils/$date';
+import alot from 'alot';
 import { File, Directory } from 'atma-io';
 
 const FS_DIR = './test/tmp/data/logs/';
@@ -18,7 +19,7 @@ UTest({
         let client = hh.client();
         let code = `
             contract Foo {
-                event Number (uint256 num);
+                event Number (uint256 indexed num);
                 event String (string str);
 
                 function emitNumber(uint num) external {
@@ -110,10 +111,16 @@ UTest({
 
         let storageData3rdWeek = await File.readAsync<any[]>(`${BASE_DIR}${WEEK_SECONDS * 3}-${WEEK_SECONDS * 4}.json`);
         eq_(storageData3rdWeek.length, 1);
+
+        let events = await indexer.getPastLogs('Number', { params: {
+            num: '0x2'
+        } });
+
+        let nums = alot(events.logs).map(x => x.params.num).toArray();
+        deepEq_(nums, [2n]);
     },
     async 'fetch events streamed' () {
 
-
         let hh = new HardhatProvider();
         let deployer = hh.deployer();
         let client = hh.client();

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "dequanto",`
`3`		`- "version": "0.1.53",`
	`3`	`+ "version": "0.1.54",`
`4`	`4`	`"author": {`
`5`	`5`	`"name": "Alex Kit",`
`6`	`6`	`"email": "alex.kit@atmajs.com"`