solution: common class for new tx ui

packages/core/src/transaction/workflow/TxBuilder.ts

@@ -18,19 +18,30 @@
   isEthereum,
 } from '../../blockchains';
 import { EthereumTransactionType } from '../ethereum';
-import { CreateBitcoinTx, CreateErc20ApproveTx, CreateErc20ConvertTx, CreateErc20Tx, CreateEtherTx } from './create-tx';
+import {
+  CreateBitcoinTx,
+  CreateErc20ApproveTx,
+  CreateErc20ConvertTx,
+  CreateErc20RecoveryTx,
+  CreateErc20Tx,
+  CreateEtherRecoveryTx,
+  CreateEtherTx,
+} from './create-tx';
 import {
   AnyCreateTx,
   AnyErc20CreateTx,
   AnyEtherCreateTx,
   AnyEthereumCreateTx,
+  AnyEthereumRecoveryTx,
   fromBitcoinPlainTx,
   fromEthereumPlainTx,
   isAnyErc20CreateTx,
   isErc20ApproveCreateTx,
   isErc20ConvertCreateTx,
   isErc20CreateTx,
+  isErc20RecoveryCreateTx,
   isEtherCreateTx,
+  isEtherRecoveryCreateTx,
 } from './create-tx/types';
 import {
   AnyPlainTx,
@@ -141,23 +152,75 @@
           this.mergeEthereumTx(transaction, createTx);
         }
 
-        if (isChanged) {
-          if (isErc20ApproveCreateTx(createTx)) {
+        if (isErc20ApproveCreateTx(createTx)) {
+          if (isChanged) {
             createTx = this.transformErc20ApproveTx(createTx);
           }
 
-          if (isErc20ConvertCreateTx(createTx)) {
+          this.mergeEthereumFee(createTx);
+        }
+
+        if (isErc20ConvertCreateTx(createTx)) {
+          if (isChanged) {
             createTx = this.transformErc20ConvertTx(createTx);
           }
 
           this.mergeEthereumFee(createTx);
         }
+
+        if (isEtherRecoveryCreateTx(createTx) || isErc20RecoveryCreateTx(createTx)) {
+          if (isChanged) {
+            return this.convertEthereumRecoveryTx(createTx);
+          }
+
+          this.mergeEthereumFee(createTx);
+        }
       }
     }
 
     return createTx;
   }
 
