[MEX-331] fees collector admin endpoints

src/config/default.json

@@ -445,7 +445,9 @@
         },
         "feesCollector": {
             "baseClaimRewards": 20000000,
-            "claimRewardsPerWeek": 20000000
+            "claimRewardsPerWeek": 20000000,
+            "addKnownContracts": 10000000,
+            "addKnownTokens": 10000000
         },
         "energyUpdate": {
             "updateFarmsEnergyForUser": 15000000

src/modules/fees-collector/fees-collector.resolver.ts

@@ -21,12 +21,14 @@ import { FeesCollectorAbiService } from './services/fees-collector.abi.service';
 import { WeeklyRewardsSplittingAbiService } from 'src/submodules/weekly-rewards-splitting/services/weekly-rewards-splitting.abi.service';
 import { FeesCollectorTransactionService } from './services/fees-collector.transaction.service';
 import { FeesCollectorComputeService } from './services/fees-collector.compute.service';
+import { JwtOrNativeAdminGuard } from '../auth/jwt.or.native.admin.guard';
 
 @Resolver(() => FeesCollectorModel)
 export class FeesCollectorResolver {
     constructor(
         private readonly feesCollectorAbi: FeesCollectorAbiService,
         private readonly feesCollectorService: FeesCollectorService,
+        private readonly feesCollectorTransaction: FeesCollectorTransactionService,
         private readonly weeklyRewardsSplittingAbi: WeeklyRewardsSplittingAbiService,
     ) {}
 
@@ -85,6 +87,34 @@ export class FeesCollectorResolver {
     async feesCollector(): Promise<FeesCollectorModel> {
         return this.feesCollectorService.feesCollector(scAddress.feesCollector);
     }
+
+    @UseGuards(JwtOrNativeAdminGuard)
+    @Query(() => TransactionModel, {
+        description: 'Add or remove known contracts',
+    })
+    async handleKnownContracts(
+        @Args('contractAddresses') contractAddresses: string[],
+        @Args('remove', { nullable: true }) remove: boolean,
+    ): Promise<TransactionModel> {
+        return this.feesCollectorTransaction.handleKnownContracts(
+            contractAddresses,
+            remove,
+        );
+    }
+
+    @UseGuards(JwtOrNativeAdminGuard)
+    @Query(() => TransactionModel, {
+        description: 'Add or remove known tokens',
+    })
+    async handleKnownTokens(
+        @Args('tokenIDs') tokenIDs: string[],
+        @Args('remove', { nullable: true }) remove: boolean,
+    ): Promise<TransactionModel> {
+        return this.feesCollectorTransaction.handleKnownTokens(
+            tokenIDs,
+            remove,
+        );
+    }
 }
 
 @Resolver(() => UserEntryFeesCollectorModel)

src/modules/fees-collector/services/fees-collector.transaction.service.ts

@@ -5,7 +5,14 @@ import { WeekTimekeepingAbiService } from 'src/submodules/week-timekeeping/servi
 import { WeeklyRewardsSplittingAbiService } from 'src/submodules/weekly-rewards-splitting/services/weekly-rewards-splitting.abi.service';
 import { constantsConfig, gasConfig, mxConfig } from 'src/config';
 import { TransactionModel } from 'src/models/transaction.model';
-import { Address, AddressValue } from '@multiversx/sdk-core/out';
+import {
+    Address,
+    AddressType,
+    AddressValue,
+    TokenIdentifierType,
+    TokenIdentifierValue,
+    VariadicValue,
+} from '@multiversx/sdk-core/out';
 
 @Injectable()
 export class FeesCollectorTransactionService {
@@ -72,4 +79,50 @@ export class FeesCollectorTransactionService {
             .buildTransaction()
             .toPlainObject();
     }
+
+    async handleKnownContracts(
+        pairAddresses: string[],
+        remove = false,
+    ): Promise<TransactionModel> {
+        const contract = await this.mxProxy.getFeesCollectorContract();
+        const endpointArgs = [
+            new VariadicValue(
+                new AddressType(),
+                pairAddresses.map(
+                    (address) => new AddressValue(Address.fromString(address)),
+                ),
+            ),
+        ];
+        const interaction = remove
+            ? contract.methodsExplicit.removeKnownContracts(endpointArgs)
+            : contract.methodsExplicit.addKnownContracts(endpointArgs);
+
+        return interaction
+            .withGasLimit(gasConfig.feesCollector.addKnownContracts)
+            .withChainID(mxConfig.chainID)
+            .buildTransaction()
+            .toPlainObject();
+    }
+
+    async handleKnownTokens(
+        tokenIDs: string[],
+        remove = false,
+    ): Promise<TransactionModel> {
+        const contract = await this.mxProxy.getFeesCollectorContract();
+        const endpointArgs = [
+            new VariadicValue(
+                new TokenIdentifierType(),
+                tokenIDs.map((id) => new TokenIdentifierValue(id)),
+            ),
+        ];
+        const interaction = remove
+            ? contract.methodsExplicit.removeKnownTokens(endpointArgs)
+            : contract.methodsExplicit.addKnownTokens(endpointArgs);
+
+        return interaction
+            .withGasLimit(gasConfig.feesCollector.addKnownTokens)
+            .withChainID(mxConfig.chainID)
+            .buildTransaction()
+            .toPlainObject();
+    }
 }

src/modules/fees-collector/specs/fees-collector.transaction.service.spec.ts

@@ -121,4 +121,71 @@ describe('FeesCollectorTransactionService', () => {
             }),
         );
     });
+
+    it('should get remove known contract transaction', async () => {
+        const service = module.get<FeesCollectorTransactionService>(
+            FeesCollectorTransactionService,
+        );
+        const transaction = await service.handleKnownContracts(
+            [
+                Address.fromHex(
+                    '0000000000000000000000000000000000000000000000000000000000000001',
+                ).bech32(),
+                Address.fromHex(
+                    '0000000000000000000000000000000000000000000000000000000000000002',
+                ).bech32(),
+            ],
+            true,
+        );
+
+        expect(transaction).toEqual(
+            new TransactionModel({
+                chainID: mxConfig.chainID,
+                gasLimit: 10000000,
+                gasPrice: 1000000000,
+                nonce: 0,
+                receiver: scAddress.feesCollector,
+                sender: Address.Zero().bech32(),
+                value: '0',
+                data: encodeTransactionData(
+                    `removeKnownContracts@${Address.fromHex(
+                        '0000000000000000000000000000000000000000000000000000000000000001',
+                    ).bech32()}@${Address.fromHex(
+                        '0000000000000000000000000000000000000000000000000000000000000002',
+                    ).bech32()}`,
+                ),
+                options: undefined,
+                signature: undefined,
+                version: 1,
+            }),
+        );
+    });
+
+    it('should get add known token transaction', async () => {
+        const service = module.get<FeesCollectorTransactionService>(
+            FeesCollectorTransactionService,
+        );
+        const transaction = await service.handleKnownTokens([
+            'WEGLD-123456',
+            'MEX-123456',
+        ]);
+
+        expect(transaction).toEqual(
+            new TransactionModel({
+                chainID: mxConfig.chainID,
+                gasLimit: 10000000,
+                gasPrice: 1000000000,
+                nonce: 0,
+                receiver: scAddress.feesCollector,
+                sender: Address.Zero().bech32(),
+                value: '0',
+                data: encodeTransactionData(
+                    `addKnownTokens@${'WEGLD-123456'}@${'MEX-123456'}`,
+                ),
+                options: undefined,
+                signature: undefined,
+                version: 1,
+            }),
+        );
+    });
 });