Resolved issue with send tx from a multi-sig account (#4654)

* fix: resolved issue with send from multi-sig account

* fix: resolved fee issue on multi-sig  token:trasnfer

* fix: updated token balance lookup on reg delegate

* fix: resolved failing unit test

* fix: resolved issue with unable to reg delegate from multi-sig

* fix: removed useless console.log

Co-authored-by: Manu <[email protected]>

src/modules/common/components/OldMultiStep/index.js

@@ -88,7 +88,6 @@ class MultiStep extends React.Component {
     };
 
     extraProps.prevState = { ...step.data[step.current + 1] };
-
     return (
       <div className={className}>
         <MultiStepNav

src/modules/dpos/validator/components/RegisterDelegateForm/index.js

@@ -1,14 +1,16 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { MODULE_COMMANDS_NAME_MAP } from 'src/modules/transaction/configuration/moduleCommand';
 import BoxHeader from 'src/theme/box/header';
 import BoxContent from 'src/theme/box/content';
 import { Input } from 'src/theme';
 import TxComposer from '@transaction/components/TxComposer';
+import { useTokensBalance } from '@token/fungible/hooks/queries';
 import useDelegateName from '../../hooks/useDelegateName';
 import useDelegateKey from '../../hooks/useDelegateKey';
 import InputLabel from './InputLabel';
 import styles from './form.css';
+import { useDposConstants } from '../../hooks/queries';
 
 const isFormValid = (name, generatorKey, blsKey, proofOfPossession) =>
   !name.error && !name.loading && !generatorKey.error && !blsKey.error && !proofOfPossession.error;
@@ -20,6 +22,7 @@ const getTooltips = (field, t) => {
   return t('Run lisk keys:generate and copy the value of {{field}}', { field });
 };
 
+// eslint-disable-next-line max-statements
 const RegisterDelegateForm = ({ nextStep, prevState }) => {
   const { t } = useTranslation();
   const [name, setName] = useDelegateName(prevState?.rawTx?.params.name);
@@ -39,6 +42,13 @@ const RegisterDelegateForm = ({ nextStep, prevState }) => {
     prevState?.rawTx?.params.proofOfPossession
   );
 
+  const { data: dposConstants, isLoading: isGettingDposConstants } = useDposConstants();
+  const { data: tokens } = useTokensBalance({
+    config: { params: { tokenID: dposConstants?.tokenIDDPoS } },
+    options: { enabled: !isGettingDposConstants },
+  });
+  const token = useMemo(() => tokens?.data?.[0] || {}, [tokens]);
+
   const onConfirm = (formProps, transactionJSON, selectedPriority, fees) => {
     nextStep({
       selectedPriority,
@@ -55,6 +65,7 @@ const RegisterDelegateForm = ({ nextStep, prevState }) => {
   const registerDelegateFormProps = {
     isValid: isFormValid(name, generatorKey, blsKey, proofOfPossession),
     moduleCommand: MODULE_COMMANDS_NAME_MAP.registerDelegate,
+    fields: { token },
   };
   const commandParams = {
     name: name.value,

src/modules/dpos/validator/components/RegisterDelegateForm/index.test.js

@@ -3,10 +3,18 @@ import { useCommandSchema } from '@network/hooks/useCommandsSchema';
 import wallets from '@tests/constants/wallets';
 import * as keys from '@tests/constants/keys';
 import { mockCommandParametersSchemas } from 'src/modules/common/__fixtures__';
+import { useTokensBalance } from '@token/fungible/hooks/queries';
+import { mockTokensBalance } from 'src/modules/token/fungible/__fixtures__';
+import { useDposConstants } from '../../hooks/queries';
+import { mockDposConstants } from '../../__fixtures__/mockDposConstants';
+
 import useDelegateName from '../../hooks/useDelegateName';
 import useDelegateKey from '../../hooks/useDelegateKey';
 import RegisterDelegateForm from '.';
 
+jest.mock('../../hooks/queries');
+jest.mock('@token/fungible/hooks/queries');
+
 jest.mock('@network/hooks/useCommandsSchema');
 jest.mock('../../hooks/useDelegateName', () => jest.fn());
 jest.mock('../../hooks/useDelegateKey', () => jest.fn());
@@ -49,6 +57,8 @@ describe('RegisterDelegateForm', () => {
   const setName = jest.fn();
   const setKey = jest.fn();
 
+  useDposConstants.mockReturnValue({ data: mockDposConstants });
+  useTokensBalance.mockReturnValue({ data: mockTokensBalance, isLoading: false });
   useCommandSchema.mockReturnValue(
     mockCommandParametersSchemas.data.reduce(
       (result, { moduleCommand, schema }) => ({ ...result, [moduleCommand]: schema }),
@@ -180,6 +190,9 @@ describe('RegisterDelegateForm', () => {
           Initialisation: '0 LSK',
           Transaction: '0 LSK',
         },
+        fields: {
+          token: mockTokensBalance.data[0],
+        },
         isValid: true,
         moduleCommand: 'dpos:registerDelegate',
       },

src/modules/transaction/api/index.js

@@ -202,6 +202,7 @@ export const getTransactionFee = async ({
   selectedPriority,
   numberOfSignatures = DEFAULT_NUMBER_OF_SIGNATURES,
   moduleCommandSchemas,
+  senderAccount = { numberOfSignatures: 0, optionalKeys: [], mandatoryKeys: [] },
 }) => {
   const feePerByte = selectedPriority.value;
   const moduleCommand = joinModuleAndCommand(transactionJSON);
@@ -215,23 +216,30 @@ export const getTransactionFee = async ({
     numberOfSignatures = optionalKeys.length + mandatoryKeys.length;
   }
 
-  // Call API to get network specific base fees
-  const baseFees = [];
+  const allocateEmptySignaturesWithEmptyBuffer = (signatureCount) =>
+    new Array(signatureCount).fill(Buffer.alloc(64));
+
+  // @TODO: impelement transaction fee calculation based on domain fee constants
+  const { mandatoryKeys, optionalKeys } = senderAccount;
   const minFee = transactions.computeMinFee(
     {
       ...transactionObject,
       params: {
         ...transactionObject.params,
         ...(numberOfSignatures &&
           !transactionObject.params.signatures?.length && {
-            signatures: new Array(numberOfSignatures).fill(0).map(() => Buffer.alloc(64)),
+            signatures: allocateEmptySignaturesWithEmptyBuffer(numberOfSignatures),
           }),
       },
     },
     paramsSchema,
-    {
-      baseFees,
-    }
+    senderAccount.numberOfSignatures
+      ? {
+          numberOfSignatures: senderAccount.numberOfSignatures,
+          numberOfEmptySignatures:
+            mandatoryKeys.length + optionalKeys.length - senderAccount.numberOfSignatures,
+        }
+      : {}
   );
 
   // tie breaker is only meant for medium and high processing speeds
@@ -243,7 +251,6 @@ export const getTransactionFee = async ({
   const cappedFee = Math.min(calculatedFee, maxCommandFee);
   const feeInLsk = fromRawLsk(cappedFee.toString());
   const roundedValue = Number(feeInLsk).toFixed(7).toString();
-
   const feedback = transactionJSON.amount === '' ? '-' : `${roundedValue ? '' : 'Invalid amount'}`;
 
   return {

src/modules/transaction/components/TransactionMonitor/transactionsTable.css

@@ -1,6 +1,6 @@
 .tableHeader {
   position: sticky;
-  top: 70px;
+  top: 85px;
   background: var(--color-white);
   z-index: 2;
   border-bottom: 2px solid var(--color-mystic);

src/modules/transaction/components/TxSignatureCollector/TxSignatureCollector.js

@@ -15,7 +15,6 @@ const isModuleCommandValid = (moduleCommand) => /^\w+:\w+$/g.test(moduleCommand)
 
 // eslint-disable-next-line max-statements
 const TxSignatureCollector = ({
-  // t,
   transactions,
   actionFunction,
   multisigTransactionSigned,
@@ -24,7 +23,6 @@ const TxSignatureCollector = ({
   nextStep,
   prevStep,
   statusInfo,
-  transactionDoubleSigned,
   fees,
   selectedPriority,
 }) => {
@@ -104,14 +102,16 @@ const TxSignatureCollector = ({
 
   useEffect(() => {
     if (!isEmpty(transactions.signedTransaction)) {
-      const isDoubleSigned = !transactions.signedTransaction.signatures.some(
-        (sig) => sig.length === 0
-      );
-      if (!transactions.txSignatureError && !isDoubleSigned) {
-        transactionDoubleSigned();
-        return;
-      }
+      // @TODO: more investigation needs to be done to know if this is needed
+      // const isDoubleSigned = !transactions.signedTransaction.signatures.some(
+      //   (sig) => sig.length === 0
+      // );
+      // if (!transactions.txSignatureError && isDoubleSigned) {
+      //   transactionDoubleSigned(moduleCommandSchemas);
+      //   return;
+      // }
       nextStep({ formProps, transactionJSON, statusInfo, sender });
+      return;
     }
 
     if (transactions.txSignatureError) {

src/modules/transaction/components/TxSignatureCollector/TxSignatureCollector.test.js

@@ -214,7 +214,8 @@ describe('TxSignatureCollector', () => {
     expect(props.nextStep).toHaveBeenCalled();
   });
 
-  it('should call transactionDoubleSigned', () => {
+    // @TODO: should be re-instated if double tx signing is reinstated
+  it.skip('should call transactionDoubleSigned', () => {
     const signedTransactionProps = {
       ...props,
       transactions: {

src/modules/transaction/configuration/statusConfig.js

@@ -94,12 +94,7 @@ export const getTransactionStatus = (account, transactions, isMultisignature, ca
       return { code: txStatusTypes.multisigSignaturePartialSuccess };
     }
 
-    if (
-      isMultisignature &&
-      ((moduleCommand !== MODULE_COMMANDS_NAME_MAP.registerDelegate &&
-        nonEmptySignatures === numberOfSignatures) ||
-        canSenderSignTx)
-    ) {
+    if (isMultisignature && (nonEmptySignatures === numberOfSignatures || canSenderSignTx)) {
       return { code: txStatusTypes.multisigSignatureSuccess };
     }
 

src/modules/transaction/hooks/useTransactionFeeCalculation.js

@@ -1,4 +1,5 @@
-import { useEffect, useReducer } from 'react';
+import { useEffect, useMemo, useReducer } from 'react';
+import { useAuth } from '@auth/hooks/queries';
 import { useCommandSchema } from '@network/hooks';
 import { getTransactionFee } from '../api';
 import { getNumberOfSignatures } from '../utils/transaction';
@@ -24,20 +25,28 @@ const useTransactionFeeCalculation = ({
 }) => {
   const [state, dispatch] = useReducer(reducer, wallet, getInitialState);
   const { moduleCommandSchemas } = useCommandSchema();
+  const { data: account } = useAuth({ config: { params: { address: wallet?.summary?.address } } });
+  const senderAccount = useMemo(() => account?.data || {}, [account]);
 
   const calculateTransactionFees = async (params) => {
-    const fee = await getTransactionFee(params);
+    // @TODO: we need to find out why fee and minFee have the same implementations
+    const fee = await getTransactionFee({
+      ...params,
+      senderAccount,
+      selectedPriority: priorityOptions[0],
+    });
     dispatch({ type: actionTypes.setFee, payload: { response: fee, wallet, token } });
 
     const minFee = await getTransactionFee({
       ...params,
+      senderAccount,
       selectedPriority: priorityOptions[0],
     });
-
     dispatch({ type: actionTypes.setMinFee, payload: { response: minFee, wallet, token } });
 
     const maxAmountFee = await getTransactionFee({
       ...params,
+      senderAccount,
       transactionJSON: { ...params.transactionJSON, amount: wallet.token?.balance },
     });
 
@@ -59,7 +68,12 @@ const useTransactionFeeCalculation = ({
         numberOfSignatures: getNumberOfSignatures(wallet, transactionJSON),
       });
     }
-  }, [transactionJSON.params, selectedPriority.selectedIndex, selectedPriority.value]);
+  }, [
+    transactionJSON.params,
+    selectedPriority.selectedIndex,
+    selectedPriority.value,
+    senderAccount,
+  ]);
 
   return state;
 };

src/modules/transaction/store/actions.js

@@ -94,24 +94,25 @@ export const resetTransactionResult = () => ({
  * @param {string} data.secondPass
  */
 // eslint-disable-next-line max-statements
-export const transactionDoubleSigned = () => async (dispatch, getState) => {
+export const transactionDoubleSigned = (moduleCommandSchemas) => async (dispatch, getState) => {
   const state = getState();
   const { transactions, network } = state;
   const keyPair = await extractKeyPair({
     passphrase: state.wallet.secondPassphrase,
     enableCustomDerivationPath: false,
   });
   const activeWallet = selectActiveTokenAccount(state);
-  const schemas = network.networks.LSK.moduleCommandSchemas[transactions.moduleCommand];
-  const transaction = toTransactionJSON(transactions.signedTransaction, schemas[transactions.moduleCommand]);
+  const transaction = toTransactionJSON(transactions.signedTransaction, moduleCommandSchemas[transactions.moduleCommand]);
   const [signedTx, err] = await signMultisigTransaction(
     activeWallet,
+    // SenderAccount is the same of the double-signer
     {
-      data: activeWallet, // SenderAccount is the same of the double-signer
+      ...activeWallet.keys,
+      ...activeWallet.keys,
     },
     transaction,
     signatureCollectionStatus.partiallySigned,
-    schemas[transactions.moduleCommand],
+    moduleCommandSchemas[transactions.moduleCommand],
     network.networks.LSK.chainID,
     keyPair.privateKey,
   );

src/modules/transaction/utils/transaction.js

@@ -412,7 +412,6 @@ const signMultisigTransaction = async (
    */
   const moduleCommand = joinModuleAndCommand(transactionJSON);
   const isRegisterMultisignature = moduleCommand === registerMultisignature;
-
   const keys = {
     mandatoryKeys: senderAccount.mandatoryKeys.map((key) => Buffer.from(key, 'hex')),
     optionalKeys: senderAccount.optionalKeys.map((key) => Buffer.from(key, 'hex')),