+  private convertEthereumRecoveryTx(oldCreateTx: AnyEthereumRecoveryTx): AnyEthereumRecoveryTx {
+    const { asset, entry, feeRange, tokenRegistry } = this;
+    const { getBalance } = this.dataProvider;
+
+    const blockchain = blockchainIdToCode(entry.blockchain);
+
+    const { coinTicker, eip1559: supportEip1559 = false } = Blockchains[blockchain].params;
+
+    const type = supportEip1559 ? oldCreateTx.type : EthereumTransactionType.LEGACY;
+
+    let newCreateTx: AnyEthereumRecoveryTx;
+
+    if (tokenRegistry.hasAddress(blockchain, asset)) {
+      newCreateTx = new CreateErc20RecoveryTx(asset, tokenRegistry, blockchain, type);
+      newCreateTx.totalBalance = getBalance(entry, coinTicker) as WeiAny;
+      newCreateTx.totalTokenBalance = getBalance(entry, asset, newCreateTx.transferFrom);
+    } else {
+      newCreateTx = new CreateEtherRecoveryTx(null, blockchain, type);
+      newCreateTx.totalBalance = getBalance(entry, asset) as WeiAny;
+    }
+
+    newCreateTx.from = entry.address?.value;
+    newCreateTx.to = oldCreateTx.to;
+
+    if (blockchain === oldCreateTx.blockchain && (oldCreateTx.gasPrice?.isPositive() ?? false)) {
+      newCreateTx.gasPrice = oldCreateTx.gasPrice;
+      newCreateTx.maxGasPrice = oldCreateTx.maxGasPrice;
+      newCreateTx.priorityGasPrice = oldCreateTx.priorityGasPrice;
+    } else if (isEthereumFeeRange(feeRange)) {
+      newCreateTx.gasPrice = feeRange.stdMaxGasPrice;
+      newCreateTx.maxGasPrice = feeRange.stdMaxGasPrice;
+      newCreateTx.priorityGasPrice = feeRange.stdPriorityGasPrice;
+    }
+
+    newCreateTx.target = TxTarget.SEND_ALL;
+    newCreateTx.rebalance();
+
+    return newCreateTx;
+  }
+
   private convertEthereumTx(oldCreateTx: EthereumBasicCreateTx): EthereumBasicCreateTx {
     const { asset, entry, feeRange, ownerAddress, tokenRegistry } = this;
     const { getBalance } = this.dataProvider;

packages/core/src/transaction/workflow/create-tx/CreateErc20RecoveryTx.ts

@@ -0,0 +1,11 @@
+import { TokenRegistry } from '../../../blockchains';
+import { EthereumBasicPlainTx, TxMetaType } from '../types';
+import { CreateErc20Tx, fromPlainDetails } from './CreateErc20Tx';
+
+export class CreateErc20RecoveryTx extends CreateErc20Tx {
+  meta = { type: TxMetaType.ERC20_RECOVERY };
+
+  static fromPlain(details: EthereumBasicPlainTx, tokenRegistry: TokenRegistry): CreateErc20RecoveryTx {
+    return new CreateErc20RecoveryTx(fromPlainDetails(details, tokenRegistry), tokenRegistry);
+  }
+}

packages/core/src/transaction/workflow/create-tx/CreateEtherRecoveryTx.ts

@@ -0,0 +1,10 @@
+import { EthereumBasicPlainTx, TxMetaType } from '../types';
+import { CreateEtherTx, fromPlainDetails } from './CreateEtherTx';
+
+export class CreateEtherRecoveryTx extends CreateEtherTx {
+  meta = { type: TxMetaType.ETHER_RECOVERY };
+
+  static fromPlain(details: EthereumBasicPlainTx): CreateEtherRecoveryTx {
+    return new CreateEtherRecoveryTx(fromPlainDetails(details));
+  }
+}

packages/core/src/transaction/workflow/create-tx/index.ts

@@ -7,6 +7,7 @@ export {
   AnyErc20CreateTx,
   AnyEtherCreateTx,
   AnyEthereumCreateTx,
+  AnyEthereumRecoveryTx,
   EthereumTx,
   fromBitcoinPlainTx,
   fromErc20PlainTx,
@@ -24,9 +25,11 @@ export {
   isErc20CancelCreateTx,
   isErc20ConvertCreateTx,
   isErc20CreateTx,
+  isErc20RecoveryCreateTx,
   isErc20SpeedUpCreateTx,
   isEtherCancelCreateTx,
   isEtherCreateTx,
+  isEtherRecoveryCreateTx,
   isEtherSpeedUpCreateTx,
 } from './types';
 
@@ -36,8 +39,10 @@ export { CreateBitcoinCancelTx } from './CreateBitcoinCancelTx';
 export { CreateBitcoinSpeedUpTx } from './CreateBitcoinSpeedUpTx';
 export { CreateErc20CancelTx } from './CreateErc20CancelTx';
 export { CreateErc20ConvertTx, Erc20ConvertTxDetails } from './CreateErc20ConvertTx';
+export { CreateErc20RecoveryTx } from './CreateErc20RecoveryTx';
 export { CreateErc20SpeedUpTx } from './CreateErc20SpeedUpTx';
 export { CreateErc20Tx, Erc20TxDetails } from './CreateErc20Tx';
 export { CreateEtherCancelTx } from './CreateEtherCancelTx';
+export { CreateEtherRecoveryTx } from './CreateEtherRecoveryTx';
 export { CreateEtherSpeedUpTx } from './CreateEtherSpeedUpTx';
 export { CreateEtherTx, TxDetails } from './CreateEtherTx';

packages/core/src/transaction/workflow/create-tx/types.ts

@@ -17,9 +17,11 @@
 import { CreateErc20ApproveTx } from './CreateErc20ApproveTx';
 import { CreateErc20CancelTx } from './CreateErc20CancelTx';
 import { CreateErc20ConvertTx } from './CreateErc20ConvertTx';
+import { CreateErc20RecoveryTx } from './CreateErc20RecoveryTx';
 import { CreateErc20SpeedUpTx } from './CreateErc20SpeedUpTx';
 import { CreateErc20Tx } from './CreateErc20Tx';
 import { CreateEtherCancelTx } from './CreateEtherCancelTx';
+import { CreateEtherRecoveryTx } from './CreateEtherRecoveryTx';
 import { CreateEtherSpeedUpTx } from './CreateEtherSpeedUpTx';
 import { CreateEtherTx } from './CreateEtherTx';
 
@@ -36,7 +38,8 @@
 export type AnyEtherCreateTx = CreateEtherTx | CreateEtherCancelTx | CreateEtherSpeedUpTx;
 export type AnyErc20CreateTx = CreateErc20Tx | CreateErc20CancelTx | CreateErc20SpeedUpTx;
 export type AnyContractCreateTx = AnyErc20CreateTx | CreateErc20ApproveTx | CreateErc20ConvertTx;
-export type AnyEthereumCreateTx = AnyEtherCreateTx | AnyContractCreateTx;
+export type AnyEthereumRecoveryTx = CreateEtherRecoveryTx | CreateErc20RecoveryTx;
+export type AnyEthereumCreateTx = AnyEtherCreateTx | AnyContractCreateTx | AnyEthereumRecoveryTx;
 export type AnyCreateTx = AnyBitcoinCreateTx | AnyEthereumCreateTx;
 
 const bitcoinTxMetaTypes: Readonly<TxMetaType[]> = [
@@ -47,12 +50,14 @@
 
 const etherTxMetaTypes: Readonly<TxMetaType[]> = [
   TxMetaType.ETHER_CANCEL,
+  TxMetaType.ETHER_RECOVERY,
   TxMetaType.ETHER_SPEEDUP,
   TxMetaType.ETHER_TRANSFER,
 ];
 
 const erc20TxMetaTypes: Readonly<TxMetaType[]> = [
   TxMetaType.ERC20_CANCEL,
+  TxMetaType.ERC20_RECOVERY,
   TxMetaType.ERC20_SPEEDUP,
   TxMetaType.ERC20_TRANSFER,
 ];
@@ -91,6 +96,10 @@
   return createTx.meta.type === TxMetaType.ETHER_CANCEL;
 }
 
+export function isEtherRecoveryCreateTx(createTx: AnyCreateTx): createTx is CreateEtherRecoveryTx {
+  return createTx.meta.type === TxMetaType.ETHER_RECOVERY;
+}
+
 export function isEtherSpeedUpCreateTx(createTx: AnyCreateTx): createTx is CreateEtherSpeedUpTx {
   return createTx.meta.type === TxMetaType.ETHER_SPEEDUP;
 }
@@ -119,6 +128,10 @@
   return createTx.meta.type === TxMetaType.ERC20_CONVERT;
 }
 
+export function isErc20RecoveryCreateTx(createTx: AnyCreateTx): createTx is CreateErc20RecoveryTx {
+  return createTx.meta.type === TxMetaType.ERC20_RECOVERY;
+}
+
 export function isErc20SpeedUpCreateTx(createTx: AnyCreateTx): createTx is CreateErc20SpeedUpTx {
   return createTx.meta.type === TxMetaType.ERC20_SPEEDUP;
 }
@@ -140,6 +153,8 @@
   switch (transaction.meta.type) {
     case TxMetaType.ETHER_CANCEL:
       return CreateEtherCancelTx.fromPlain(transaction);
+    case TxMetaType.ETHER_RECOVERY:
+      return CreateEtherRecoveryTx.fromPlain(transaction);
     case TxMetaType.ETHER_SPEEDUP:
       return CreateEtherSpeedUpTx.fromPlain(transaction);
     case TxMetaType.ETHER_TRANSFER:
@@ -157,6 +172,8 @@
       return CreateErc20CancelTx.fromPlain(transaction, tokenRegistry);
     case TxMetaType.ERC20_CONVERT:
       return CreateErc20ConvertTx.fromPlain(transaction, tokenRegistry);
+    case TxMetaType.ERC20_RECOVERY:
+      return CreateErc20RecoveryTx.fromPlain(transaction, tokenRegistry);
     case TxMetaType.ERC20_SPEEDUP:
       return CreateErc20SpeedUpTx.fromPlain(transaction, tokenRegistry);
     case TxMetaType.ERC20_TRANSFER:

packages/core/src/transaction/workflow/index.ts

@@ -7,6 +7,7 @@
   AnyErc20CreateTx,
   AnyEtherCreateTx,
   AnyEthereumCreateTx,
+  AnyEthereumRecoveryTx,
   ApproveTarget,
   BitcoinTx,
   BitcoinTxDetails,
@@ -17,9 +18,11 @@
   CreateErc20ApproveTx,
   CreateErc20CancelTx,
   CreateErc20ConvertTx,
+  CreateErc20RecoveryTx,
   CreateErc20SpeedUpTx,
   CreateErc20Tx,
   CreateEtherCancelTx,
+  CreateEtherRecoveryTx,
   CreateEtherSpeedUpTx,
   CreateEtherTx,
   Erc20ApproveTxDetails,
@@ -43,9 +46,11 @@
   isErc20CancelCreateTx,
   isErc20ConvertCreateTx,
   isErc20CreateTx,
+  isErc20RecoveryCreateTx,
   isErc20SpeedUpCreateTx,
   isEtherCancelCreateTx,
   isEtherCreateTx,
+  isEtherRecoveryCreateTx,
   isEtherSpeedUpCreateTx,
 } from './create-tx';
 

packages/core/src/transaction/workflow/types.ts

@@ -17,6 +17,7 @@ export enum TxMetaType {
   ERC20_APPROVE,
   ERC20_CANCEL,
   ERC20_CONVERT,
+  ERC20_RECOVERY,
   ERC20_SPEEDUP,
   ERC20_TRANSFER,
 }

packages/react-app/src/transaction/CreateTransaction.tsx

@@ -50,6 +50,10 @@
     case TxAction.CONVERT:
       title = 'Create Convert Transaction';
 
+      break;
+    case TxAction.RECOVERY:
+      title = 'Create Recovery Transaction';
+
       break;
     case TxAction.SPEEDUP:
       title = 'Speed Up Transaction';

packages/react-app/src/transaction/SetupTransaction/SetupTransaction.tsx

@@ -54,8 +54,14 @@
   getFiatBalance(asset: string): CurrencyAmount | undefined;
 }
 
