Merge pull request #1507 from multiversx/feat/sdk-core-v13

Merge feat/sdk-core-v13 into development
multiversx · Oct 14, 2024 · 7febc13 · 7febc13
2 parents d578d92 + d7de8dd
commit 7febc13
Show file tree

Hide file tree

Showing 62 changed files with 7,348 additions and 18,501 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -31,10 +31,9 @@
         "@datastructures-js/priority-queue": "^6.1.0",
         "@elastic/elasticsearch": "7.12.0",
         "@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.20",
-        "@multiversx/sdk-native-auth-server": "1.0.15",
+        "@multiversx/sdk-core": "^13.6.3",
+        "@multiversx/sdk-exchange": "^0.2.21",
+        "@multiversx/sdk-native-auth-server": "1.0.19",
         "@multiversx/sdk-nestjs-cache": "^3.7.0",
         "@multiversx/sdk-nestjs-common": "^3.7.0",
         "@multiversx/sdk-nestjs-elastic": "^3.7.0",
@@ -113,6 +112,7 @@
         "eslint-plugin-import": "^2.26.0",
         "npm-run-all": "^4.1.5",
         "prettier": "^2.7.1",
+        "rimraf": "^4.4.1",
         "supertest": "^6.3.3",
         "ts-jest": "^29.1.1",
         "ts-loader": "^6.2.1",

diff --git a/src/modules/analytics/models/analytics.model.ts b/src/modules/analytics/models/analytics.model.ts
@@ -1,5 +1,3 @@
-import { HistoricalValue } from '@multiversx/sdk-data-api-client';
-import { DataApiHistoricalResponse } from '@multiversx/sdk-data-api-client/lib/src/responses';
 import { Field, ObjectType } from '@nestjs/graphql';
 import BigNumber from 'bignumber.js';
 import moment from 'moment';
@@ -16,18 +14,6 @@ export class HistoricDataModel {
         Object.assign(this, init);
     }
 
