[SERVICES-2155] context tracker

package.json

@@ -65,6 +65,7 @@
         "class-validator": "^0.14.0",
         "config": "^3.3.7",
         "cookie-parser": "^1.4.6",
+        "dd-trace": "^5.10.0",
         "express": "^4.18.1",
         "graphql": "^16.5.0",
         "graphql-redis-subscriptions": "^2.4.2",

src/main.ts

@@ -13,6 +13,7 @@ import cookieParser from 'cookie-parser';
 import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
 import { LoggerService } from '@nestjs/common';
 import { NestExpressApplication } from '@nestjs/platform-express';
+import 'dd-trace/init';
 
 async function bootstrap() {
     BigNumber.config({ EXPONENTIAL_AT: [-30, 30] });

src/modules/analytics/services/analytics.compute.service.ts

@@ -5,10 +5,9 @@ import {
     FarmRewardType,
     FarmVersion,
 } from 'src/modules/farm/models/farm.model';
-import { farmsAddresses, farmType, farmVersion } from 'src/utils/farm.utils';
+import { farmType, farmVersion } from 'src/utils/farm.utils';
 import { FarmComputeFactory } from 'src/modules/farm/farm.compute.factory';
 import { AnalyticsQueryService } from 'src/services/analytics/services/analytics.query.service';
-import { RemoteConfigGetterService } from '../../remote-config/remote-config.getter.service';
 import { WeekTimekeepingAbiService } from 'src/submodules/week-timekeeping/services/week-timekeeping.abi.service';
 import { WeeklyRewardsSplittingAbiService } from 'src/submodules/weekly-rewards-splitting/services/weekly-rewards-splitting.abi.service';
 import { PairAbiService } from 'src/modules/pair/services/pair.abi.service';
@@ -21,21 +20,24 @@ import { FarmAbiFactory } from 'src/modules/farm/farm.abi.factory';
 import { TokenComputeService } from 'src/modules/tokens/services/token.compute.service';
 import { TokenService } from 'src/modules/tokens/services/token.service';
 import { ErrorLoggerAsync } from '@multiversx/sdk-nestjs-common';
+import { FarmFactoryService } from 'src/modules/farm/farm.factory';
+import { StakingService } from 'src/modules/staking/services/staking.service';
 
 @Injectable()
 export class AnalyticsComputeService {
     constructor(
         private readonly routerAbi: RouterAbiService,
         private readonly farmAbi: FarmAbiFactory,
         private readonly farmCompute: FarmComputeFactory,
+        private readonly farmFactory: FarmFactoryService,
         private readonly pairAbi: PairAbiService,
         private readonly pairCompute: PairComputeService,
+        private readonly stakingService: StakingService,
         private readonly stakingCompute: StakingComputeService,
         private readonly tokenCompute: TokenComputeService,
         private readonly tokenService: TokenService,
         private readonly weekTimekeepingAbi: WeekTimekeepingAbiService,
         private readonly weeklyRewardsSplittingAbi: WeeklyRewardsSplittingAbiService,
-        private readonly remoteConfigGetterService: RemoteConfigGetterService,
         private readonly analyticsQuery: AnalyticsQueryService,
     ) {}
 
@@ -51,9 +53,9 @@ export class AnalyticsComputeService {
 
     async computeLockedValueUSDFarms(): Promise<string> {
         let totalLockedValue = new BigNumber(0);
-
+        const farmsAddresses = await this.farmFactory.getFarmsAddresses();
         const promises: Promise<string>[] = [];
-        for (const farmAddress of farmsAddresses()) {
+        for (const farmAddress of farmsAddresses) {
             promises.push(
                 this.farmCompute
                     .useCompute(farmAddress)
@@ -118,25 +120,26 @@ export class AnalyticsComputeService {
         let totalValueLockedUSD = new BigNumber(0);
 
         const stakingAddresses =
-            await this.remoteConfigGetterService.getStakingAddresses();
+            await this.stakingService.getStakingAddresses();
         const promises = stakingAddresses.map((stakingAddress) =>
             this.stakingCompute.stakedValueUSD(stakingAddress),
         );
 
         promises.push(this.computeTotalLockedMexStakedUSD());
+        const farmsAddresses = await this.farmFactory.getFarmsAddresses();
 
-        if (farmsAddresses()[5] !== undefined) {
+        if (farmsAddresses[5] !== undefined) {
             promises.push(
                 this.farmCompute
-                    .useCompute(farmsAddresses()[5])
-                    .computeFarmLockedValueUSD(farmsAddresses()[5]),
+                    .useCompute(farmsAddresses[5])
+                    .computeFarmLockedValueUSD(farmsAddresses[5]),
             );
         }
-        if (farmsAddresses()[13] !== undefined) {
+        if (farmsAddresses[13] !== undefined) {
             promises.push(
                 this.farmCompute
-                    .useCompute(farmsAddresses()[13])
-                    .computeFarmLockedValueUSD(farmsAddresses()[13]),
+                    .useCompute(farmsAddresses[13])
+                    .computeFarmLockedValueUSD(farmsAddresses[13]),
             );
         }
 
@@ -163,7 +166,7 @@ export class AnalyticsComputeService {
     }
 
     async computeTotalAggregatedRewards(days: number): Promise<string> {
-        const addresses: string[] = farmsAddresses();
+        const addresses: string[] = await this.farmFactory.getFarmsAddresses();
         const promises = addresses.map(async (farmAddress) => {
             if (
                 farmType(farmAddress) === FarmRewardType.CUSTOM_REWARDS ||

src/modules/analytics/specs/analytics.service.spec.ts

@@ -45,6 +45,7 @@ import { WinstonModule } from 'nest-winston';
 import { ApiConfigService } from 'src/helpers/api.config.service';
 import winston from 'winston';
 import { DynamicModuleUtils } from 'src/utils/dynamic.module.utils';
+import { FarmFactoryService } from 'src/modules/farm/farm.factory';
 import { ElasticSearchModule } from 'src/services/elastic-search/elastic.search.module';
 import { StakingFilteringService } from 'src/modules/staking/services/staking.filtering.service';
 
@@ -77,6 +78,7 @@ describe('AnalyticsService', () => {
                 FarmComputeServiceV1_2,
                 FarmComputeServiceV1_3,
                 FarmComputeServiceV2,
+                FarmFactoryService,
                 FarmServiceV1_2,
                 FarmServiceV1_3,
                 FarmServiceV2,

src/modules/farm/base-module/farm.resolver.ts

@@ -1,7 +1,6 @@
 import { Resolver, ResolveField, Parent } from '@nestjs/graphql';
 import { BaseFarmModel } from '../models/farm.model';
 import { PairModel } from '../../pair/models/pair.model';
-import { LockedAssetModel } from '../../locked-asset-factory/models/locked-asset.model';
 import { EsdtToken } from '../../tokens/models/esdtToken.model';
 import { NftCollection } from '../../tokens/models/nftCollection.model';
 import { Address } from '@multiversx/sdk-core';

src/modules/farm/base-module/services/farm.abi.service.ts

@@ -420,4 +420,32 @@ export class FarmAbiService
     async getFarmShardRaw(farmAddress: string): Promise<number> {
         return (await this.apiService.getAccountStats(farmAddress)).shard;
     }
+
+    @ErrorLoggerAsync({
+        logArgs: true,
+    })
+    @GetOrSetCache({
+        baseKey: 'farm',
+        remoteTtl: CacheTtlInfo.ContractInfo.remoteTtl,
+        localTtl: CacheTtlInfo.ContractInfo.localTtl,
+    })
+    async farmDeployedTimestamp(farmAddress: string): Promise<number> {
+        return await this.getFarmDeployedTimestampRaw(farmAddress);
+    }
+
+    async getFarmDeployedTimestampRaw(
+        farmAddress: string,
+    ): Promise<number | undefined> {
+        try {
+            const addressDetails = await this.apiService.getAccountStats(
+                farmAddress,
+            );
+            return addressDetails.deployedAt ?? undefined;
+        } catch (error) {
+            if (error.message.includes('Account not found')) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
 }

src/modules/farm/base-module/services/interfaces.ts

@@ -24,6 +24,7 @@ export interface IFarmAbiService {
     lastErrorMessage(farmAddress: string): Promise<string>;
     ownerAddress(farmAddress: string): Promise<string>;
     farmShard(farmAddress: string): Promise<number>;
+    farmDeployedTimestamp(farmAddress: string): Promise<number>;
 }
 
 export interface IFarmComputeService {

src/modules/farm/farm.abi.factory.ts

@@ -1,19 +1,21 @@
 import { Injectable } from '@nestjs/common';
-import { farmVersion, farmsAddresses } from 'src/utils/farm.utils';
+import { farmVersion } from 'src/utils/farm.utils';
 import { FarmAbiService } from './base-module/services/farm.abi.service';
 import { FarmVersion } from './models/farm.model';
 import { FarmAbiServiceV1_2 } from './v1.2/services/farm.v1.2.abi.service';
 import { FarmAbiServiceV1_3 } from './v1.3/services/farm.v1.3.abi.service';
 import { FarmAbiServiceV2 } from './v2/services/farm.v2.abi.service';
 import { CacheService } from '@multiversx/sdk-nestjs-cache';
 import { Constants } from '@multiversx/sdk-nestjs-common';
+import { FarmFactoryService } from './farm.factory';
 
 @Injectable()
 export class FarmAbiFactory {
     constructor(
         private readonly abiServiceV1_2: FarmAbiServiceV1_2,
         private readonly abiServiceV1_3: FarmAbiServiceV1_3,
         private readonly abiServiceV2: FarmAbiServiceV2,
+        private readonly farmFactory: FarmFactoryService,
         private readonly cachingService: CacheService,
     ) {}
 
@@ -29,7 +31,8 @@ export class FarmAbiFactory {
     }
 
     async isFarmToken(tokenID: string): Promise<boolean> {
-        for (const farmAddress of farmsAddresses()) {
+        const farmsAddresses = await this.farmFactory.getFarmsAddresses();
+        for (const farmAddress of farmsAddresses) {
             const farmTokenID = await this.useAbi(farmAddress).farmTokenID(
                 farmAddress,
             );
@@ -49,7 +52,10 @@ export class FarmAbiFactory {
         if (cachedValue && cachedValue !== undefined) {
             return cachedValue;
         }
-        for (const farmAddress of farmsAddresses()) {
+
+        const farmsAddresses = await this.farmFactory.getFarmsAddresses();
+
+        for (const farmAddress of farmsAddresses) {
             const farmTokenID = await this.useAbi(farmAddress).farmTokenID(
                 farmAddress,
             );

src/modules/farm/farm.factory.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { FarmVersion } from './models/farm.model';
-import { farmsAddresses, farmType, farmVersion } from 'src/utils/farm.utils';
+import { farmType, farmVersion, farmsAddresses } from 'src/utils/farm.utils';
 import { FarmModelV1_2 } from './models/farm.v1.2.model';
 import { FarmModelV1_3 } from './models/farm.v1.3.model';
 import { FarmCustomModel } from './models/farm.custom.model';
@@ -10,18 +10,44 @@ import { FarmServiceV1_3 } from './v1.3/services/farm.v1.3.service';
 import { FarmServiceV2 } from './v2/services/farm.v2.service';
 import { FarmServiceBase } from './base-module/services/farm.base.service';
 import { FarmModelV2 } from './models/farm.v2.model';
+import { ContextTracker } from '@multiversx/sdk-nestjs-common';
+import { FarmAbiServiceV1_2 } from './v1.2/services/farm.v1.2.abi.service';
 
 @Injectable()
 export class FarmFactoryService {
     constructor(
         private readonly farmServiceV1_2: FarmServiceV1_2,
         private readonly farmServiceV1_3: FarmServiceV1_3,
         private readonly farmServiceV2: FarmServiceV2,
+        private readonly farmAbi: FarmAbiServiceV1_2,
     ) {}
 
-    getFarms(): Array<typeof FarmsUnion> {
+    async getFarmsAddresses(versions?: string[]): Promise<string[]> {
+        let addresses = farmsAddresses(versions);
+
+        const context = ContextTracker.get();
+        if (context && context.deepHistoryTimestamp) {
+            const farmsDeployedTimestamps = await Promise.all(
+                addresses.map((address) =>
+                    this.farmAbi.farmDeployedTimestamp(address),
+                ),
+            );
+            addresses = addresses.filter((_, index) => {
+                return (
+                    farmsDeployedTimestamps[index] !== undefined &&
+                    farmsDeployedTimestamps[index] <=
+                        context.deepHistoryTimestamp
+                );
+            });
+        }
+
+        return addresses;
+    }
+
+    async getFarms(): Promise<Array<typeof FarmsUnion>> {
         const farms: Array<typeof FarmsUnion> = [];
-        for (const address of farmsAddresses()) {
+        const farmsAddresses = await this.getFarmsAddresses();
+        for (const address of farmsAddresses) {
             const version = farmVersion(address);
             switch (version) {
                 case FarmVersion.V1_2:

src/modules/farm/farm.module.ts

@@ -23,7 +23,6 @@ import { FarmSetterFactory } from './farm.setter.factory';
         ContextModule,
         forwardRef(() => PairModule),
         TokenModule,
-        FarmCustomModule,
         FarmModuleV1_2,
         FarmModuleV1_3,
         FarmModuleV2,

src/modules/farm/mocks/farm.abi.service.mock.ts

@@ -80,6 +80,10 @@ export class FarmAbiServiceMock implements IFarmAbiService {
     async farmShard(farmAddress: string): Promise<number> {
         return 1;
     }
+
+    async farmDeployedTimestamp(farmAddress: string): Promise<number> {
+        return 1636895880;
+    }
 }
 
 export const FarmAbiServiceProvider = {

src/modules/farm/specs/farm.service.spec.ts

@@ -137,7 +137,7 @@ describe('FarmService', () => {
 
     it('should get farms', async () => {
         const factory = module.get<FarmFactoryService>(FarmFactoryService);
-        const farms = factory.getFarms();
+        const farms = await factory.getFarms();
         expect(farms).toEqual([
             {
                 address:

src/modules/rabbitmq/rabbitmq.consumer.ts

@@ -6,7 +6,6 @@ import { RabbitMQProxyHandlerService } from './rabbitmq.proxy.handler.service';
 import { CompetingRabbitConsumer } from './rabbitmq.consumers';
 import { scAddress } from 'src/config';
 import { RabbitMQEsdtTokenHandlerService } from './rabbitmq.esdtToken.handler.service';
-import { farmsAddresses } from 'src/utils/farm.utils';
 import { RouterHandlerService } from './handlers/router.handler.service';
 import { RabbitMQMetabondingHandlerService } from './rabbitmq.metabonding.handler.service';
 import { PriceDiscoveryEventHandler } from './handlers/price.discovery.handler.service';
@@ -64,6 +63,7 @@ import { RouterAbiService } from '../router/services/router.abi.service';
 import { EscrowHandlerService } from './handlers/escrow.handler.service';
 import { governanceContractsAddresses } from '../../utils/governance';
 import { GovernanceHandlerService } from './handlers/governance.handler.service';
+import { FarmFactoryService } from '../farm/farm.factory';
 
 @Injectable()
 export class RabbitMqConsumer {
@@ -72,6 +72,7 @@ export class RabbitMqConsumer {
 
     constructor(
         private readonly routerAbi: RouterAbiService,
+        private readonly farmFactory: FarmFactoryService,
         private readonly liquidityHandler: LiquidityHandler,
         private readonly swapHandler: SwapEventHandler,
         private readonly wsFarmHandler: FarmHandlerService,
@@ -326,7 +327,8 @@ export class RabbitMqConsumer {
     async getFilterAddresses(): Promise<void> {
         this.filterAddresses = [];
         this.filterAddresses = await this.routerAbi.getAllPairsAddressRaw();
-        this.filterAddresses.push(...farmsAddresses());
+        const farmsAddresses = await this.farmFactory.getFarmsAddresses();
+        this.filterAddresses.push(...farmsAddresses);
         this.filterAddresses.push(scAddress.routerAddress);
         this.filterAddresses.push(scAddress.metabondingStakingAddress);
         this.filterAddresses.push(...scAddress.priceDiscovery);