use events index instead of logs

Author: bogdan-rosianu

src/common/indexer/elastic/elastic.indexer.service.ts

@@ -594,14 +594,14 @@ export class ElasticIndexerService implements IndexerInterface {
   async getTransactionLogs(hashes: string[]): Promise<any[]> {
     const queries = [];
     for (const hash of hashes) {
-      queries.push(QueryType.Match('_id', hash));
+      queries.push(QueryType.Match('txHash', hash));
     }
 
     const elasticQueryLogs = ElasticQuery.create()
       .withPagination({ from: 0, size: 10000 })
       .withCondition(QueryConditionOptions.should, queries);
 
-    return await this.elasticService.getList('logs', 'id', elasticQueryLogs);
+    return await this.elasticService.getList('events', 'id', elasticQueryLogs);
   }
 
   async getTransactionScResults(txHash: string): Promise<any[]> {

src/common/indexer/entities/index.ts

@@ -12,5 +12,5 @@ export { Tag } from './tag';
 export { Token } from './token';
 export { TokenAccount, TokenType } from './token.account';
 export { Transaction } from './transaction';
-export { TransactionLog, TransactionLogEvent } from './transaction.log';
+export { TransactionLog, TransactionLogEvent, ElasticTransactionLogEvent } from './transaction.log';
 export { TransactionReceipt } from './transaction.receipt';

src/common/indexer/entities/transaction.log.ts

@@ -13,3 +13,15 @@ export interface TransactionLogEvent {
   data?: string;
   order: number;
 }
+
+export interface ElasticTransactionLogEvent {
+  address: string;
+  identifier: string;
+  topics: string[];
+  data?: string;
+  order: number;
+  txHash: string;
+  originalTxHash: string;
+  logAddress: string;
+  additionalData?: string[];
+}

src/common/indexer/indexer.interface.ts

@@ -12,7 +12,7 @@ import { TokenWithRolesFilter } from "src/endpoints/tokens/entities/token.with.r
 import { TransactionFilter } from "src/endpoints/transactions/entities/transaction.filter";
 import { TokenAssets } from "../assets/entities/token.assets";
 import { QueryPagination } from "../entities/query.pagination";
-import { Account, AccountHistory, AccountTokenHistory, Block, Collection, MiniBlock, Operation, Round, ScDeploy, ScResult, Tag, Token, TokenAccount, Transaction, TransactionLog, TransactionReceipt } from "./entities";
+import { Account, AccountHistory, AccountTokenHistory, Block, Collection, MiniBlock, Operation, Round, ScDeploy, ScResult, Tag, Token, TokenAccount, Transaction, ElasticTransactionLogEvent, TransactionReceipt } from "./entities";
 import { AccountAssets } from "../assets/entities/account.assets";
 import { ProviderDelegators } from "./entities/provider.delegators";
 import { ApplicationFilter } from "src/endpoints/applications/entities/application.filter";
@@ -134,7 +134,7 @@ export interface IndexerInterface {
 
   getTokensForAddress(address: string, queryPagination: QueryPagination, filter: TokenFilter): Promise<Token[]>
 
-  getTransactionLogs(hashes: string[]): Promise<TransactionLog[]>
+  getTransactionLogs(hashes: string[]): Promise<ElasticTransactionLogEvent[]>
 
   getTransactionScResults(txHash: string): Promise<ScResult[]>
 

src/common/indexer/indexer.service.ts

@@ -11,7 +11,7 @@ import { TransactionFilter } from "src/endpoints/transactions/entities/transacti
 import { MetricsEvents } from "src/utils/metrics-events.constants";
 import { TokenAssets } from "../assets/entities/token.assets";
 import { QueryPagination } from "../entities/query.pagination";
-import { Account, AccountHistory, AccountTokenHistory, Block, Collection, MiniBlock, Operation, Round, ScDeploy, ScResult, Tag, Token, TokenAccount, Transaction, TransactionLog, TransactionReceipt } from "./entities";
+import { Account, AccountHistory, AccountTokenHistory, Block, Collection, MiniBlock, Operation, Round, ScDeploy, ScResult, Tag, Token, TokenAccount, Transaction, ElasticTransactionLogEvent, TransactionReceipt } from "./entities";
 import { IndexerInterface } from "./indexer.interface";
 import { LogPerformanceAsync } from "src/utils/log.performance.decorator";
 import { AccountQueryOptions } from "src/endpoints/accounts/entities/account.query.options";
@@ -302,7 +302,7 @@ export class IndexerService implements IndexerInterface {
   }
 
   @LogPerformanceAsync(MetricsEvents.SetIndexerDuration)
-  async getTransactionLogs(hashes: string[]): Promise<TransactionLog[]> {
+  async getTransactionLogs(hashes: string[]): Promise<ElasticTransactionLogEvent[]> {
     return await this.indexerInterface.getTransactionLogs(hashes);
   }
 

src/endpoints/transactions/entities/transaction.log.event.ts

@@ -21,6 +21,9 @@ export class TransactionLogEvent {
   @ApiProperty()
   data: string = '';
 
+  @ApiProperty()
+  order: number = 0;
+
   @ApiProperty()
   additionalData: string[] | undefined = undefined;
 }

src/endpoints/transactions/transaction.get.service.ts

@@ -52,7 +52,34 @@ export class TransactionGetService {
   }
 
   private async getTransactionLogsFromElasticInternal(hashes: string[]): Promise<any[]> {
-    return await this.indexerService.getTransactionLogs(hashes);
+    const rawHits = await this.indexerService.getTransactionLogs(hashes);
+
+    const logsMap: Map<string, TransactionLog> = new Map();
+
+    for (const source of rawHits) {
+      const txHash = source.txHash;
+
+      if (!logsMap.has(txHash)) {
+        logsMap.set(txHash, new TransactionLog({
+          id: txHash,
+          address: source.address,
+          events: [],
+        }));
+      }
+
+      const event = {
+        identifier: source.identifier,
+        address: source.logAddress || source.address,
+        data: BinaryUtils.hexToBase64(source.data ?? ''),
+        additionalData: source.additionalData?.map(d => BinaryUtils.hexToBase64(d)),
+        topics: source.topics?.map(t => BinaryUtils.hexToBase64(t)),
+        order: source.order ?? 0,
+      };
+
+      logsMap.get(txHash)?.events.push(ApiUtils.mergeObjects(new TransactionLogEvent(), event));
+    }
+
+    return Array.from(logsMap.values());
   }
 
   async getTransactionScResultsFromElastic(txHash: string): Promise<SmartContractResult[]> {