-    static fromDataApiResponse(
-        row: DataApiHistoricalResponse,
-        aggregate: HistoricalValue,
-    ) {
-        return new HistoricDataModel({
-            timestamp: moment
-                .utc(row.timestamp * 1000)
-                .format('yyyy-MM-DD HH:mm:ss'),
-            value: new BigNumber(row[aggregate] ?? '0').toFixed(),
-        });
-    }
-
     static fromCompleteValues({ field, value }, type: 'last' | 'sum') {
         return new HistoricDataModel({
             timestamp: moment.utc(field).format('yyyy-MM-DD HH:mm:ss'),

diff --git a/src/modules/auto-router/services/auto-router.transactions.service.ts b/src/modules/auto-router/services/auto-router.transactions.service.ts
@@ -3,6 +3,7 @@ import {
     AddressValue,
     BigUIntValue,
     BytesValue,
+    Token,
     TokenTransfer,
     TypedValue,
 } from '@multiversx/sdk-core';
@@ -19,6 +20,7 @@ import { ComposableTasksTransactionService } from 'src/modules/composable-tasks/
 import { EsdtTokenPayment } from '@multiversx/sdk-exchange';
 import { EgldOrEsdtTokenPayment } from 'src/models/esdtTokenPayment.model';
 import { decimalToHex } from 'src/utils/token.converters';
+import { TransactionOptions } from 'src/modules/common/transaction.options';
 
 @Injectable()
 export class AutoRouterTransactionService {
@@ -33,7 +35,6 @@ export class AutoRouterTransactionService {
         args: MultiSwapTokensArgs,
     ): Promise<TransactionModel[]> {
         const transactions = [];
-        const contract = await this.mxProxy.getRouterSmartContract();
 
         const amountIn = new BigNumber(args.intermediaryAmounts[0]).plus(
             new BigNumber(args.intermediaryAmounts[0]).multipliedBy(
@@ -44,6 +45,7 @@ export class AutoRouterTransactionService {
         if (args.tokenInID === mxConfig.EGLDIdentifier) {
             return [
                 await this.wrapEgldAndMultiSwapTransaction(
+                    sender,
                     amountIn.integerValue().toFixed(),
                     args,
                 ),
@@ -53,6 +55,7 @@ export class AutoRouterTransactionService {
         if (args.tokenOutID === mxConfig.EGLDIdentifier) {
             return [
                 await this.multiSwapAndUnwrapEgldTransaction(
+                    sender,
                     amountIn.integerValue().toFixed(),
                     args,
                 ),
@@ -62,25 +65,31 @@ export class AutoRouterTransactionService {
         const gasLimit =
             args.addressRoute.length * gasConfig.router.multiPairSwapMultiplier;
 
-        const transactionArgs =
-            args.swapType == SWAP_TYPE.fixedInput
-                ? this.multiPairFixedInputSwaps(args)
-                : this.multiPairFixedOutputSwaps(args);
+        const transactionOptions = new TransactionOptions({
+            sender: sender,
+            chainID: mxConfig.chainID,
+            gasLimit: gasLimit,
+            function: 'multiPairSwap',
+            arguments:
+                args.swapType == SWAP_TYPE.fixedInput
+                    ? this.multiPairFixedInputSwaps(args)
+                    : this.multiPairFixedOutputSwaps(args),
+            tokenTransfers: [
+                new TokenTransfer({
+                    token: new Token({
+                        identifier: args.tokenRoute[0],
+                    }),
+                    amount: BigInt(amountIn.integerValue().toFixed()),
+                }),
+            ],
+        });
+
+        const transaction =
+            await this.mxProxy.getRouterSmartContractTransaction(
+                transactionOptions,
+            );
+        transactions.push(transaction);
 
-        transactions.push(
-            contract.methodsExplicit
-                .multiPairSwap(transactionArgs)
-                .withSingleESDTTransfer(
-                    TokenTransfer.fungibleFromBigInteger(
-                        args.tokenRoute[0],
-                        amountIn.integerValue(),
-                    ),
-                )
-                .withGasLimit(gasLimit)
-                .withChainID(mxConfig.chainID)
-                .buildTransaction()
-                .toPlainObject(),
-        );
         if (args.tokenOutID === mxConfig.EGLDIdentifier) {
             transactions.push(
                 await this.transactionsWrapService.unwrapEgld(
@@ -209,6 +218,7 @@ export class AutoRouterTransactionService {
     }
 
     async wrapEgldAndMultiSwapTransaction(
+        sender: string,
         value: string,
         args: MultiSwapTokensArgs,
     ): Promise<TransactionModel> {
@@ -219,6 +229,7 @@ export class AutoRouterTransactionService {
         const swaps = this.convertMultiPairSwapsToBytesValues(typedArgs);
 
         return this.composeTasksTransactionService.getComposeTasksTransaction(
+            sender,
             new EsdtTokenPayment({
                 tokenIdentifier: 'EGLD',
                 tokenNonce: 0,
@@ -245,6 +256,7 @@ export class AutoRouterTransactionService {
     }
 
     async multiSwapAndUnwrapEgldTransaction(
+        sender: string,
         value: string,
         args: MultiSwapTokensArgs,
     ): Promise<TransactionModel> {
@@ -255,6 +267,7 @@ export class AutoRouterTransactionService {
         const swaps = this.convertMultiPairSwapsToBytesValues(typedArgs);
 
         return this.composeTasksTransactionService.getComposeTasksTransaction(
+            sender,
             new EsdtTokenPayment({
                 tokenIdentifier: args.tokenRoute[0],
                 tokenNonce: 0,

diff --git a/src/modules/auto-router/specs/auto-router.service.spec.ts b/src/modules/auto-router/specs/auto-router.service.spec.ts
@@ -20,8 +20,6 @@ import { RemoteConfigGetterServiceMock } from 'src/modules/remote-config/mocks/r
 import { PairInfoModel } from 'src/modules/pair/models/pair-info.model';
 import { TokenServiceProvider } from 'src/modules/tokens/mocks/token.service.mock';
 import { Tokens } from 'src/modules/pair/mocks/pair.constants';
-import { encodeTransactionData } from 'src/helpers/helpers';
-import { gasConfig } from 'src/config';
 import { WrapAbiServiceProvider } from 'src/modules/wrapping/mocks/wrap.abi.service.mock';
 import { WrapService } from 'src/modules/wrapping/services/wrap.service';
 import { PairAbiServiceProvider } from 'src/modules/pair/mocks/pair.abi.service.mock';
@@ -37,6 +35,9 @@ import { PairFilteringService } from 'src/modules/pair/services/pair.filtering.s
 
 describe('AutoRouterService', () => {
     let service: AutoRouterService;
+    const senderAddress = Address.newFromHex(
+        '0000000000000000000000000000000000000000000000000000000000000001',
+    ).toBech32();
 
     const ContextGetterServiceProvider = {
         provide: ContextGetterService,
@@ -119,9 +120,9 @@ describe('AutoRouterService', () => {
                 tokenRoute: ['USDC-123456', 'WEGLD-123456'],
                 pairs: [
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000013',
-                        ).bech32(),
+                        ).toBech32(),
                         firstToken: Tokens('WEGLD-123456'),
                         secondToken: Tokens('USDC-123456'),
                         info: new PairInfoModel({
@@ -163,9 +164,9 @@ describe('AutoRouterService', () => {
                 tokenRoute: ['USDC-123456', 'WEGLD-123456'],
                 pairs: [
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000013',
-                        ).bech32(),
+                        ).toBech32(),
                         firstToken: Tokens('WEGLD-123456'),
                         secondToken: Tokens('USDC-123456'),
                         info: new PairInfoModel({
@@ -212,9 +213,9 @@ describe('AutoRouterService', () => {
                 tokenRoute: ['USDC-123456', 'WEGLD-123456', 'MEX-123456'],
                 pairs: [
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000013',
-                        ).bech32(),
+                        ).toBech32(),
                         firstToken: Tokens('WEGLD-123456'),
                         secondToken: Tokens('USDC-123456'),
                         info: new PairInfoModel({
@@ -225,9 +226,9 @@ describe('AutoRouterService', () => {
                         totalFeePercent: 0.003,
                     }),
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000012',
-                        ).bech32(),
+                        ).toBech32(),
                         firstToken: Tokens('WEGLD-123456'),
                         secondToken: Tokens('MEX-123456'),
                         info: new PairInfoModel({
@@ -247,7 +248,7 @@ describe('AutoRouterService', () => {
 
     it('should get a wrap tx + a fixed input simple swap tx', async () => {
         const transactions = await service.getTransactions(
-            Address.Zero().bech32(),
+            senderAddress,
             new AutoRouteModel({
                 swapType: 0,
                 tokenInID: 'EGLD',
@@ -265,9 +266,9 @@ describe('AutoRouterService', () => {
                 tokenRoute: ['USDC-123456', 'WEGLD-123456'],
                 pairs: [
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000013',
-                        ).bech32(),
+                        ).toBech32(),
                     }),
                 ],
                 tolerance: 0.01,
@@ -277,15 +278,15 @@ describe('AutoRouterService', () => {
             {
                 nonce: 0,
                 value: '1000000000000000000',
-                receiver: Address.Zero().bech32(),
-                sender: '',
+                receiver: Address.Zero().toBech32(),
+                sender: senderAddress,
                 receiverUsername: undefined,
                 senderUsername: undefined,
                 gasPrice: 1000000000,
                 gasLimit: 40200000,
                 data: 'Y29tcG9zZVRhc2tzQDAwMDAwMDBiNTU1MzQ0NDMyZDMxMzIzMzM0MzUzNjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwNzExNzJhY2UwMjZiMGM0QEBAMDJAMDAwMDAwMTQ3Mzc3NjE3MDU0NmY2YjY1NmU3MzQ2Njk3ODY1NjQ0OTZlNzA3NTc0MDAwMDAwMGI1NTUzNDQ0MzJkMzEzMjMzMzQzNTM2MDAwMDAwMDcxMTcyYWNlMDI2YjBjNA==',
                 chainID: 'T',
-                version: 1,
+                version: 2,
                 options: undefined,
                 signature: undefined,
                 guardian: undefined,
@@ -296,7 +297,7 @@ describe('AutoRouterService', () => {
 
     it('should get a fixed output multi swap tx + unwrap tx', async () => {
         const transactions = await service.getTransactions(
-            Address.Zero().bech32(),
+            senderAddress,
             new AutoRouteModel({
                 swapType: 1,
                 tokenInID: 'USDC-123456',
@@ -315,14 +316,14 @@ describe('AutoRouterService', () => {
                 tokenRoute: ['USDC-123456', 'WEGLD-123456', 'MEX-123456'],
                 pairs: [
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000013',
-                        ).bech32(),
+                        ).toBech32(),
                     }),
                     new PairModel({
-                        address: Address.fromHex(
+                        address: Address.newFromHex(
                             '0000000000000000000000000000000000000000000000000000000000000012',
-                        ).bech32(),
+                        ).toBech32(),
                     }),
                 ],
                 tolerance: 0.01,
@@ -332,15 +333,15 @@ describe('AutoRouterService', () => {
             {
                 nonce: 0,
                 value: '0',
-                receiver: Address.Zero().bech32(),
-                sender: '',
+                receiver: Address.Zero().toBech32(),
+                sender: senderAddress,
                 receiverUsername: undefined,
                 senderUsername: undefined,
                 gasPrice: 1000000000,
                 gasLimit: 75200000,
                 data: 'RVNEVFRyYW5zZmVyQDU1NTM0NDQzMmQzMTMyMzMzNDM1MzZAMDcwY2VmOWY1ZWRmY2YyOEA2MzZmNmQ3MDZmNzM2NTU0NjE3MzZiNzNAMDAwMDAwMDQ0NTQ3NGM0NDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwODA2ZjA1YjU5ZDNiMjAwMDBAMDNAMDAwMDAwMjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDEzMDAwMDAwMTU3Mzc3NjE3MDU0NmY2YjY1NmU3MzQ2Njk3ODY1NjQ0Zjc1NzQ3MDc1NzQwMDAwMDAwYzU3NDU0NzRjNDQyZDMxMzIzMzM0MzUzNjAwMDAwMDA1OTJhZmQ4YjAyZjAwMDAwMDIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAxMjAwMDAwMDE1NzM3NzYxNzA1NDZmNmI2NTZlNzM0NjY5Nzg2NTY0NGY3NTc0NzA3NTc0MDAwMDAwMGE0ZDQ1NTgyZDMxMzIzMzM0MzUzNjAwMDAwMDA4MDZmMDViNTlkM2IyMDAwMEAwMUA=',
                 chainID: 'T',
-                version: 1,
+                version: 2,
                 options: undefined,
                 signature: undefined,
                 guardian: undefined,

diff --git a/src/modules/common/transaction.options.ts b/src/modules/common/transaction.options.ts
@@ -0,0 +1,15 @@
+import { TokenTransfer } from '@multiversx/sdk-core';
+
+export class TransactionOptions {
+    chainID?: string;
+    function: string;
+    gasLimit: number;
+    sender: string;
+    arguments?: any[];
+    tokenTransfers?: TokenTransfer[];
+    nativeTransferAmount?: string;
+
+    constructor(init?: Partial<TransactionOptions>) {
+        Object.assign(this, init);
+    }
+}