Transaction replacement - Allow speeding up transactions

.env.defaults

@@ -31,4 +31,5 @@ SUPPORT_SWAP_QUOTE_REFRESH=false
 SUPPORT_ACHIEVEMENTS_BANNER=false
 SUPPORT_NFT_SEND=false
 USE_MAINNET_FORK=false
+SUPPORT_TRANSACTION_REPLACEMENT=false
 ENABLE_UPDATED_DAPP_CONNECTIONS=true

background/features.ts

@@ -23,6 +23,8 @@ export const RuntimeFlag = {
   SUPPORT_SWAP_QUOTE_REFRESH: process.env.SUPPORT_SWAP_QUOTE_REFRESH === "true",
   SUPPORT_CUSTOM_NETWORKS: process.env.SUPPORT_CUSTOM_NETWORKS === "true",
   SUPPORT_CUSTOM_RPCS: process.env.SUPPORT_CUSTOM_RPCS === "true",
+  SUPPORT_TRANSACTION_REPLACEMENT:
+    process.env.SUPPORT_TRANSACTION_REPLACEMENT === "true",
   ENABLE_UPDATED_DAPP_CONNECTIONS:
     process.env.ENABLE_UPDATED_DAPP_CONNECTIONS === "true",
 } as const

background/lib/gas.ts

@@ -1,4 +1,4 @@
-import { Provider } from "@ethersproject/abstract-provider"
+import { Block, Provider } from "@ethersproject/abstract-provider"
 import { fetchJson } from "@ethersproject/web"
 
 import logger from "./logger"
