Merge pull request #1205 from multiversx/SERVICES-1877-farm-v-2-events

[SERVICES-1877] farm v2 events

package.json

@@ -33,7 +33,7 @@
         "@golevelup/nestjs-rabbitmq": "^4.0.0",
         "@multiversx/sdk-core": "^12.8.0",
         "@multiversx/sdk-data-api-client": "^0.5.8",
-        "@multiversx/sdk-exchange": "^0.2.18",
+        "@multiversx/sdk-exchange": "^0.2.19",
         "@multiversx/sdk-native-auth-server": "1.0.7",
         "@multiversx/sdk-nestjs-cache": "^2.0.0-beta.2",
         "@multiversx/sdk-nestjs-common": "^2.0.0-beta.2",

src/modules/rabbitmq/handlers/farm.handler.service.ts

@@ -0,0 +1,162 @@
+import {
+    BaseFarmEvent,
+    BaseRewardsEvent,
+    ClaimRewardsEventV2,
+    EnterFarmEventV1_2,
+    EnterFarmEventV1_3,
+    EnterFarmEventV2,
+    ExitFarmEventV1_2,
+    ExitFarmEventV1_3,
+    ExitFarmEventV2,
+    FARM_EVENTS,
+    RawEventType,
+    RewardsEventV1_2,
+    RewardsEventV1_3,
+} from '@multiversx/sdk-exchange';
+import { Inject, Injectable } from '@nestjs/common';
+import { RedisPubSub } from 'graphql-redis-subscriptions';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PUB_SUB } from 'src/services/redis.pubSub.module';
+import { farmVersion } from 'src/utils/farm.utils';
+import { Logger } from 'winston';
+import { FarmVersion } from '../../farm/models/farm.model';
+import { FarmSetterFactory } from '../../farm/farm.setter.factory';
+import { FarmAbiFactory } from '../../farm/farm.abi.factory';
+
+@Injectable()
+export class FarmHandlerService {
+    constructor(
+        private readonly farmAbiFactory: FarmAbiFactory,
+        private readonly farmSetterFactory: FarmSetterFactory,
+        @Inject(PUB_SUB) private pubSub: RedisPubSub,
+        @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+    ) {}
+
+    async handleEnterFarmEvent(rawEvent: RawEventType): Promise<void> {
+        const version = farmVersion(rawEvent.address);
+        switch (version) {
+            case FarmVersion.V1_2:
+                await this.handleEnterFarmEventV1_3(
+                    new EnterFarmEventV1_2(rawEvent),
+                );
+                return;
+            case FarmVersion.V1_3:
+                await this.handleEnterFarmEventV1_3(
+                    new EnterFarmEventV1_3(rawEvent),
+                );
+                return;
+            case FarmVersion.V2:
+                await this.handleEnterFarmEventV2(
+                    new EnterFarmEventV2(rawEvent),
+                );
+                return;
+        }
+    }
+
+    async handleExitFarmEvent(rawEvent: RawEventType): Promise<void> {
+        const version = farmVersion(rawEvent.address);
+        switch (version) {
+            case FarmVersion.V1_2:
+                await this.handleExitFarmEventV1_3(
+                    new ExitFarmEventV1_2(rawEvent),
+                );
+                return;
+            case FarmVersion.V1_3:
+                await this.handleExitFarmEventV1_3(
+                    new ExitFarmEventV1_3(rawEvent),
+                );
+                return;
+            case FarmVersion.V2:
+                await this.handleExitFarmEventV2(new ExitFarmEventV2(rawEvent));
+                return;
+        }
+    }
+
+    async handleRewardsEvent(rawEvent: RawEventType): Promise<void> {
+        const version = farmVersion(rawEvent.address);
+        switch (version) {
+            case FarmVersion.V1_2:
+                await this.handleClaimRewardsEventV1_3(
+                    new RewardsEventV1_2(rawEvent),
+                );
+                return;
+            case FarmVersion.V1_3:
+                await this.handleClaimRewardsEventV1_3(
+                    new RewardsEventV1_3(rawEvent),
+                );
+                return;
+            case FarmVersion.V2:
+                await this.handleClaimRewardsEventV2(
+                    new ClaimRewardsEventV2(rawEvent),
+                );
+                return;
+        }
+    }
+
+    private async handleEnterFarmEventV1_3(
+        event: BaseFarmEvent,
+    ): Promise<void> {
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.getAddress())
+            .setFarmTokenSupply(event.getAddress(), event.farmSupply.toFixed());
+        await this.deleteCacheKeys([cacheKey]);
+        await this.pubSub.publish(FARM_EVENTS.ENTER_FARM, {
+            enterFarmEvent: event,
+        });
+    }
+
+    private async handleExitFarmEventV1_3(event: BaseFarmEvent): Promise<void> {
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.address)
+            .setFarmTokenSupply(event.address, event.farmSupply.toFixed());
+        await this.deleteCacheKeys([cacheKey]);
+        await this.pubSub.publish(FARM_EVENTS.EXIT_FARM, {
+            exitFarmEvent: event,
+        });
+    }
+
+    private async handleClaimRewardsEventV1_3(
+        event: BaseRewardsEvent,
+    ): Promise<void> {
+        const rewardPerShare = await this.farmAbiFactory
+            .useAbi(event.address)
+            .rewardPerShare(event.address);
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.address)
+            .setRewardPerShare(event.getAddress(), rewardPerShare);
+        await this.deleteCacheKeys([cacheKey]);
+
+        await this.pubSub.publish(FARM_EVENTS.CLAIM_REWARDS, {
+            rewardsEvent: event,
+        });
+    }
+
+    private async handleEnterFarmEventV2(
+        event: EnterFarmEventV2,
+    ): Promise<void> {
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.address)
+            .setFarmTokenSupply(event.address, event.farmSupply.toFixed());
+        await this.deleteCacheKeys([cacheKey]);
+    }
+
+    private async handleExitFarmEventV2(event: ExitFarmEventV2): Promise<void> {
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.address)
+            .setFarmTokenSupply(event.address, event.farmSupply.toFixed());
+        await this.deleteCacheKeys([cacheKey]);
+    }
+
+    private async handleClaimRewardsEventV2(
+        event: ClaimRewardsEventV2,
+    ): Promise<void> {
+        const cacheKey = await this.farmSetterFactory
+            .useSetter(event.address)
+            .setFarmTokenSupply(event.address, event.farmSupply.toFixed());
+        await this.deleteCacheKeys([cacheKey]);
+    }
+
+    private async deleteCacheKeys(invalidatedKeys: string[]) {
+        await this.pubSub.publish('deleteCacheKeys', invalidatedKeys);
+    }
+}

