implement event logAddress filter

src/common/indexer/elastic/elastic.indexer.helper.ts

@@ -814,6 +814,16 @@ export class ElasticIndexerHelper {
       elasticQuery = elasticQuery.withCondition(QueryConditionOptions.must, QueryType.Match('order', filter.order));
     }
 
+    if (filter.logAddress) {
+      elasticQuery = elasticQuery.withMustMatchCondition('logAddress', filter.logAddress);
+    }
+
+    if (filter.topics && filter.topics.length > 0) {
+      for (const topic of filter.topics) {
+        elasticQuery = elasticQuery.withMustMatchCondition('topics', topic);
+      }
+    }
+
     return elasticQuery;
   }
 }

src/endpoints/events/entities/events.filter.ts

@@ -11,4 +11,6 @@ export class EventsFilter {
   before: number = 0;
   after: number = 0;
   order: number = 0;
+  logAddress: string = '';
+  topics: string[] = [];
 }

src/endpoints/events/events.controller.ts

@@ -20,26 +20,31 @@ export class EventsController {
   @ApiQuery({ name: 'from', description: 'Number of items to skip for the result set', required: false })
   @ApiQuery({ name: 'size', description: 'Number of items to retrieve', required: false })
   @ApiQuery({ name: 'address', description: 'Event address', required: false })
+  @ApiQuery({ name: 'logAddress', description: 'Event log address', required: false })
   @ApiQuery({ name: 'identifier', description: 'Event identifier', required: false })
   @ApiQuery({ name: 'txHash', description: 'Event transaction hash', required: false })
   @ApiQuery({ name: 'shard', description: 'Event shard id', required: false })
   @ApiQuery({ name: 'before', description: 'Event before timestamp', required: false })
   @ApiQuery({ name: 'after', description: 'Event after timestamp', required: false })
   @ApiQuery({ name: 'order', description: 'Event order', required: false })
+  @ApiQuery({ name: 'topics', description: 'Event topics to filter by', required: false, isArray: true })
   async getEvents(
     @Query('from', new DefaultValuePipe(0), ParseIntPipe) from: number,
     @Query('size', new DefaultValuePipe(25), ParseIntPipe) size: number,
     @Query('address', ParseAddressPipe) address: string,
+    @Query('logAddress', ParseAddressPipe) logAddress: string,
     @Query('identifier') identifier: string,
     @Query('txHash') txHash: string,
     @Query('shard', ParseIntPipe) shard: number,
     @Query('before', ParseIntPipe) before: number,
     @Query('after', ParseIntPipe) after: number,
     @Query('order', ParseIntPipe) order: number,
+    @Query('topics') topics: string | string[],
   ): Promise<Events[]> {
+    const topicsArray = topics ? (Array.isArray(topics) ? topics : [topics]) : [];
     return await this.eventsService.getEvents(
       new QueryPagination({ from, size }),
-      new EventsFilter({ address, identifier, txHash, shard, after, before, order }));
+      new EventsFilter({ address, logAddress, identifier, txHash, shard, after, before, order, topics: topicsArray }));
   }
 
   @Get('/events/count')
@@ -51,16 +56,19 @@ export class EventsController {
   @ApiQuery({ name: 'shard', description: 'Event shard id', required: false })
   @ApiQuery({ name: 'before', description: 'Event before timestamp', required: false })
   @ApiQuery({ name: 'after', description: 'Event after timestamp', required: false })
+  @ApiQuery({ name: 'topics', description: 'Event topics to filter by', required: false, isArray: true })
   async getEventsCount(
     @Query('address', ParseAddressPipe) address: string,
     @Query('identifier') identifier: string,
     @Query('txHash') txHash: string,
     @Query('shard', ParseIntPipe) shard: number,
     @Query('before', ParseIntPipe) before: number,
     @Query('after', ParseIntPipe) after: number,
+    @Query('topics') topics: string | string[],
   ): Promise<number> {
+    const topicsArray = topics ? (Array.isArray(topics) ? topics : [topics]) : [];
     return await this.eventsService.getEventsCount(
-      new EventsFilter({ address, identifier, txHash, shard, after, before }));
+      new EventsFilter({ address, identifier, txHash, shard, after, before, topics: topicsArray }));
   }
 
   @Get('/events/:txHash')

src/test/unit/services/events.spec.ts

@@ -137,6 +137,50 @@ describe('EventsService', () => {
       expect(result).toEqual(expectedEvents);
       expect(indexerService.getEvents).toHaveBeenCalledWith(pagination, filter);
     });
+
+    it('should return events filtered by log address', async () => {
+      const pagination: QueryPagination = { from: 0, size: 10 };
+      const filter: EventsFilter = new EventsFilter({ logAddress: "erd1qqqqqqqqqqqqqpgq5lgsm8lsen2gv65gwtrs25js0ktx7ltgusrqeltmln" });
+
+      const mockElasticEvents = [
+        generateMockEvent(),
+      ];
+
+      const expectedEvents = [
+        createExpectedEvent("7e3faa2a4ea5cfe8667f2e13eb27076b0452742dbe01044871c8ea109f73ebed", "transferValueOnly"),
+      ];
+
+      mockIndexerService.getEvents.mockResolvedValue(mockElasticEvents);
+
+      const result = await service.getEvents(pagination, filter);
+
+      for (const event of result) {
+        expect(event.logAddress).toEqual("erd1qqqqqqqqqqqqqpgq5lgsm8lsen2gv65gwtrs25js0ktx7ltgusrqeltmln");
+      }
+
+      expect(result).toEqual(expectedEvents);
+      expect(indexerService.getEvents).toHaveBeenCalledWith(pagination, filter);
+    });
+
+    it('should return events filtered by topics', async () => {
+      const pagination: QueryPagination = { from: 0, size: 10 };
+      const filter: EventsFilter = new EventsFilter({ topics: ["2386f26fc10000"] });
+
+      const mockElasticEvents = [
+        generateMockEvent(),
+      ];
+
+      const expectedEvents = [
+        createExpectedEvent("7e3faa2a4ea5cfe8667f2e13eb27076b0452742dbe01044871c8ea109f73ebed", "transferValueOnly"),
+      ];
+
+      mockIndexerService.getEvents.mockResolvedValue(mockElasticEvents);
+
+      const result = await service.getEvents(pagination, filter);
+
+      expect(result).toEqual(expectedEvents);
+      expect(indexerService.getEvents).toHaveBeenCalledWith(pagination, filter);
+    });
   });
 
   describe('getEventsCount', () => {