Development

config/config.devnet-old.yaml

@@ -70,6 +70,7 @@ aws:
   s3Secret: ''
   s3Bucket: 'devnet-old-media.elrond.com'
   s3Region: ''
+  s3Endpoint: ''
 urls:
   self: 'https://devnet-old-api.multiversx.com'
   elastic:

config/config.devnet.yaml

@@ -122,6 +122,7 @@ aws:
   s3Secret: ''
   s3Bucket: 'devnet-media.elrond.com'
   s3Region: ''
+  s3Endpoint: ''
 urls:
   self: 'https://devnet-api.multiversx.com'
   elastic:

config/config.e2e.mainnet.yaml

@@ -126,6 +126,7 @@ aws:
   s3Secret: ''
   s3Bucket: 'media.elrond.com'
   s3Region: ''
+  s3Endpoint: ''
 urls:
   self: 'http://localhost:3001'
   elastic:

config/config.mainnet.yaml

@@ -126,6 +126,7 @@ aws:
   s3Secret: ''
   s3Bucket: 'media.elrond.com'
   s3Region: ''
+  s3Endpoint: ''
 urls:
   self: 'https://api.multiversx.com'
   elastic:

config/config.testnet.yaml

@@ -125,6 +125,7 @@ aws:
   s3Secret: ''
   s3Bucket: 'testnet-media.elrond.com'
   s3Region: ''
+  s3Endpoint: ''
 urls:
   self: 'https://testnet-api.multiversx.com'
   elastic:

src/common/api-config/api.config.service.ts

@@ -559,6 +559,11 @@ export class ApiConfigService {
     return s3Region;
   }
 
