update applications endpoint (#1443)

* update applications endpoint

* implement cache system

* added max size withTxCount request

* return single application details

* add getApplicationBalance private method to be able to reuse the same functionallity

* simplify txCount for single application

* Update GitHub Actions workflow to use actions/upload-artifact@v4

* bump version actions/download-artifact@v4

* refactor

* update cs tests

* fixes after review

Author: cfaur09

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

@@ -974,6 +974,10 @@ export class ElasticIndexerService implements IndexerInterface {
     return await this.elasticService.getList('scdeploys', 'address', elasticQuery);
   }
 
+  async getApplication(address: string): Promise<any> {
+    return await this.elasticService.getItem('scdeploys', 'address', address);
+  }
+
   async getApplicationCount(filter: ApplicationFilter): Promise<number> {
     const elasticQuery = this.indexerHelper.buildApplicationFilter(filter);
 

src/common/indexer/indexer.interface.ts

@@ -188,6 +188,8 @@ export interface IndexerInterface {
 
   getApplicationCount(filter: ApplicationFilter): Promise<number>
 
+  getApplication(address: string): Promise<any>
+
   getAddressesWithTransfersLast24h(): Promise<string[]>
 
   getEvents(pagination: QueryPagination, filter: EventsFilter): Promise<Events[]>

src/common/indexer/indexer.service.ts

@@ -446,6 +446,11 @@ export class IndexerService implements IndexerInterface {
     return await this.indexerInterface.getApplications(filter, pagination);
   }
 
+  @LogPerformanceAsync(MetricsEvents.SetIndexerDuration)
+  async getApplication(address: string): Promise<any> {
+    return await this.indexerInterface.getApplication(address);
+  }
+
   @LogPerformanceAsync(MetricsEvents.SetIndexerDuration)
   async getApplicationCount(filter: ApplicationFilter): Promise<number> {
     return await this.indexerInterface.getApplicationCount(filter);

src/endpoints/applications/application.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, DefaultValuePipe, Get, Query } from "@nestjs/common";
+import { Controller, DefaultValuePipe, Get, Param, Query } from "@nestjs/common";
 import { ApiOkResponse, ApiOperation, ApiQuery, ApiTags } from "@nestjs/swagger";
 import { ApplicationService } from "./application.service";
 import { QueryPagination } from "src/common/entities/query.pagination";
 import { ApplicationFilter } from "./entities/application.filter";
-import { ParseIntPipe } from "@multiversx/sdk-nestjs-common";
+import { ParseIntPipe, ParseBoolPipe, ParseAddressPipe } from "@multiversx/sdk-nestjs-common";
 import { Application } from "./entities/application";
 
 @Controller()
@@ -20,15 +20,18 @@ export class ApplicationController {
   @ApiQuery({ name: 'size', description: 'Number of items to retrieve', required: false })
   @ApiQuery({ name: 'before', description: 'Before timestamp', required: false })
   @ApiQuery({ name: 'after', description: 'After timestamp', required: false })
+  @ApiQuery({ name: 'withTxCount', description: 'Include transaction count', required: false, type: Boolean })
   async getApplications(
     @Query('from', new DefaultValuePipe(0), ParseIntPipe) from: number,
     @Query("size", new DefaultValuePipe(25), ParseIntPipe) size: number,
     @Query('before', ParseIntPipe) before?: number,
     @Query('after', ParseIntPipe) after?: number,
-  ): Promise<any[]> {
+    @Query('withTxCount', new ParseBoolPipe()) withTxCount?: boolean,
+  ): Promise<Application[]> {
+    const applicationFilter = new ApplicationFilter({ before, after, withTxCount });
     return await this.applicationService.getApplications(
       new QueryPagination({ size, from }),
-      new ApplicationFilter({ before, after })
+      applicationFilter
     );
   }
 
@@ -45,4 +48,13 @@ export class ApplicationController {
 
     return await this.applicationService.getApplicationsCount(filter);
   }
+
+  @Get("applications/:address")
+  @ApiOperation({ summary: 'Application details', description: 'Returns details of a smart contract' })
+  @ApiOkResponse({ type: Application })
+  async getApplication(
+    @Param('address', ParseAddressPipe) address: string,
+  ): Promise<Application> {
+    return await this.applicationService.getApplication(address);
+  }
 }

src/endpoints/applications/application.module.ts

@@ -2,14 +2,18 @@ import { Module } from "@nestjs/common";
 import { ElasticIndexerModule } from "src/common/indexer/elastic/elastic.indexer.module";
 import { ApplicationService } from "./application.service";
 import { AssetsService } from '../../common/assets/assets.service';
+import { GatewayService } from "src/common/gateway/gateway.service";
+import { TransferModule } from "../transfers/transfer.module";
 
 @Module({
   imports: [
     ElasticIndexerModule,
+    TransferModule,
   ],
   providers: [
     ApplicationService,
     AssetsService,
+    GatewayService,
   ],
   exports: [
     ApplicationService,

src/endpoints/applications/application.service.ts

@@ -4,33 +4,110 @@ import { Application } from './entities/application';
 import { QueryPagination } from 'src/common/entities/query.pagination';
 import { ApplicationFilter } from './entities/application.filter';
 import { AssetsService } from '../../common/assets/assets.service';
+import { GatewayService } from 'src/common/gateway/gateway.service';
+import { TransferService } from '../transfers/transfer.service';
+import { TransactionFilter } from '../transactions/entities/transaction.filter';
+import { TransactionType } from '../transactions/entities/transaction.type';
+import { Logger } from '@nestjs/common';
+import { CacheService } from '@multiversx/sdk-nestjs-cache';
+import { CacheInfo } from 'src/utils/cache.info';
 
 @Injectable()
 export class ApplicationService {
+  private readonly logger = new Logger(ApplicationService.name);
+
   constructor(
     private readonly elasticIndexerService: ElasticIndexerService,
     private readonly assetsService: AssetsService,
+    private readonly gatewayService: GatewayService,
+    private readonly transferService: TransferService,
+    private readonly cacheService: CacheService,
   ) { }
 
   async getApplications(pagination: QueryPagination, filter: ApplicationFilter): Promise<Application[]> {
+    filter.validate(pagination.size);
+
+    if (!filter.isSet) {
+      return await this.cacheService.getOrSet(
+        CacheInfo.Applications(pagination).key,
+        async () => await this.getApplicationsRaw(pagination, filter),
+        CacheInfo.Applications(pagination).ttl
+      );
+    }
+
+    return await this.getApplicationsRaw(pagination, filter);
+  }
+
+  async getApplicationsRaw(pagination: QueryPagination, filter: ApplicationFilter): Promise<Application[]> {
     const elasticResults = await this.elasticIndexerService.getApplications(filter, pagination);
     const assets = await this.assetsService.getAllAccountAssets();
 
     if (!elasticResults) {
       return [];
     }
 
-    return elasticResults.map(item => ({
+    const applications = elasticResults.map(item => new Application({
       contract: item.address,
       deployer: item.deployer,
       owner: item.currentOwner,
       codeHash: item.initialCodeHash,
       timestamp: item.timestamp,
       assets: assets[item.address],
+      balance: '0',
+      ...(filter.withTxCount && { txCount: 0 }),
     }));
+
+    const balancePromises = applications.map(application =>
+      this.getApplicationBalance(application.contract)
+        .then(balance => { application.balance = balance; })
+    );
+    await Promise.all(balancePromises);
+
+    if (filter.withTxCount) {
+      for (const application of applications) {
+        application.txCount = await this.getApplicationTxCount(application.contract);
+      }
+    }
+
+    return applications;
   }
 
   async getApplicationsCount(filter: ApplicationFilter): Promise<number> {
     return await this.elasticIndexerService.getApplicationCount(filter);
   }
+
+  async getApplication(address: string): Promise<Application> {
+    const indexResult = await this.elasticIndexerService.getApplication(address);
+    const assets = await this.assetsService.getAllAccountAssets();
+
+    const result = new Application({
+      contract: indexResult.address,
+      deployer: indexResult.deployer,
+      owner: indexResult.currentOwner,
+      codeHash: indexResult.initialCodeHash,
+      timestamp: indexResult.timestamp,
+      assets: assets[address],
+      balance: '0',
+      txCount: 0,
+    });
+
+    result.txCount = await this.getApplicationTxCount(result.contract);
+    result.balance = await this.getApplicationBalance(result.contract);
+
+    return result;
+  }
+
+  private async getApplicationTxCount(address: string): Promise<number> {
+    return await this.transferService.getTransfersCount(new TransactionFilter({ address, type: TransactionType.Transaction }));
+  }
+
+  private async getApplicationBalance(address: string): Promise<string> {
+    try {
+      const { account: { balance } } = await this.gatewayService.getAddressDetails(address);
+      return balance;
+    } catch (error) {
+      this.logger.error(`Error when getting balance for contract ${address}`, error);
+      return '0';
+    }
+  }
 }

src/endpoints/applications/entities/application.filter.ts

@@ -1,13 +1,23 @@
+import { BadRequestException } from "@nestjs/common";
+
 export class ApplicationFilter {
   constructor(init?: Partial<ApplicationFilter>) {
     Object.assign(this, init);
   }
 
   after?: number;
   before?: number;
+  withTxCount?: boolean;
+
+  validate(size: number) {
+    if (this.withTxCount && size > 25) {
+      throw new BadRequestException('Size must be less than or equal to 25 when withTxCount is set');
+    }
+  }
 
   isSet(): boolean {
     return this.after !== undefined ||
-      this.before !== undefined;
+      this.before !== undefined ||
+      this.withTxCount !== undefined;
   }
 }

src/endpoints/applications/entities/application.ts

@@ -23,4 +23,10 @@ export class Application {
 
   @ApiProperty({ type: AccountAssets, nullable: true, description: 'Contract assets' })
   assets: AccountAssets | undefined = undefined;
+
+  @ApiProperty({ type: String })
+  balance: string = '0';
+
+  @ApiProperty({ type: Number, required: false })
+  txCount?: number;
 }

src/test/chain-simulator/applications.cs-e2e.ts

@@ -33,6 +33,33 @@ describe('Applications e2e tests with chain simulator', () => {
       }
     });
 
+    it('should return applications with txCount field if withTxCount query param is true', async () => {
+      const response = await axios.get(`${config.apiServiceUrl}/applications?withTxCount=true`);
+      expect(response.status).toBe(200);
+      expect(response.data).toBeInstanceOf(Array);
+      expect(response.data[0]).toHaveProperty('txCount');
+    });
+  });
+
+  describe('GET /applications/:address', () => {
+    it('should return status code 200 and an application', async () => {
+      const application = await axios.get(`${config.apiServiceUrl}/applications`);
+      const response = await axios.get(`${config.apiServiceUrl}/applications/${application.data[0].contract}`);
+      expect(response.status).toBe(200);
+      expect(response.data).toBeInstanceOf(Object);
+    });
+
+    it('should return application details with txCount and balance fields', async () => {
+      const application = await axios.get(`${config.apiServiceUrl}/applications`);
+      const response = await axios.get(`${config.apiServiceUrl}/applications/${application.data[0].contract}`);
+      expect(response.status).toBe(200);
+      expect(response.data).toBeInstanceOf(Object);
+      expect(response.data).toHaveProperty('txCount');
+      expect(response.data).toHaveProperty('balance');
+    });
+  });
+
+  describe('GET /applications/count', () => {
     it('should return the number of applications', async () => {
       const response = await axios.get(`${config.apiServiceUrl}/applications/count`);
       expect(response.status).toBe(200);