Merge pull request #1539 from multiversx/development

Development to main

Author: bogdan-rosianu

src/endpoints/accounts/account.service.ts

@@ -182,17 +182,20 @@ export class AccountService {
       }
 
       if (AddressUtils.isSmartContractAddress(address) && account.code) {
-        const deployTxHash = await this.getAccountDeployedTxHash(address);
+        const [deployTxHash, deployedAt, isVerified] = await Promise.all([
+          this.getAccountDeployedTxHash(address),
+          this.getAccountDeployedAt(address),
+          this.getAccountIsVerified(address, account.codeHash),
+        ]);
+
         if (deployTxHash) {
           account.deployTxHash = deployTxHash;
         }
 
-        const deployedAt = await this.getAccountDeployedAt(address);
         if (deployedAt) {
           account.deployedAt = deployedAt;
         }
 
-        const isVerified = await this.getAccountIsVerified(address, account.codeHash);
         if (isVerified) {
           account.isVerified = isVerified;
         }

src/endpoints/blocks/block.service.ts

@@ -10,6 +10,7 @@ import { IndexerService } from "src/common/indexer/indexer.service";
 import { NodeService } from "../nodes/node.service";
 import { IdentitiesService } from "../identities/identities.service";
 import { ApiConfigService } from "../../common/api-config/api.config.service";
+import { ConcurrencyUtils } from "src/utils/concurrency.utils";
 
 @Injectable()
 export class BlockService {
@@ -34,8 +35,8 @@ export class BlockService {
 
   async getBlocks(filter: BlockFilter, queryPagination: QueryPagination, withProposerIdentity?: boolean): Promise<Block[]> {
     const result = await this.indexerService.getBlocks(filter, queryPagination);
-    const blocks = [];
-    for (const item of result) {
+
+    const blocks = await Promise.all(result.map(async (item) => {
       const blockRaw = await this.computeProposerAndValidators(item);
 
       const block = Block.mergeWithElasticResponse(new Block(), blockRaw);
@@ -44,8 +45,8 @@ export class BlockService {
         block.scheduledRootHash = blockRaw.scheduledData.rootHash;
       }
 
-      blocks.push(block);
-    }
+      return block;
+    }));
 
     if (withProposerIdentity === true) {
       await this.applyProposerIdentity(blocks);
@@ -58,17 +59,19 @@ export class BlockService {
     const proposerBlses = blocks.map(x => x.proposer);
 
     const nodes = await this.nodeService.getAllNodes();
-    for (const node of nodes) {
-      if (!proposerBlses.includes(node.bls)) {
-        continue;
-      }
-
-      const nodeIdentity = node.identity;
-      if (!nodeIdentity) {
-        continue;
-      }
-
-      const identity = await this.identitiesService.getIdentity(nodeIdentity);
+    const relevantNodes = nodes.filter(node => proposerBlses.includes(node.bls) && node.identity);
+
+    const nodeIdentities = await ConcurrencyUtils.executeWithConcurrencyLimit(
+      relevantNodes,
+      async (node) => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const identity = await this.identitiesService.getIdentity(node.identity!);
+        return { node, identity };
+      },
+      25,
+      'Block proposer identities'
+    );
+    for (const { node, identity } of nodeIdentities) {
       if (!identity) {
         continue;
       }

src/endpoints/collections/collection.controller.ts

@@ -225,6 +225,7 @@ export class CollectionController {
   @ApiQuery({ name: 'nonceAfter', description: 'Return all NFTs with given nonce after the given number', required: false, type: Number })
   @ApiQuery({ name: 'withOwner', description: 'Return owner where type = NonFungibleESDT', required: false, type: Boolean })
   @ApiQuery({ name: 'withSupply', description: 'Return supply where type = SemiFungibleESDT', required: false, type: Boolean })
+  @ApiQuery({ name: 'withAssets', description: 'Return assets information (defaults to true)', required: false, type: Boolean })
   @ApiQuery({ name: 'sort', description: 'Sorting criteria', required: false, enum: SortCollectionNfts })
   @ApiQuery({ name: 'order', description: 'Sorting order (asc / desc)', required: false, enum: SortOrder })
   async getNfts(
@@ -244,6 +245,7 @@ export class CollectionController {
     @Query('nonceAfter', ParseIntPipe) nonceAfter?: number,
     @Query('withOwner', ParseBoolPipe) withOwner?: boolean,
     @Query('withSupply', ParseBoolPipe) withSupply?: boolean,
+    @Query('withAssets', ParseBoolPipe) withAssets?: boolean,
     @Query('sort', new ParseEnumPipe(SortCollectionNfts)) sort?: SortCollectionNfts,
     @Query('order', new ParseEnumPipe(SortOrder)) order?: SortOrder,
   ): Promise<Nft[]> {
@@ -255,7 +257,7 @@ export class CollectionController {
     return await this.nftService.getNfts(
       new QueryPagination({ from, size }),
       new NftFilter({ search, identifiers, collection, name, tags, creator, hasUris, isWhitelistedStorage, isNsfw, traits, nonceBefore, nonceAfter, sort, order }),
-      new NftQueryOptions({ withOwner, withSupply }),
+      new NftQueryOptions({ withOwner, withSupply, withAssets }),
     );
   }
 

src/endpoints/collections/collection.service.ts

@@ -169,10 +169,12 @@ export class CollectionService {
   async batchGetCollectionsAssets(identifiers: string[]): Promise<{ [key: string]: TokenAssets | undefined }> {
     const collectionsAssets: { [key: string]: TokenAssets | undefined } = {};
 
+    const allAssets = await this.assetsService.getAllTokenAssets();
+
     await this.cachingService.batchApplyAll(
       identifiers,
       identifier => CacheInfo.EsdtAssets(identifier).key,
-      identifier => this.assetsService.getTokenAssets(identifier),
+      identifier => Promise.resolve(allAssets[identifier]),
       (identifier, properties) => collectionsAssets[identifier] = properties,
       CacheInfo.EsdtAssets('').ttl
     );

src/endpoints/nfts/entities/nft.query.options.ts

@@ -3,11 +3,16 @@ import { BadRequestException } from "@nestjs/common";
 export class NftQueryOptions {
   constructor(init?: Partial<NftQueryOptions>) {
     Object.assign(this, init);
+
+    if (this.withAssets === undefined) {
+      this.withAssets = true;
+    }
   }
 
   withOwner?: boolean;
   withSupply?: boolean;
   withReceivedAt?: boolean;
+  withAssets?: boolean;
 
   validate(size: number): void {
     if (this.withReceivedAt && size > 25) {

src/endpoints/nfts/nft.service.ts

@@ -70,7 +70,7 @@ export class NftService {
     const nfts = await this.getNftsInternal({ from, size }, filter);
 
     await Promise.all([
-      this.batchApplyAssetsAndTicker(nfts),
+      this.conditionallyApplyAssetsAndTicker(nfts, undefined, queryOptions),
       this.conditionallyApplyOwners(nfts, queryOptions),
       this.conditionallyApplySupply(nfts, queryOptions),
       this.batchProcessNfts(nfts),
@@ -88,23 +88,25 @@ export class NftService {
     ]);
   }
 
-  private async batchApplyAssetsAndTicker(nfts: Nft[], fields?: string[]): Promise<void> {
+  private async conditionallyApplyAssetsAndTicker(nfts: Nft[], fields?: string[], queryOptions?: { withAssets?: boolean }): Promise<void> {
     if (fields && fields.includesNone(['ticker', 'assets'])) {
       return;
     }
 
-    await Promise.all(
-      nfts.map(async (nft) => {
-        nft.assets = await this.assetsService.getTokenAssets(nft.identifier) ??
-          await this.assetsService.getTokenAssets(nft.collection);
-
-        if (nft.assets) {
-          nft.ticker = nft.collection.split('-')[0];
-        } else {
-          nft.ticker = nft.collection;
-        }
-      })
-    );
+    const allAssets = await this.assetsService.getAllTokenAssets();
+    if (queryOptions?.withAssets === false) {
+      return;
+    }
+
+    for (const nft of nfts) {
+      nft.assets = allAssets[nft.identifier] ?? allAssets[nft.collection];
+
+      if (nft.assets) {
+        nft.ticker = nft.collection.split('-')[0];
+      } else {
+        nft.ticker = nft.collection;
+      }
+    }
   }
 
   private async conditionallyApplyOwners(nfts: Nft[], queryOptions?: NftQueryOptions): Promise<void> {

src/endpoints/tokens/token.service.ts

@@ -93,16 +93,19 @@ export class TokenService {
 
     this.applyTickerFromAssets(token);
 
-    await this.applySupply(token, supplyOptions);
-
-    if (token.type === TokenType.FungibleESDT) {
-      token.roles = await this.getTokenRoles(identifier);
-    } else if (token.type === TokenType.MetaESDT) {
-      const elasticCollection = await this.indexerService.getCollection(identifier);
-      if (elasticCollection) {
-        await this.collectionService.applyCollectionRoles(token, elasticCollection);
-      }
-    }
+    await Promise.all([
+      this.applySupply(token, supplyOptions),
+      (async () => {
+        if (token.type === TokenType.FungibleESDT) {
+          token.roles = await this.getTokenRoles(identifier);
+        } else if (token.type === TokenType.MetaESDT) {
+          const elasticCollection = await this.indexerService.getCollection(identifier);
+          if (elasticCollection) {
+            await this.collectionService.applyCollectionRoles(token, elasticCollection);
+          }
+        }
+      })(),
+    ]);
 
     return token;
   }
@@ -760,8 +763,10 @@ export class TokenService {
 
     this.logger.log(`Fetched ${tokens.length} fungible tokens`);
 
+    const allAssets = await this.assetsService.getAllTokenAssets();
+
     for (const token of tokens) {
-      const assets = await this.assetsService.getTokenAssets(token.identifier);
+      const assets = allAssets[token.identifier];
 
       if (assets && assets.name) {
         token.name = assets.name;
@@ -797,10 +802,13 @@ export class TokenService {
 
     await this.batchProcessTokens(tokens);
 
-    await this.applyMexLiquidity(tokens.filter(x => x.type !== TokenType.MetaESDT));
-    await this.applyMexPrices(tokens.filter(x => x.type !== TokenType.MetaESDT));
-    await this.applyMexPairType(tokens.filter(x => x.type !== TokenType.MetaESDT));
-    await this.applyMexPairTradesCount(tokens.filter(x => x.type !== TokenType.MetaESDT));
+    const nonMetaEsdtTokens = tokens.filter(x => x.type !== TokenType.MetaESDT);
+    await Promise.all([
+      this.applyMexLiquidity(nonMetaEsdtTokens),
+      this.applyMexPrices(nonMetaEsdtTokens),
+      this.applyMexPairType(nonMetaEsdtTokens),
+      this.applyMexPairTradesCount(nonMetaEsdtTokens),
+    ]);
 
     await this.cachingService.batchApplyAll(
       tokens,

src/endpoints/transactions/transaction.service.ts

@@ -477,7 +477,7 @@ export class TransactionService {
       if (!resultsByHash.has(txHash)) {
         resultsByHash.set(txHash, []);
       }
-      resultsByHash.get(txHash)!.push(result);
+      resultsByHash.get(txHash)?.push(result);
     }
 
     const results: Array<SmartContractResult[] | undefined> = [];

src/endpoints/transfers/transfer.service.ts

@@ -21,9 +21,16 @@ export class TransferService {
   ) { }
 
   private sortElasticTransfers(elasticTransfers: any[]): any[] {
+    const transactionMap = new Map<string, any>();
+    for (const transfer of elasticTransfers) {
+      if (transfer.txHash) {
+        transactionMap.set(transfer.txHash, transfer);
+      }
+    }
+
     for (const elasticTransfer of elasticTransfers) {
       if (elasticTransfer.originalTxHash) {
-        const transaction = elasticTransfers.find(x => x.txHash === elasticTransfer.originalTxHash);
+        const transaction = transactionMap.get(elasticTransfer.originalTxHash);
         if (transaction) {
           elasticTransfer.order = (transaction.nonce * 10) + 1;
         } else {

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

@@ -110,6 +110,7 @@ describe('Token Service', () => {
           useValue: {
             getTokenAssets: jest.fn(),
             getAllAccountAssets: jest.fn(),
+            getAllTokenAssets: jest.fn(),
           },
         },
         {
@@ -603,7 +604,7 @@ describe('Token Service', () => {
       expect(getAllTokensMock).toHaveBeenCalledTimes(1);
 
       const secondToken = mockTokens[1];
-      secondToken.assets.priceSource = {type: 'customUrl'};
+      secondToken.assets.priceSource = { type: 'customUrl' };
       const newExpectedMarketCap = result - secondToken.marketCap;
       mockTokens[1] = secondToken;
 
@@ -692,7 +693,6 @@ describe('Token Service', () => {
       });
 
       it('should return tokens from other sources when isTokensFetchFeatureEnabled is false', async () => {
-
         const mockTokenProperties: Partial<TokenProperties>[] = [{ identifier: 'mockIdentifier' }];
         let mockTokens: Partial<TokenDetailed>[] = mockTokenProperties.map(properties => ApiUtils.mergeObjects(new TokenDetailed(), properties));
         const mockTokenAssets: Partial<TokenAssets> = { name: 'mockName' };
@@ -702,6 +702,7 @@ describe('Token Service', () => {
         jest.spyOn(apiConfigService, 'isTokensFetchFeatureEnabled').mockReturnValue(false);
         jest.spyOn(esdtService, 'getAllFungibleTokenProperties').mockResolvedValue(mockTokenProperties as TokenProperties[]);
         jest.spyOn(assetsService, 'getTokenAssets').mockResolvedValue(mockTokenAssets as TokenAssets);
+        jest.spyOn(assetsService, 'getAllTokenAssets').mockResolvedValue({ mockIdentifier: mockTokenAssets, 'EGLD-000000': mockTokenAssets } as any);
         jest.spyOn(collectionService, 'getNftCollections').mockResolvedValue(mockNftCollections as NftCollection[]);
 
         jest.spyOn(tokenService as any, 'batchProcessTokens').mockImplementation(() => Promise.resolve());
@@ -723,16 +724,14 @@ describe('Token Service', () => {
         expect(apiConfigService.isTokensFetchFeatureEnabled).toHaveBeenCalled();
         expect(esdtService.getAllFungibleTokenProperties).toHaveBeenCalled();
 
-        mockTokens.forEach((mockToken) => {
-          expect(assetsService.getTokenAssets).toHaveBeenCalledWith(mockToken.identifier);
-        });
+        expect(assetsService.getAllTokenAssets).toHaveBeenCalledTimes(1);
 
-        expect(esdtService.getAllFungibleTokenProperties).toHaveBeenCalled();
         mockTokens.forEach(mockToken => {
-          expect(assetsService.getTokenAssets).toHaveBeenCalledWith(mockToken.identifier);
           mockToken.name = mockTokenAssets.name;
         });
-        expect(assetsService.getTokenAssets).toHaveBeenCalledTimes(mockTokens.length + 1); // add 1 for EGLD-000000
+
+        expect(esdtService.getAllFungibleTokenProperties).toHaveBeenCalled();
+        expect(assetsService.getTokenAssets).toHaveBeenCalledWith('EGLD-000000');
 
 
         expect((collectionService as any).getNftCollections).toHaveBeenCalledWith(expect.anything(), { type: [TokenType.MetaESDT] });
@@ -817,23 +816,26 @@ describe('Token Service', () => {
         new TokenProperties({ identifier: 'token5' }),
       ]);
 
-      // Only token2 has a custom price source
+      const mockAllAssets: { [key: string]: TokenAssets } = {
+        token1: new TokenAssets({ name: 'Token token1' }),
+        token2: new TokenAssets({
+          name: 'Token token2',
+          priceSource: {
+            type: TokenAssetsPriceSourceType.customUrl,
+            path: '0.usdPrice',
+            url: 'url',
+          },
+        }),
+        token3: new TokenAssets({ name: 'Token token3' }),
+        token4: new TokenAssets({ name: 'Token token4' }),
+        token5: new TokenAssets({ name: 'Token token5' }),
+        'EGLD-000000': new TokenAssets({ name: 'EGLD' }),
+      };
+      jest.spyOn(tokenService['assetsService'], 'getAllTokenAssets').mockResolvedValue(mockAllAssets);
+
       // eslint-disable-next-line require-await
       jest.spyOn(tokenService['assetsService'], 'getTokenAssets').mockImplementation(async (identifier: string) => {
-        if (identifier === 'token2') {
-          return new TokenAssets({
-            name: `Token ${identifier}`,
-            priceSource: {
-              type: TokenAssetsPriceSourceType.customUrl,
-              path: '0.usdPrice',
-              url: 'url',
-            },
-          });
-        }
-        return new TokenAssets({
-          name: `Token ${identifier}`,
-          // No priceSource
-        });
+        return mockAllAssets[identifier];
       });
 
       jest.spyOn(tokenService['collectionService'], 'getNftCollections').mockResolvedValue([]);
@@ -854,7 +856,7 @@ describe('Token Service', () => {
       jest.spyOn(tokenService as any, 'applyMexPrices').mockResolvedValue(undefined);
       jest.spyOn(tokenService as any, 'applyMexPairType').mockResolvedValue(undefined);
       jest.spyOn(tokenService as any, 'applyMexPairTradesCount').mockResolvedValue(undefined);
-      jest.spyOn(tokenService['apiService'] as any, 'get').mockResolvedValue({data: [{usdPrice: 1.0}]});
+      jest.spyOn(tokenService['apiService'] as any, 'get').mockResolvedValue({ data: [{ usdPrice: 1.0 }] });
       jest.spyOn(tokenService['cachingService'], 'batchApplyAll').mockImplementation(
         // eslint-disable-next-line require-await
         async (...args: unknown[]) => {