Merge pull request #778 from ElrondNetwork/development

Development to main

src/common/services/caching/entities/cache.info.ts

@@ -99,9 +99,19 @@ export class CacheInfo {
     ttl: 5 * TimeConstants.oneMinute,
   };
 
+  static AllDexTokens: CacheInfo = {
+    key: 'allDexTokens',
+    ttl: 10 * TimeConstants.oneMinute,
+  };
+
+  static AllApiTokens: CacheInfo = {
+    key: 'allApiTokens',
+    ttl: 10 * TimeConstants.oneMinute,
+  };
+
   static AllTokens: CacheInfo = {
     key: 'allTokens',
-    ttl: 10 * TimeConstants.oneMinute,
+    ttl: TimeConstants.oneMinute,
   };
 
   static EgldToken: CacheInfo = {

src/common/services/elrond-communication/elrond-api.service.ts

@@ -616,41 +616,20 @@ export class ElrondApiService {
     );
   }
 
-  async getAllMexTokens(): Promise<Token[]> {
+  async getAllDexTokens(): Promise<Token[]> {
     const allTokens = await this.doGetGeneric(
-      this.getAllMexTokens.name,
+      this.getAllDexTokens.name,
       'mex/tokens?size=10000',
     );
-    return allTokens.map((t) => Token.fromElrondApiToken(t));
+    return allTokens.map((t) => Token.fromElrondApiDexToken(t));
   }
 
-  async getAllMexTokensWithDecimals(): Promise<Token[]> {
-    const batchSize = constants.getTokensFromApiBatchSize;
-    const tokens: Token[] = await this.getAllMexTokens();
-
-    const tokenChunks = BatchUtils.splitArrayIntoChunks(tokens, batchSize);
-    for (const tokenChunk of tokenChunks) {
-      const identifiersParam = tokenChunk.map((t) => t.identifier).join(',');
-      const tokensWithDecimals = await this.doGetGeneric(
-        this.getAllMexTokensWithDecimals.name,
-        `tokens?identifiers=${identifiersParam}&fields=identifier,decimals&size=${tokenChunk.length}`,
-      );
-
-      if (!tokensWithDecimals) {
-        continue;
-      }
-
-      for (const tokenWithDecimals of tokensWithDecimals) {
-        const token = tokens.find(
-          (t) => t.identifier === tokenWithDecimals.identifier,
-        );
-        if (token) {
-          token.decimals = tokenWithDecimals.decimals;
-        }
-      }
-    }
-
-    return tokens;
+  async getAllTokens(): Promise<Token[]> {
+    const allTokens = await this.doGetGeneric(
+      this.getAllTokens.name,
+      'tokens?size=10000&fields=identifier,name,ticker,decimals',
+    );
+    return allTokens.map((t) => Token.fromElrondApiToken(t));
   }
 
   async getEgldPriceFromEconomics(): Promise<string> {

src/common/services/elrond-communication/elrond-tools.service.ts

@@ -25,7 +25,9 @@ export class ElrondToolsService {
     });
   }
 
-  async getEgldHistoricalPrice(isoDateOnly: string): Promise<string> {
+  async getEgldHistoricalPrice(
+    isoDateOnly: string,
+  ): Promise<string | undefined> {
     return await this.getTokenPriceByTimestamp(
       elrondConfig.wegld,
       elrondConfig.usdc,
@@ -37,12 +39,15 @@ export class ElrondToolsService {
     token: string,
     isoDateOnly: string,
     cachedEgldPriceUsd?: string,
-  ): Promise<string> {
+  ): Promise<string | undefined> {
     const priceInEgld = await this.getTokenPriceByTimestamp(
       token,
       elrondConfig.wegld,
       isoDateOnly,
     );
+    if (!priceInEgld) {
+      return;
+    }
     const egldPriceUsd =
       cachedEgldPriceUsd ?? (await this.getEgldHistoricalPrice(isoDateOnly));
     return new BigNumber(priceInEgld).multipliedBy(egldPriceUsd).toFixed();
@@ -68,20 +73,21 @@ export class ElrondToolsService {
     firstToken: string,
     secondToken: string,
     isoDateOnly: string,
-  ): Promise<string> {
+  ): Promise<string | undefined> {
     const query = this.getTokenPriceByTimestampQuery(
       firstToken,
       secondToken,
       isoDateOnly,
     );
     const res = await this.doPost(this.getTokenPriceByTimestamp.name, query);
-    return res.data.trading.pair.price[0].last.toFixed(20);
+    return res?.data?.trading?.pair?.price?.[0]?.last?.toFixed(20) ?? undefined;
   }
 
   private async getConfig(): Promise<ApiSettings> {
     const accessTokenInfo = await this.nativeAuthSigner.getToken();
     return {
       authorization: `Bearer ${accessTokenInfo.token}`,
+      timeout: 500,
     };
   }
 

src/common/services/elrond-communication/models/Token.model.ts

@@ -19,13 +19,21 @@ export class Token {
     Object.assign(this, init);
   }
 
-  static fromElrondApiToken(token: any): Token {
+  static fromElrondApiDexToken(token: any): Token {
     return new Token({
       identifier: token.id,
       symbol: token.symbol,
       name: token.name,
       priceUsd: token.price,
-      decimals: token.decimals ?? undefined,
+    });
+  }
+
+  static fromElrondApiToken(token: any): Token {
+    return new Token({
+      identifier: token.identifier,
+      symbol: token.ticker,
+      name: token.name,
+      decimals: token.decimals,
     });
   }
 }

src/crons/cache.warmer/tokens.warmer.service.ts

@@ -21,13 +21,12 @@ export class TokensWarmerService {
     );
   }
 
-  @Cron(CronExpression.EVERY_MINUTE)
+  @Cron(CronExpression.EVERY_10_MINUTES)
   async updateTokens() {
     await Locker.lock(
-      'MEX Tokens invalidations',
+      'Tokens invalidations',
       async () => {
-        const tokens =
-          await this.elrondApiService.getAllMexTokensWithDecimals();
+        const tokens = await this.elrondApiService.getAllTokens();
         await this.invalidateKey(
           CacheInfo.AllTokens.key,
           tokens,
@@ -38,6 +37,22 @@ export class TokensWarmerService {
     );
   }
 
+  @Cron(CronExpression.EVERY_MINUTE)
+  async updateDexTokens() {
+    await Locker.lock(
+      'DEX Tokens invalidations',
+      async () => {
+        const tokens = await this.elrondApiService.getAllDexTokens();
+        await this.invalidateKey(
+          CacheInfo.AllDexTokens.key,
+          tokens,
+          CacheInfo.AllDexTokens.ttl,
+        );
+      },
+      true,
+    );
+  }
+
   @Cron(CronExpression.EVERY_MINUTE)
   async updateEgldTokens() {
     await Locker.lock(

src/modules/asset-history/services/assets-history.nft-events.service.ts

@@ -69,6 +69,10 @@ export class AssetsHistoryNftEventService {
           });
         }
       }
+      case NftEventEnum.ESDTNFTBurn:
+      case NftEventEnum.ESDTNFTUpdateAttributes: {
+        break;
+      }
       default: {
         return this.mapNftEventLog(nonce, transferEvent.identifier, mainEvent);
       }

src/modules/assets/assets-getter.service.ts

@@ -337,6 +337,15 @@ export class AssetsGetterService {
     offset: number,
     sortByRank?: Sort,
   ): Promise<CollectionType<Asset>> {
+    for (let i = 0; i < traits.length; i++) {
+      const multipleAttributesPerTraitFilter = traits.find(
+        (t) => t.name === traits[i].name && t.value !== traits[i].value,
+      );
+      if (multipleAttributesPerTraitFilter) {
+        return new CollectionType({ items: [], count: 0 });
+      }
+    }
+
     const [nfts, count] =
       await this.nftTraitsService.getCollectionNftsByTraitsAndRanks(
         collection,

src/modules/assets/content.validation.service.ts

@@ -7,7 +7,9 @@ import { VerifyContentService } from './verify-content.service';
 export class ContentValidation {
   private status: boolean = true;
   private verifyContentService: VerifyContentService;
-  constructor(private logger: Logger) {
+  private readonly logger: Logger;
+  constructor() {
+    this.logger = new Logger(ContentValidation.name);
     this.verifyContentService = new VerifyContentService();
   }
 

src/modules/auctions/auctions-getter.service.ts

@@ -681,20 +681,14 @@ export class AuctionsGetterService {
     marketplaceKey?: string,
     collectionIdentifier?: string,
   ): Promise<Token[]> {
-    const [currentPaymentTokenIds, allMexTokens, egldToken, lkmexToken] =
-      await Promise.all([
-        this.persistenceService.getCurrentPaymentTokenIdsWithCounts(
-          marketplaceKey,
-          collectionIdentifier,
-        ),
-        this.usdPriceService.getCachedMexTokensWithDecimals(),
-        this.usdPriceService.getToken(elrondConfig.egld),
-        this.usdPriceService.getToken(elrondConfig.lkmex),
-      ]);
-
-    const allTokens: Token[] = allMexTokens
-      .concat(egldToken)
-      .concat(lkmexToken);
+    const [currentPaymentTokenIds, allTokens] = await Promise.all([
+      this.persistenceService.getCurrentPaymentTokenIdsWithCounts(
+        marketplaceKey,
+        collectionIdentifier,
+      ),
+      this.usdPriceService.getAllCachedTokens(),
+    ]);
+
     let mappedTokens = [];
     for (const payment of currentPaymentTokenIds) {
       const token = allTokens.find(

src/modules/nftCollections/collection-nfts.redis-handler.ts

@@ -72,7 +72,7 @@ export class CollectionsNftsRedisHandler extends BaseCollectionsAssetsRedisHandl
     let nftsGroupByCollection: { [key: string]: any[] } = {};
 
     for (const nfts of nftsResponse) {
-      nftsGroupByCollection[nfts[0]?.collection] = nfts;
+      nftsGroupByCollection[nfts?.[0]?.collection] = nfts;
     }
     return nftsGroupByCollection;
   }

src/modules/usdPrice/usd-price.module.ts

@@ -3,9 +3,15 @@ import { ElrondCommunicationModule } from 'src/common/services/elrond-communicat
 import { UsdPriceService } from './usd-price.service';
 import { UsdPriceRedisHandler } from './usd-price.redis-handler';
 import { UsdPriceResolver } from './usd-price.resolver';
+import { UsdTokenPriceResolver } from './usd-token-price.resolver';
 
 @Module({
-  providers: [UsdPriceResolver, UsdPriceRedisHandler, UsdPriceService],
+  providers: [
+    UsdPriceResolver,
+    UsdTokenPriceResolver,
+    UsdPriceRedisHandler,
+    UsdPriceService,
+  ],
   imports: [ElrondCommunicationModule],
   exports: [UsdPriceService],
 })