+interface TxOrigin {
+  action: TxAction;
+  entries: WalletEntry[];
+  entry: WalletEntry;
+}
+
 interface DispatchProps {
-  prepareTransaction(action: TxAction, entry: WalletEntry): void;
+  prepareTransaction(origin: TxOrigin): void;
   setAsset(asset: string): void;
   setEntry(entry: WalletEntry, ownerAddress?: string): void;
   setStage(stage: CreateTxStage): void;
@@ -88,8 +94,8 @@
   const mounted = React.useRef(true);
 
   React.useEffect(() => {
-    prepareTransaction(action, entry);
-  }, [action, entry, storedTx, prepareTransaction]);
+    prepareTransaction({ action, entries, entry });
+  }, [action, entries, entry, storedTx, prepareTransaction]);
 
   React.useEffect(() => {
     return () => {
@@ -132,7 +138,7 @@
       walletId = EntryIdOp.of(entryId).extractWalletId();
     }
 
-    const entries = accounts.selectors.findWallet(state, walletId)?.entries.filter((entry) => !entry.receiveDisabled);
+    const { entries } = accounts.selectors.findWallet(state, walletId) ?? {};
 
     if (entries == null || entries.length === 0) {
       throw new Error('Something went wrong while getting entries from wallet');
@@ -250,8 +256,8 @@
   },
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   (dispatch: any, { initialAllowance, storedTx }) => ({
-    prepareTransaction(action, entry) {
-      dispatch(txStash.actions.prepareTransaction({ action, entry, initialAllowance, storedTx }));
+    prepareTransaction({ action, entries, entry }) {
+      dispatch(txStash.actions.prepareTransaction({ action, entries, entry, initialAllowance, storedTx }));
     },
     setAsset(asset) {
       dispatch(txStash.actions.setAsset(asset));