Development

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [[v2.24.3]](https://github.com/multiversx/mx-sdk-dapp/pull/979)] - 2023-11-29
+
+- [Removed `senderUsername` and `receiverUsername` for `SetGuardian` tx](https://github.com/multiversx/mx-sdk-dapp/pull/978)
+- [Added extra gas fee for guardian transactions](https://github.com/multiversx/mx-sdk-dapp/pull/977)
+
 ## [[v2.24.2]](https://github.com/multiversx/mx-sdk-dapp/pull/976)] - 2023-11-28
 - [Fixed logout for wallet provider](https://github.com/multiversx/mx-sdk-dapp/pull/975)
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiversx/sdk-dapp",
-  "version": "2.24.2",
+  "version": "2.24.3",
   "description": "A library to hold the main logic for a dapp on the MultiversX blockchain",
   "author": "MultiversX",
   "license": "GPL-3.0-or-later",

src/constants/guardianActions.enum.ts

@@ -0,0 +1,5 @@
+export enum GuardianActionsEnum {
+  SetGuardian = 'SetGuardian',
+  GuardAccount = 'GuardAccount',
+  UnGuardAccount = 'UnGuardAccount'
+}

src/constants/index.ts

@@ -1,6 +1,7 @@
 export * from './dataTestIds.enum';
 export * from './errorsMessages';
 export * from './extension.constants';
+export * from './guardianActions.enum';
 export * from './ledger.constants';
 export * from './ledgerErrorCodes';
 export * from './mnemonicWords';

src/models/newTransaction.ts

@@ -7,40 +7,45 @@ import {
 import { GAS_LIMIT, GAS_PRICE, VERSION } from 'constants/index';
 import { RawTransactionType } from 'types';
 import { getDataPayloadForTransaction } from 'utils/transactions/getDataPayloadForTransaction';
+import { isGuardianTx } from 'utils/transactions/isGuardianTx';
 
 export function newTransaction(rawTransaction: RawTransactionType) {
+  const rawTx = Object.assign({}, rawTransaction);
+
+  // TODO: Remove when the protocol supports usernames for guardian transactions
+  if (isGuardianTx({ data: rawTx.data, onlySetGuardian: true })) {
+    delete rawTx.senderUsername;
+    delete rawTx.receiverUsername;
+  }
+
   const transaction = new Transaction({
-    value: rawTransaction.value.valueOf(),
-    data: getDataPayloadForTransaction(rawTransaction.data),
-    nonce: rawTransaction.nonce.valueOf(),
-    receiver: new Address(rawTransaction.receiver),
-    ...(rawTransaction.receiverUsername
-      ? { receiverUsername: rawTransaction.receiverUsername }
-      : {}),
-    sender: new Address(rawTransaction.sender),
-    ...(rawTransaction.senderUsername
-      ? { senderUsername: rawTransaction.senderUsername }
+    value: rawTx.value.valueOf(),
+    data: getDataPayloadForTransaction(rawTx.data),
+    nonce: rawTx.nonce.valueOf(),
+    receiver: new Address(rawTx.receiver),
+    ...(rawTx.receiverUsername
+      ? { receiverUsername: rawTx.receiverUsername }
       : {}),
-    gasLimit: rawTransaction.gasLimit.valueOf() ?? GAS_LIMIT,
-    gasPrice: rawTransaction.gasPrice.valueOf() ?? GAS_PRICE,
-    chainID: rawTransaction.chainID.valueOf(),
-    version: new TransactionVersion(rawTransaction.version ?? VERSION),
-    ...(rawTransaction.options
-      ? { options: new TransactionOptions(rawTransaction.options) }
+    sender: new Address(rawTx.sender),
+    ...(rawTx.senderUsername ? { senderUsername: rawTx.senderUsername } : {}),
+    gasLimit: rawTx.gasLimit.valueOf() ?? GAS_LIMIT,
+    gasPrice: rawTx.gasPrice.valueOf() ?? GAS_PRICE,
+    chainID: rawTx.chainID.valueOf(),
+    version: new TransactionVersion(rawTx.version ?? VERSION),
+    ...(rawTx.options
+      ? { options: new TransactionOptions(rawTx.options) }
       : {}),
-    ...(rawTransaction.guardian
-      ? { guardian: new Address(rawTransaction.guardian) }
-      : {})
+    ...(rawTx.guardian ? { guardian: new Address(rawTx.guardian) } : {})
   });
 
-  if (rawTransaction.guardianSignature) {
+  if (rawTx.guardianSignature) {
     transaction.applyGuardianSignature(
-      Buffer.from(rawTransaction.guardianSignature, 'hex')
+      Buffer.from(rawTx.guardianSignature, 'hex')
     );
   }
 
-  if (rawTransaction.signature) {
-    transaction.applySignature(Buffer.from(rawTransaction.signature, 'hex'));
+  if (rawTx.signature) {
+    transaction.applySignature(Buffer.from(rawTx.signature, 'hex'));
   }
 
   return transaction;

src/services/transactions/signTransactions.ts

@@ -15,6 +15,7 @@ import {
   SendTransactionReturnType,
   SignTransactionsPropsType
 } from 'types';
+import { isGuardianTx } from 'utils/transactions/isGuardianTx';
 import { stringIsFloat } from 'utils/validation/stringIsFloat';
 import { calcTotalFee } from './utils';
 
@@ -74,8 +75,15 @@ export async function signTransactions({
         customTransactionInformation?.signWithoutSending ?? true
     },
     transactions: transactionsPayload.map((tx) => {
+      const transaction = tx.toPlainObject();
+
+      // TODO: Remove when the protocol supports usernames for guardian transactions
+      if (isGuardianTx({ data: transaction.data, onlySetGuardian: true })) {
+        return transaction;
+      }
+
       return {
-        ...tx.toPlainObject(),
+        ...transaction,
         senderUsername: tx.getSenderUsername().valueOf(),
         receiverUsername: tx.getReceiverUsername().valueOf()
       };

src/utils/operations/calculateFeeLimit.ts

@@ -6,7 +6,14 @@ import {
   TokenPayment
 } from '@multiversx/sdk-core';
 import { NetworkConfig } from '@multiversx/sdk-network-providers';
-import { GAS_LIMIT, GAS_PRICE, ZERO } from 'constants/index';
+import BigNumber from 'bignumber.js';
+import {
+  EXTRA_GAS_LIMIT_GUARDED_TX,
+  GAS_LIMIT,
+  GAS_PRICE,
+  ZERO
+} from 'constants/index';
+import { isGuardianTx } from 'utils/transactions/isGuardianTx';
 import { stringIsFloat, stringIsInteger } from 'utils/validation';
 
 export interface CalculateFeeLimitType {
@@ -35,14 +42,21 @@ export function calculateFeeLimit({
 }: CalculateFeeLimitType) {
   const data = inputData || '';
   const validGasLimit = stringIsInteger(gasLimit) ? gasLimit : minGasLimit;
+
+  // We need to add extra gas fee for guardian transactions
+  const extraGasLimit = isGuardianTx({ data }) ? EXTRA_GAS_LIMIT_GUARDED_TX : 0;
+  const usedGasLimit = new BigNumber(validGasLimit)
+    .plus(extraGasLimit)
+    .toNumber();
+
   const validGasPrice = stringIsFloat(gasPrice) ? gasPrice : defaultGasPrice;
   const transaction = new Transaction({
     nonce: 0,
     value: TokenPayment.egldFromAmount('0'),
     receiver: new Address(placeholderData.to),
     sender: new Address(placeholderData.to),
     gasPrice: parseInt(validGasPrice),
-    gasLimit: parseInt(validGasLimit),
+    gasLimit: usedGasLimit,
     data: new TransactionPayload(data.trim()),
     chainID: chainId,
     version: new TransactionVersion(1)
@@ -52,11 +66,12 @@ export function calculateFeeLimit({
   networkConfig.MinGasLimit = parseInt(minGasLimit);
   networkConfig.GasPerDataByte = parseInt(gasPerDataByte);
   networkConfig.GasPriceModifier = parseFloat(gasPriceModifier);
+
   try {
     const bNfee = transaction.computeFee(networkConfig);
-    const fee = bNfee.toString(10);
-    return fee;
+    return bNfee.toString(10);
   } catch (err) {
+    console.error(err);
     return ZERO;
   }
 }

src/utils/operations/tests/calculateFeeLimit.test.tsx

@@ -13,16 +13,84 @@ describe('calculateFeeLimit tests', () => {
     });
     expect(feeLimit).toBe('62000000000000');
   });
+
   it('computes correct fee', () => {
     const feeLimit = calculateFeeLimit({
       gasLimit: '11100000',
       gasPrice: '1000000000',
       data: 'bid@0d59@43525a502d333663366162@25',
-      gasPerDataByte: '1500',
+      gasPerDataByte: String(GAS_PER_DATA_BYTE),
+      gasPriceModifier: String(GAS_PRICE_MODIFIER),
       defaultGasPrice: '1000000000',
-      gasPriceModifier: '0.01',
       chainId: 'T'
     });
+
     expect(feeLimit).toBe('210990000000000');
   });
+
+  it('computes correct fee for SetGuardian tx', () => {
+    const feeLimit = calculateFeeLimit({
+      gasLimit: '',
+      gasPrice: (1_000_000).toString(),
+      data: 'SetGuardian@qwerty@12345',
+      chainId: 'T',
+      gasPerDataByte: '1',
+      gasPriceModifier: '1'
+    });
+
+    expect(feeLimit).toBe((100_000_000_000).toString()); // (minGasLimit + extra guardian gas) * gasPrice
+  });
+
+  it('computes correct fee for GuardAccount tx', () => {
+    const feeLimit = calculateFeeLimit({
+      gasLimit: '',
+      gasPrice: (1_000_000).toString(),
+      data: 'GuardAccount@qwerty@12345',
+      chainId: 'T',
+      gasPerDataByte: '1',
+      gasPriceModifier: '1'
+    });
+
+    expect(feeLimit).toBe((100_000_000_000).toString()); // (minGasLimit + extra guardian gas) * gasPrice
+  });
+
+  it('computes correct fee for UnGuardAccount tx', () => {
+    const feeLimit = calculateFeeLimit({
+      gasLimit: '',
+      gasPrice: (1_000_000).toString(),
+      data: 'UnGuardAccount@qwerty@12345',
+      chainId: 'T',
+      gasPerDataByte: '1',
+      gasPriceModifier: '1'
+    });
+
+    expect(feeLimit).toBe((100_000_000_000).toString()); // (minGasLimit + extra guardian gas) * gasPrice
+  });
+
+  it('computes correct fee for UnGuardAccount tx and gas limit specified', () => {
+    const feeLimit = calculateFeeLimit({
+      gasLimit: (1_000_000).toString(),
+      gasPrice: (1_000_000).toString(),
+      data: 'UnGuardAccount@qwerty@12345',
+      chainId: 'T',
+      gasPerDataByte: '1',
+      gasPriceModifier: '1'
+    });
+
+    expect(feeLimit).toBe((1_050_000_000_000).toString()); // (gasLimit + extra guardian gas) * gasPrice
+  });
+
+  it('computes correct fee for UnGuardAccount tx and min gas limit specified', () => {
+    const feeLimit = calculateFeeLimit({
+      gasLimit: '',
+      minGasLimit: (1_000_000).toString(),
+      gasPrice: (1_000_000).toString(),
+      data: 'UnGuardAccount@qwerty@12345',
+      chainId: 'T',
+      gasPerDataByte: '1',
+      gasPriceModifier: '1'
+    });
+
+    expect(feeLimit).toBe((1_050_000_000_000).toString()); // (minGasLimit + extra guardian gas) * gasPrice
+  });
 });

src/utils/transactions/index.ts

@@ -5,6 +5,7 @@ export * from './getInterpretedTransaction';
 export * from './getTokenFromData';
 export * from './getTransactionLink';
 export * from './getUnHighlightedDataFieldParts';
+export * from './isGuardianTx';
 export * from './isTokenTransfer';
 export * from './parseMultiEsdtTransferData';
 export * from './parseTransactionAfterSigning';

src/utils/transactions/isGuardianTx.tsx

@@ -0,0 +1,21 @@
+import { GuardianActionsEnum } from 'constants/index';
+
+export const isGuardianTx = ({
+  data,
+  onlySetGuardian
+}: {
+  data?: string;
+  onlySetGuardian?: boolean;
+}) => {
+  if (!data) {
+    return false;
+  }
+
+  if (onlySetGuardian) {
+    return data.startsWith(GuardianActionsEnum.SetGuardian);
+  }
+
+  return Object.values(GuardianActionsEnum).some((action) =>
+    data.startsWith(action)
+  );
+};

src/utils/transactions/parseTransactionAfterSigning.ts

@@ -3,6 +3,7 @@ import { PlainSignedTransaction } from '@multiversx/sdk-web-wallet-provider/out/
 import { newTransaction } from 'models';
 import { SignedTransactionType } from 'types';
 import { TransactionServerStatusesEnum } from 'types/enums.types';
+import { isGuardianTx } from './isGuardianTx';
 
 export function parseTransactionAfterSigning(
   signedTransaction: Transaction | PlainSignedTransaction
@@ -21,5 +22,12 @@ export function parseTransactionAfterSigning(
     receiverUsername: transaction.getReceiverUsername().valueOf(),
     status: TransactionServerStatusesEnum.pending
   };
+
+  // TODO: Remove when the protocol supports usernames for guardian transactions
+  if (isGuardianTx({ data: parsedTransaction.data, onlySetGuardian: true })) {
+    delete parsedTransaction.senderUsername;
+    delete parsedTransaction.receiverUsername;
+  }
+
   return parsedTransaction;
 }

src/utils/transactions/tests/isGuardianTx.test.ts

@@ -0,0 +1,54 @@
+import { GuardianActionsEnum } from 'constants/index';
+import { isGuardianTx } from '../isGuardianTx';
+
+describe('isGuardianTx Function', () => {
+  // Test Valid Actions
+  Object.values(GuardianActionsEnum).forEach((action) => {
+    test(`should return true for valid action starting with "${action}"`, () => {
+      expect(isGuardianTx({ data: `${action}ExtraInfo` })).toBe(true);
+    });
+  });
+
+  // Test when onlySetGuardian is true
+  test('should return true only for SetGuardian action when onlySetGuardian is true', () => {
+    expect(
+      isGuardianTx({ data: 'SetGuardianExtraInfo', onlySetGuardian: true })
+    ).toBe(true);
+    expect(
+      isGuardianTx({
+        data: 'GuardAccountAdditionalData',
+        onlySetGuardian: true
+      })
+    ).toBe(false);
+    expect(
+      isGuardianTx({
+        data: 'UnGuardAccountSomethingElse',
+        onlySetGuardian: true
+      })
+    ).toBe(false);
+  });
+
+  // Test Invalid Actions
+  test('should return false for invalid actions', () => {
+    expect(isGuardianTx({ data: 'InvalidAction' })).toBe(false);
+    expect(isGuardianTx({ data: 'SetAccountGuard' })).toBe(false);
+    expect(isGuardianTx({ data: 'AccountUnGuard' })).toBe(false);
+  });
+
+  // Test Empty String
+  test('should return false for an empty string', () => {
+    expect(isGuardianTx({ data: '' })).toBe(false);
+  });
+
+  // Test Null or Undefined
+  test('should return false for null or undefined data', () => {
+    expect(isGuardianTx({ data: undefined })).toBe(false);
+  });
+
+  // Test Partial Matches
+  test('should return false for partial matches', () => {
+    expect(isGuardianTx({ data: 'Set' })).toBe(false);
+    expect(isGuardianTx({ data: 'Guard' })).toBe(false);
+    expect(isGuardianTx({ data: 'UnGuard' })).toBe(false);
+  });
+});