+  getAwsS3Endpoint(): string | undefined {
+    const s3Endpoint = this.configService.get<string>('aws.s3Endpoint');
+    return s3Endpoint && s3Endpoint.length > 0 ? s3Endpoint : undefined;
+  }
+
   getMetaChainShardId(): number {
     const metaChainShardId = this.configService.get<number>('metaChainShardId');
     if (metaChainShardId === undefined) {

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

@@ -250,6 +250,15 @@ export class ElasticIndexerService implements IndexerInterface {
     return await this.elasticService.getItem('blocks', 'hash', hash);
   }
 
+  async getBlockByMiniBlockHash(miniBlockHash: string): Promise<Block | undefined> {
+    const elasticQuery = ElasticQuery.create()
+      .withCondition(QueryConditionOptions.must, [QueryType.Match('miniBlocksHashes', miniBlockHash)])
+      .withSort([{ name: 'timestamp', order: ElasticSortOrder.descending }]);
+
+    const result = await this.elasticService.getList('blocks', '_search', elasticQuery);
+    return result.length > 0 ? result[0] : undefined;
+  }
+
   async getMiniBlock(miniBlockHash: string): Promise<any> {
     return await this.elasticService.getItem('miniblocks', 'miniBlockHash', miniBlockHash);
   }

src/common/indexer/entities/block.ts

@@ -4,6 +4,7 @@ export interface Block {
   round: number;
   epoch: number;
   miniBlocksHashes: string[];
+  miniBlocksDetails?: MiniBlockDetails[];
   notarizedBlocksHashes?: string[];
   proposer: number;
   validators: number[],
@@ -25,3 +26,15 @@ export interface Block {
   gasPenalized: number;
   maxGasLimit: string;
 }
+
+export interface MiniBlockDetails {
+  firstProcessedTx: number;
+  lastProcessedTx: number;
+  senderShard: number;
+  receiverShard: number;
+  mbIndex: number;
+  type: string;
+  procType: string;
+  txsHashes: string[];
+  executionOrderTxsIndices: number[];
+}

src/common/indexer/entities/index.ts

@@ -1,7 +1,7 @@
 export { Account } from './account';
 export { AccountHistory } from './account.history';
 export { AccountTokenHistory } from './account.token.history';
-export { Block } from './block';
+export { Block, MiniBlockDetails } from './block';
 export { Collection } from './collection';
 export { MiniBlock } from './miniblock';
 export { Operation } from './operation';

src/common/indexer/indexer.interface.ts

@@ -74,6 +74,8 @@ export interface IndexerInterface {
 
   getBlock(hash: string): Promise<Block>
 
+  getBlockByMiniBlockHash(miniBlockHash: string): Promise<Block | undefined>
+
   getMiniBlock(miniBlockHash: string): Promise<MiniBlock>
 
   getMiniBlocks(pagination: QueryPagination, filter: MiniBlockFilter): Promise<MiniBlock[]>

src/common/indexer/indexer.service.ts

@@ -166,6 +166,11 @@ export class IndexerService implements IndexerInterface {
     return await this.indexerInterface.getBlock(hash);
   }
 
+  @LogPerformanceAsync(MetricsEvents.SetIndexerDuration)
+  async getBlockByMiniBlockHash(miniBlockHash: string): Promise<Block | undefined> {
+    return await this.indexerInterface.getBlockByMiniBlockHash(miniBlockHash);
+  }
+
   @LogPerformanceAsync(MetricsEvents.SetIndexerDuration)
   async getMiniBlock(miniBlockHash: string): Promise<MiniBlock> {
     return await this.indexerInterface.getMiniBlock(miniBlockHash);

src/common/plugins/plugin.service.ts

@@ -4,6 +4,7 @@ import { AccountDetailed } from "src/endpoints/accounts/entities/account.detaile
 import { About } from "src/endpoints/network/entities/about";
 import { Nft } from "src/endpoints/nfts/entities/nft";
 import { Transaction } from "src/endpoints/transactions/entities/transaction";
+import { EsdtSupply } from "../gateway/entities/esdt.supply";
 
 @Injectable()
 export class PluginService {
@@ -18,4 +19,6 @@ export class PluginService {
   async batchProcessNfts(_nfts: Nft[], _withScamInfo?: boolean): Promise<void> { }
 
   async processAbout(_about: About): Promise<void> { }
+
+  formatTokenSupply(_identifier: string, _esdtSupply: EsdtSupply) { }
 }

src/common/rabbitmq/entities/notifier.event.identifier.ts

@@ -1,5 +1,9 @@
 export enum NotifierEventIdentifier {
   ESDTNFTCreate = 'ESDTNFTCreate',
   ESDTNFTUpdateAttributes = 'ESDTNFTUpdateAttributes',
+  ESDTNFTBurn = 'ESDTNFTBurn',
+  ESDTMetaDataUpdate = 'ESDTMetaDataUpdate',
+  ESDTMetaDataRecreate = 'ESDTMetaDataRecreate',
+  ESDTModifyCreator = 'ESDTModifyCreator',
   transferOwnership = 'transferOwnership',
 }

src/common/rabbitmq/rabbitmq.consumer.ts

@@ -41,6 +41,16 @@ export class RabbitMqConsumer {
       case NotifierEventIdentifier.ESDTNFTUpdateAttributes:
         await this.nftHandlerService.handleNftUpdateAttributesEvent(event);
         break;
+      case NotifierEventIdentifier.ESDTNFTBurn:
+        await this.nftHandlerService.handleNftBurnEvent(event);
+        break;
+      case NotifierEventIdentifier.ESDTMetaDataUpdate:
+      case NotifierEventIdentifier.ESDTMetaDataRecreate:
+        await this.nftHandlerService.handleNftMetadataEvent(event);
+        break;
+      case NotifierEventIdentifier.ESDTModifyCreator:
+        await this.nftHandlerService.handleNftModifyCreatorEvent(event);
+        break;
       case NotifierEventIdentifier.transferOwnership:
         await this.tokenHandlerService.handleTransferOwnershipEvent(event);
         break;

src/common/rabbitmq/rabbitmq.nft.handler.service.ts

@@ -8,6 +8,9 @@ import { NotifierEvent } from './entities/notifier.event';
 import { CacheService } from "@multiversx/sdk-nestjs-cache";
 import { BinaryUtils, OriginLogger } from '@multiversx/sdk-nestjs-common';
 import { IndexerService } from '../indexer/indexer.service';
+import { NftSubType } from 'src/endpoints/nfts/entities/nft.sub.type';
+import { Inject } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
 
 @Injectable()
 export class RabbitMqNftHandlerService {
@@ -18,6 +21,7 @@ export class RabbitMqNftHandlerService {
     private readonly nftService: NftService,
     private readonly indexerService: IndexerService,
     private readonly cachingService: CacheService,
+    @Inject('PUBSUB_SERVICE') private clientProxy: ClientProxy,
   ) { }
 
   private async getCollectionType(collectionIdentifier: string): Promise<NftType | null> {
@@ -62,7 +66,19 @@ export class RabbitMqNftHandlerService {
     nft.attributes = attributes;
 
     try {
-      await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({ forceRefreshMetadata: true }));
+      const isDynamicNft = this.isDynamicNftType(nft.subType);
+
+      if (isDynamicNft) {
+        this.logger.log(`Processing dynamic NFT with identifier '${identifier}', forcing refresh of metadata and media`);
+
+        await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({
+          forceRefreshMetadata: true,
+          forceRefreshMedia: true,
+          forceRefreshThumbnail: true,
+        }));
+      } else {
+        await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({ forceRefreshMetadata: true }));
+      }
     } catch (error) {
       this.logger.error(`An unhandled error occurred when processing NFT update attributes event for NFT with identifier '${identifier}'`);
       this.logger.error(error);
@@ -71,6 +87,18 @@ export class RabbitMqNftHandlerService {
     }
   }
 
+  private isDynamicNftType(subType?: NftSubType): boolean {
+    if (subType) {
+      return [
+        NftSubType.DynamicNonFungibleESDT,
+        NftSubType.DynamicSemiFungibleESDT,
+        NftSubType.DynamicMetaESDT,
+      ].includes(subType);
+    }
+
+    return false;
+  }
+
   public async handleNftCreateEvent(event: NotifierEvent): Promise<boolean> {
     const identifier = this.getNftIdentifier(event.topics);
 
@@ -92,6 +120,21 @@ export class RabbitMqNftHandlerService {
     }
 
     try {
+      const isDynamicNft = this.isDynamicNftType(nft.subType);
+
+      if (isDynamicNft) {
+        this.logger.log(`Processing dynamic NFT creation with identifier '${identifier}', forcing full refresh`);
+
+        await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({
+          uploadAsset: true,
+          forceRefreshMetadata: true,
+          forceRefreshMedia: true,
+          forceRefreshThumbnail: true,
+        }));
+
+        return true;
+      }
+
       const needsProcessing = await this.nftWorkerService.needsProcessing(nft, new ProcessNftSettings());
       if (needsProcessing) {
         await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({ uploadAsset: true }));
@@ -105,6 +148,70 @@ export class RabbitMqNftHandlerService {
     }
   }
 
+  public async handleNftBurnEvent(event: NotifierEvent): Promise<boolean> {
+    const identifier = this.getNftIdentifier(event.topics);
+
+    this.logger.log(`Detected 'ESDTNFTBurn' event for NFT with identifier '${identifier}'`);
+
+    try {
+      const cacheKey = `nft:${identifier}`;
+      await this.cachingService.delete(cacheKey);
+
+      this.clientProxy.emit('deleteCacheKeys', [cacheKey]);
+
+      this.logger.log(`Cache invalidated for NFT with identifier '${identifier}' across all instances`);
+      return true;
+    } catch (error) {
+      this.logger.error(`An unhandled error occurred when processing NFT Burn event for NFT with identifier '${identifier}'`);
+      this.logger.error(error);
+      return false;
+    }
+  }
+
+  public async handleNftMetadataEvent(event: NotifierEvent): Promise<boolean> {
+    const identifier = this.getNftIdentifier(event.topics);
+
+    this.logger.log(`Detected '${event.identifier}' event for NFT with identifier '${identifier}'`);
+
+    const nft = await this.nftService.getSingleNft(identifier);
+    if (!nft) {
+      this.logger.log(`Could not fetch NFT details for NFT with identifier '${identifier}'`);
+      return false;
+    }
+
+    try {
+      await this.nftWorkerService.addProcessNftQueueJob(nft, new ProcessNftSettings({
+        forceRefreshMetadata: true,
+        forceRefreshMedia: true,
+      }));
+      return true;
+    } catch (error) {
+      this.logger.error(`An unhandled error occurred when processing '${event.identifier}' event for NFT with identifier '${identifier}'`);
+      this.logger.error(error);
+      return false;
+    }
+  }
+
+  public async handleNftModifyCreatorEvent(event: NotifierEvent): Promise<boolean> {
+    const identifier = this.getNftIdentifier(event.topics);
+
+    this.logger.log(`Detected 'ESDTModifyCreator' event for NFT with identifier '${identifier}'`);
+
+    try {
+      const cacheKey = `nft:${identifier}`;
+      await this.cachingService.delete(cacheKey);
+
+      this.clientProxy.emit('deleteCacheKeys', [cacheKey]);
+
+      this.logger.log(`Cache invalidated for NFT with identifier '${identifier}' across all instances`);
+      return true;
+    } catch (error) {
+      this.logger.error(`An unhandled error occurred when processing NFT ModifyCreator event for NFT with identifier '${identifier}'`);
+      this.logger.error(error);
+      return false;
+    }
+  }
+
   private getNftIdentifier(topics: string[]): string {
     const collection = BinaryUtils.base64Decode(topics[0]);
     const nonce = BinaryUtils.base64ToHex(topics[1]);

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

@@ -34,6 +34,7 @@ import * as JsonDiff from "json-diff";
 import { QueryPagination } from "src/common/entities/query.pagination";
 import { StakeService } from "src/endpoints/stake/stake.service";
 import { ApplicationMostUsed } from "src/endpoints/accounts/entities/application.most.used";
+import { NftType } from '../../common/indexer/entities/nft.type';
 
 @Injectable()
 export class CacheWarmerService {
@@ -320,14 +321,21 @@ export class CacheWarmerService {
   @Lock({ name: 'Elastic updater: Update collection isVerified, nftCount, holderCount', verbose: true })
   async handleUpdateCollectionExtraDetails() {
     const allAssets = await this.assetsService.getAllTokenAssets();
+    const nftTypes = [
+      NftType.NonFungibleESDT,
+      NftType.SemiFungibleESDT,
+      NftType.NonFungibleESDTv2,
+      NftType.DynamicNonFungibleESDT,
+      NftType.DynamicSemiFungibleESDT,
+    ];
 
     for (const key of Object.keys(allAssets)) {
       const collection = await this.indexerService.getCollection(key);
       if (!collection) {
         continue;
       }
 
-      if (![TokenType.NonFungibleESDT, TokenType.SemiFungibleESDT].includes(collection.type as TokenType)) {
+      if (!nftTypes.includes(collection.type as NftType)) {
         continue;
       }
 

src/endpoints/accounts/account.controller.ts

@@ -1115,6 +1115,7 @@ export class AccountController {
   @ApiQuery({ name: 'isScCall', description: 'Returns sc call transactions details', required: false, type: Boolean })
   @ApiQuery({ name: 'senderOrReceiver', description: 'One address that current address interacted with', required: false })
   @ApiQuery({ name: 'withRefunds', description: 'Include refund transactions', required: false })
+  @ApiQuery({ name: 'withTxsRelayedByAddress', description: 'Include transactions that were relayed by the address', required: false })
   async getAccountTransfersCount(
     @Param('address', ParseAddressPipe) address: string,
     @Query('sender', ParseAddressArrayPipe) sender?: string[],
@@ -1132,6 +1133,7 @@ export class AccountController {
     @Query('senderOrReceiver', ParseAddressPipe) senderOrReceiver?: string,
     @Query('isScCall', ParseBoolPipe) isScCall?: boolean,
     @Query('withRefunds', ParseBoolPipe) withRefunds?: boolean,
+    @Query('withTxsRelayedByAddress', ParseBoolPipe) withTxsRelayedByAddress?: boolean,
   ): Promise<number> {
     return await this.transferService.getTransfersCount(new TransactionFilter({
       address,
@@ -1150,6 +1152,7 @@ export class AccountController {
       round,
       isScCall,
       withRefunds,
+      withTxsRelayedByAddress,
     }));
   }
 
@@ -1172,6 +1175,7 @@ export class AccountController {
     @Query('senderOrReceiver', ParseAddressPipe) senderOrReceiver?: string,
     @Query('withRefunds', ParseBoolPipe) withRefunds?: boolean,
     @Query('isScCall', ParseBoolPipe) isScCall?: boolean,
+    @Query('withTxsRelayedByAddress', ParseBoolPipe) withTxsRelayedByAddress?: boolean,
   ): Promise<number> {
     return await this.transferService.getTransfersCount(new TransactionFilter({
       address,
@@ -1190,6 +1194,7 @@ export class AccountController {
       round,
       withRefunds,
       isScCall,
+      withTxsRelayedByAddress,
     }));
   }