@@ -148,7 +148,8 @@ const getLegacyGasPrices = async (
 
 export default async function getBlockPrices(
   network: EVMNetwork,
-  provider: Provider
+  provider: Provider,
+  block?: Block
 ): Promise<BlockPrices> {
   // if BlockNative is configured and we're on mainnet, prefer their gas service
   if (
@@ -169,7 +170,7 @@ export default async function getBlockPrices(
   }
 
   const [currentBlock, feeData] = await Promise.all([
-    provider.getBlock("latest"),
+    block ? Promise.resolve(block) : provider.getBlock("latest"),
     provider.getFeeData(),
   ])
 

background/main.ts

@@ -37,9 +37,8 @@ import {
   AnalyticsService,
   getNoopService,
 } from "./services"
-
 import { HexString, NormalizedEVMAddress } from "./types"
-import { SignedTransaction } from "./networks"
+import { EVMNetwork, EVMTransaction, SignedTransaction } from "./networks"
 import { AccountBalance, AddressOnNetwork, NameOnNetwork } from "./accounts"
 import { Eligible } from "./services/doggo/types"
 
@@ -1705,7 +1704,7 @@ export default class Main extends BaseService<never> {
     return this.internalSignerService.importSigner(signerRaw)
   }
 
-  async getActivityDetails(txHash: string): Promise<ActivityDetail[]> {
+  async getActivityDetails(txHash: string): Promise<[ActivityDetail]> {
     const addressNetwork = this.store.getState().ui.selectedAccount
     const transaction = await this.chainService.getTransaction(
       addressNetwork.network,
@@ -1716,7 +1715,7 @@ export default class Main extends BaseService<never> {
       2
     )
 
-    return getActivityDetails(enrichedTransaction)
+    return [getActivityDetails(enrichedTransaction)]
   }
 
   async connectAnalyticsService(): Promise<void> {
@@ -1962,6 +1961,22 @@ export default class Main extends BaseService<never> {
     return this.indexingService.importCustomToken(asset)
   }
 
+  async trackReplacementTransaction(
+    hash: string,
+    parentTx: string,
+    addressOnNetwork: AddressOnNetwork
+  ): Promise<void> {
+    this.chainService.trackReplacementTransaction(
+      hash,
+      addressOnNetwork,
+      parentTx
+    )
+  }
+
+  async getTxData(network: EVMNetwork, hash: string): Promise<EVMTransaction> {
+    return this.chainService.getTransaction(network, hash)
+  }
+
   private connectPopupMonitor() {
     runtime.onConnect.addListener((port) => {
       if (port.name !== popupMonitorPortName) return

background/networks.ts

@@ -10,6 +10,14 @@ import type {
   PartialTransactionRequestWithFrom,
 } from "./services/enrichment"
 
+/**
+ * Transaction status, uses the same convention as the result from eth_gettransactionreceipt
+ */
+export enum TxStatus {
+  FAIL = 0,
+  SUCCESS = 1,
+}
+
 /**
  * Each supported network family is generally incompatible with others from a
  * transaction, consensus, and/or wire format perspective.
@@ -244,7 +252,7 @@ export type EVMLog = {
  */
 export type ConfirmedEVMTransaction = EVMTransaction & {
   gasUsed: bigint
-  status: number
+  status: TxStatus
   blockHash: string
   blockHeight: number
   logs: EVMLog[] | undefined
@@ -255,7 +263,7 @@ export type ConfirmedEVMTransaction = EVMTransaction & {
  * the error if available.
  */
 export type FailedConfirmationEVMTransaction = EVMTransaction & {
-  status: 0
+  status: TxStatus.FAIL
   error?: string
   blockHash: null
   blockHeight: null

background/redux-slices/activities.ts

@@ -9,6 +9,7 @@ import {
   normalizeEVMAddress,
   sameEVMAddress,
 } from "../lib/utils"
+import { EVMTransaction, isEIP1559TransactionRequest } from "../networks"
 import { Transaction } from "../services/chain/db"
 import { EnrichedEVMTransaction } from "../services/enrichment"
 import { HexString } from "../types"
@@ -20,6 +21,7 @@ import {
   ActivityDetail,
   INFINITE_VALUE,
 } from "./utils/activities-utils"
+import { getProvider } from "./utils/contract-utils"
 
 export { Activity, ActivityDetail, INFINITE_VALUE }
 export type Activities = {
@@ -28,8 +30,20 @@ export type Activities = {
   }
 }
 
+const lowerCaseCmp = (a: string, b: string) =>
+  a.toLowerCase() === b.toLowerCase()
+
+type TrackedReplacementTx = {
+  chainID: string
+  hash: string
+  parentTx: string
+  initiator: string
+}
+
 type ActivitiesState = {
   activities: Activities
+  replacementTransactions: TrackedReplacementTx[]
+  transactionToReplace?: EVMTransaction
 }
 
 const ACTIVITIES_MAX_COUNT = 25
@@ -113,6 +127,7 @@ const initializeActivitiesFromTransactions = ({
 
 const initialState: ActivitiesState = {
   activities: {},
+  replacementTransactions: [],
 }
 
 const activitiesSlice = createSlice({
@@ -126,9 +141,11 @@ const activitiesSlice = createSlice({
       }: {
         payload: { transactions: Transaction[]; accounts: AddressOnNetwork[] }
       }
-    ) => ({
-      activities: initializeActivitiesFromTransactions(payload),
-    }),
+    ) => {
+      immerState.activities = initializeActivitiesFromTransactions(payload)
+      // Clear these at extension restart
+      immerState.replacementTransactions = []
+    },
     initializeActivitiesForAccount: (
       immerState,
       {
@@ -170,6 +187,67 @@ const activitiesSlice = createSlice({
           immerState.activities[normalizeEVMAddress(address)]?.[chainID]
         )
       })
+
+      const { replacementTransactions } = immerState
+
+      // Check if we're already tracking the replacement tx so we can get the
+      // "replaced" tx and remove it if the replacement has been mined
+      const replacementRef = replacementTransactions.find(
+        (ref) =>
+          (lowerCaseCmp(ref.hash, transaction.hash) ||
+            lowerCaseCmp(ref.parentTx, transaction.hash)) &&
+          ref.chainID === transaction.network.chainID
+      )
+
+      if (replacementRef) {
+        const accountActivities =
+          immerState.activities[normalizeEVMAddress(transaction.from)][
+            replacementRef.chainID
+          ]
+
+        const replacementTx = accountActivities.find((tx) =>
+          lowerCaseCmp(tx.hash, replacementRef.hash)
+        )
+
+        if (
+          replacementTx &&
+          // this new activity is the replacement tx
+          ((lowerCaseCmp(replacementRef.hash, transaction.hash) &&
+            // tx has been mined
+            transaction.blockHash) ||
+            // if this new activity is the replaced tx
+            (lowerCaseCmp(replacementRef.parentTx, transaction.hash) &&
+              // replacement has been mined
+              replacementTx.blockHash))
+        ) {
+          // drop replaced tx
+          immerState.activities[normalizeEVMAddress(transaction.from)][
+            replacementRef.chainID
+          ] = accountActivities.filter(
+            ({ hash }) => !lowerCaseCmp(hash, replacementRef.parentTx)
+          )
+        }
+      }
+    },
+    addReplacementTransaction: (
+      immerState,
+      { payload }: { payload: TrackedReplacementTx }
+    ) => {
+      const { replacementTransactions } = immerState
+      if (
+        !replacementTransactions.some(
+          (request) =>
+            request.hash === payload.hash && request.chainID === payload.chainID
+        )
+      ) {
+        replacementTransactions.push(payload)
+      }
+    },
+    setTransactionToReplace(
+      immerState,
+      { payload }: { payload: EVMTransaction | undefined }
+    ) {
+      immerState.transactionToReplace = payload
     },
   },
 })
@@ -179,6 +257,8 @@ export const {
   addActivity,
   removeActivities,
   initializeActivitiesForAccount,
+  addReplacementTransaction,
+  setTransactionToReplace,
 } = activitiesSlice.actions
 
 export default activitiesSlice.reducer
@@ -189,3 +269,77 @@ export const fetchSelectedActivityDetails = createBackgroundAsyncThunk(
     return main.getActivityDetails(activityHash)
   }
 )
+
+export const speedUpTx = createBackgroundAsyncThunk(
+  "activities/speedupTx",
+  async (
+    tx: Transaction | EnrichedEVMTransaction,
+    { dispatch, extra: { main } }
+  ) => {
+    const {
+      hash: parentTxHash,
+      network,
+      input,
+      from,
+      type,
+      to,
+      value,
+      nonce,
+      gasLimit,
+    } = tx
+
+    const provider = getProvider()
+    const signer = provider.getSigner()
+    const isEIP1559Tx = isEIP1559TransactionRequest(tx)
+
+    if ((isEIP1559Tx && !tx.maxFeePerGas) || (!isEIP1559Tx && !tx.gasPrice)) {
+      throw new Error("Cannot speed up transaction without a valid gas price")
+    }
+
+    const txRequest = {
+      data: input || "0x",
+      from,
+      to,
+      value,
+      gasLimit,
+      nonce,
+      // if type is null, don't pass it
+      ...(type === null ? {} : { type }),
+    }
+
+    if (isEIP1559Tx) {
+      Object.assign(txRequest, {
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: (tx.maxPriorityFeePerGas * 120n) / 100n,
+      })
+    } else {
+      Object.assign(txRequest, {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        gasPrice: (tx.gasPrice! * 120n) / 100n,
+      })
+    }
+
+    dispatch(
+      setTransactionToReplace(await main.getTxData(network, parentTxHash))
+    )
+
+    const newTxHash = await signer.sendTransaction(txRequest).finally(() => {
+      // reset state whether the process fails or not
+      dispatch(setTransactionToReplace(undefined))
+    })
+
+    await main.trackReplacementTransaction(newTxHash.hash, parentTxHash, {
+      address: from,
+      network,
+    })
+
+    dispatch(
+      addReplacementTransaction({
+        hash: newTxHash.hash,
+        chainID: network.chainID,
+        parentTx: newTxHash.hash,
+        initiator: from,
+      })
+    )
+  }
+)

background/redux-slices/selectors/activitiesSelectors.ts

@@ -19,3 +19,13 @@ export const selectActivitesHashesForEnrichment = createSelector(
     )
   }
 )
+
+export const selectTrackedReplacementTransactions = createSelector(
+  (state: RootState) => state.activities,
+  (activities) => activities.replacementTransactions
+)
+
+export const selectTransactionToReplace = createSelector(
+  (state: RootState) => state.activities,
+  (activities) => activities.transactionToReplace
+)