src/modules/rabbitmq/rabbitmq.consumer.ts

@@ -1,7 +1,7 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { Logger } from 'winston';
-import { RabbitMQFarmHandlerService } from './rabbitmq.farm.handler.service';
+import { FarmHandlerService } from './handlers/farm.handler.service';
 import { RabbitMQProxyHandlerService } from './rabbitmq.proxy.handler.service';
 import { CompetingRabbitConsumer } from './rabbitmq.consumers';
 import { scAddress } from 'src/config';
@@ -74,7 +74,7 @@ export class RabbitMqConsumer {
         private readonly routerAbi: RouterAbiService,
         private readonly liquidityHandler: LiquidityHandler,
         private readonly swapHandler: SwapEventHandler,
-        private readonly wsFarmHandler: RabbitMQFarmHandlerService,
+        private readonly wsFarmHandler: FarmHandlerService,
         private readonly wsProxyHandler: RabbitMQProxyHandlerService,
         private readonly routerHandler: RouterHandlerService,
         private readonly wsEsdtTokenHandler: RabbitMQEsdtTokenHandlerService,
@@ -169,6 +169,7 @@ export class RabbitMqConsumer {
                     break;
                 case FARM_EVENTS.EXIT_FARM:
                     await this.wsFarmHandler.handleExitFarmEvent(rawEvent);
+
                     break;
                 case FARM_EVENTS.CLAIM_REWARDS:
                     await this.wsFarmHandler.handleRewardsEvent(rawEvent);

src/modules/rabbitmq/rabbitmq.module.ts

@@ -3,7 +3,7 @@ import { DynamicModule, Module } from '@nestjs/common';
 import { CommonAppModule } from 'src/common.app.module';
 import { FarmModule } from '../farm/farm.module';
 import { PairModule } from '../pair/pair.module';
-import { RabbitMQFarmHandlerService } from './rabbitmq.farm.handler.service';
+import { FarmHandlerService } from './handlers/farm.handler.service';
 import { RabbitMQProxyHandlerService } from './rabbitmq.proxy.handler.service';
 import { RabbitMqConsumer } from './rabbitmq.consumer';
 import { RabbitMQEsdtTokenHandlerService } from './rabbitmq.esdtToken.handler.service';
@@ -62,7 +62,7 @@ import { GovernanceModule } from '../governance/governance.module';
     ],
     providers: [
         RabbitMqConsumer,
-        RabbitMQFarmHandlerService,
+        FarmHandlerService,
         RabbitMQProxyHandlerService,
         RouterHandlerService,
         RabbitMQEsdtTokenHandlerService,