MEX-397: add query for increase proxy pair token energy transaction

Signed-off-by: Claudiu Lataretu <[email protected]>

src/config/default.json

@@ -261,7 +261,8 @@
                     "withTokenMerge": 40000000
                 },
                 "removeLiquidity": 30000000,
-                "defaultMergeWLPT": 20000000
+                "defaultMergeWLPT": 20000000,
+                "increaseEnergy": 20000000
             },
             "farms": {
                 "v1.2": {

src/modules/proxy/proxy.module.ts

@@ -16,6 +16,7 @@ import { ProxyQueryResolver } from './proxy.query.resolver';
 import { ProxyResolver } from './proxy.resolver';
 import { WrappedLpTokenAttributesResolverV2 } from './wrappedLp.token.v2.resolver';
 import { WrappedFarmTokenResolverV2 } from './wrappedFarm.token.v2.resolver';
+import { EnergyModule } from '../energy/energy.module';
 
 @Module({
     imports: [
@@ -27,6 +28,7 @@ import { WrappedFarmTokenResolverV2 } from './wrappedFarm.token.v2.resolver';
         forwardRef(() => ProxyFarmModule),
         forwardRef(() => ProxyModuleV2),
         FarmModule,
+        EnergyModule,
     ],
     providers: [
         ProxyAbiService,

src/modules/proxy/proxy.transaction.resolver.ts

@@ -24,11 +24,15 @@ import { InputTokenModel } from 'src/models/inputToken.model';
 import { LiquidityTokensValidationPipe } from './validators/add.liquidity.input.validator';
 import { ProxyService } from './services/proxy.service';
 import { scAddress } from 'src/config';
+import { GraphQLError } from 'graphql';
+import { ApolloServerErrorCode } from '@apollo/server/errors';
+import { EnergyAbiService } from '../energy/services/energy.abi.service';
 
 @Resolver()
 export class ProxyTransactionResolver {
     constructor(
         private readonly proxyService: ProxyService,
+        private readonly energyAbi: EnergyAbiService,
         private readonly transactionsProxyPairService: ProxyPairTransactionsService,
         private readonly transactionsProxyFarmService: ProxyFarmTransactionsService,
     ) {}
@@ -195,4 +199,44 @@ export class ProxyTransactionResolver {
             args,
         );
     }
+
+    @UseGuards(JwtOrNativeAuthGuard)
+    @Query(() => TransactionModel)
+    async increaseProxyPairTokenEnergy(
+        @Args('payment') payment: InputTokenModel,
+        @Args('lockEpochs') lockEpochs: number,
+        @AuthUser() user: UserAuthResult,
+    ): Promise<TransactionModel> {
+        let proxyAddress: string;
+        try {
+            proxyAddress = await this.proxyService.getProxyAddressByToken(
+                payment.tokenID,
+            );
+
+            if (proxyAddress !== scAddress.proxyDexAddress.v2) {
+                throw new Error('Wrapped lp token is not supported');
+            }
+
+            const lockOptions = await this.energyAbi.lockOptions();
+            if (
+                lockOptions.find(
+                    (option) => option.lockEpochs === lockEpochs,
+                ) === undefined
+            ) {
+                throw new Error('Invalid lock epochs!');
+            }
+        } catch (error) {
+            throw new GraphQLError(error.message, {
+                extensions: {
+                    code: ApolloServerErrorCode.BAD_USER_INPUT,
+                },
+            });
+        }
+        return this.transactionsProxyPairService.increaseProxyPairTokenEnergy(
+            user.address,
+            proxyAddress,
+            payment,
+            lockEpochs,
+        );
+    }
 }

src/modules/proxy/services/proxy-pair/proxy.pair.transactions.service.ts

@@ -4,6 +4,7 @@ import {
     BigUIntValue,
     BytesValue,
     TypedValue,
+    U64Value,
 } from '@multiversx/sdk-core/out/smartcontracts/typesystem';
 import { Address, TokenTransfer } from '@multiversx/sdk-core';
 import { TransactionModel } from 'src/models/transaction.model';
@@ -236,6 +237,33 @@ export class ProxyPairTransactionsService {
             .toPlainObject();
     }
 
+    async increaseProxyPairTokenEnergy(
+        sender: string,
+        proxyAddress: string,
+        payment: InputTokenModel,
+        lockEpochs: number,
+    ): Promise<TransactionModel> {
+        const contract = await this.mxProxy.getProxyDexSmartContract(
+            proxyAddress,
+        );
+        return contract.methodsExplicit
+            .increaseProxyPairTokenEnergy([
+                new U64Value(new BigNumber(lockEpochs)),
+            ])
+            .withSingleESDTNFTTransfer(
+                TokenTransfer.metaEsdtFromBigInteger(
+                    payment.tokenID,
+                    payment.nonce,
+                    new BigNumber(payment.amount),
+                ),
+            )
+            .withSender(Address.fromString(sender))
+            .withGasLimit(gasConfig.proxy.pairs.increaseEnergy)
+            .withChainID(mxConfig.chainID)
+            .buildTransaction()
+            .toPlainObject();
+    }
+
     private async convertInputTokenstoESDTTokens(
         tokens: InputTokenModel[],
     ): Promise<InputTokenModel[]> {