race cond. fix

Author: TateB

src/hooks/transactions/transactionStore.test.ts

@@ -56,10 +56,8 @@ describe('transactionStore', () => {
       setTimeout(() => {
         onReplaced!({
           reason: 'repriced',
-          transaction: {
-            hash: newHash,
-          },
-        } as any)
+          transactionHash: newHash,
+        })
       }, 0)
 
       return {

src/hooks/transactions/transactionStore.ts

@@ -399,21 +399,15 @@ export function createTransactionStore(config_: ConfigWithEns) {
           const requestPromise = waitForTransaction(config, {
             confirmations: 1,
             hash: hash as `0x${string}`,
-            onReplaced: (replacedTransaction) => {
-              if (replacedTransaction.reason === 'repriced') {
-                setTransactionStatus(
-                  account,
-                  chainId,
-                  hash,
-                  'repriced',
-                  replacedTransaction.transaction.hash,
-                )
+            onReplaced: (response) => {
+              if (response.reason === 'repriced') {
+                setTransactionStatus(account, chainId, hash, 'repriced', response.transactionHash)
                 addTransaction(account, chainId, {
                   ...transaction,
                   isSafeTx: false,
-                  hash: replacedTransaction.transaction.hash,
+                  hash: response.transactionHash,
                 })
-                transactionRequestCache.set(replacedTransaction.transaction.hash, requestPromise)
+                transactionRequestCache.set(response.transactionHash, requestPromise)
                 transactionRequestCache.delete(hash)
               }
             },

src/hooks/transactions/waitForTransaction.test.ts

@@ -1,9 +1,7 @@
-import { type PartialMockedFunction } from '@app/test-utils'
-
-import { PartiallyMockedFunction } from '@vitest/spy'
-import { WaitForTransactionReceiptReturnType } from 'viem'
+import { type MockedFunctionDeep } from '@vitest/spy'
+import { WaitForTransactionReceiptReturnType, type Transaction } from 'viem'
 import { waitForTransactionReceipt } from 'viem/actions'
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { ClientWithEns, ConfigWithEns } from '@app/types'
 import { fetchTxFromSafeTxHash } from '@app/utils/safe'
@@ -14,11 +12,10 @@ vi.mock('viem/actions')
 
 vi.mock('@app/utils/safe')
 
-const mockWaitForTransactionReceipt = waitForTransactionReceipt as unknown as PartialMockedFunction<
+const mockWaitForTransactionReceipt = waitForTransactionReceipt as MockedFunctionDeep<
   typeof waitForTransactionReceipt
 >
-
-const mockFetchTxFromSafeTxHash = fetchTxFromSafeTxHash as unknown as PartiallyMockedFunction<
+const mockFetchTxFromSafeTxHash = fetchTxFromSafeTxHash as MockedFunctionDeep<
   typeof fetchTxFromSafeTxHash
 >
 
@@ -50,6 +47,10 @@ const mockTransactionReceiptData: WaitForTransactionReceiptReturnType = {
   type: 'legacy',
 }
 
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
 describe('waitForTransaction', () => {
   it('should wait for standard transaction', async () => {
     // @ts-ignore vi.fn is messing with types
@@ -62,7 +63,6 @@ describe('waitForTransaction', () => {
     expect(result).toStrictEqual(mockTransactionReceiptData)
   })
   it('should pass onReplaced tx to waitForTransactionReceipt', async () => {
-    // @ts-ignore vi.fn is messing with types
     mockWaitForTransactionReceipt.mockResolvedValueOnce(mockTransactionReceiptData)
 
     const onReplaced = vi.fn()
@@ -72,12 +72,22 @@ describe('waitForTransaction', () => {
       onReplaced,
     })
 
-    expect(mockWaitForTransactionReceipt).toHaveBeenCalledWith(
-      mockClient,
-      expect.objectContaining({
-        onReplaced,
-      }),
-    )
+    expect(mockWaitForTransactionReceipt).toHaveBeenCalled()
+
+    const onReplacedInternalFn = mockWaitForTransactionReceipt.mock.calls[0][1].onReplaced
+    onReplacedInternalFn!({
+      reason: 'replaced',
+      transaction: {
+        hash: '0xnewhash',
+      } as unknown as Transaction,
+      replacedTransaction: {} as unknown as Transaction,
+      transactionReceipt: {} as unknown as WaitForTransactionReceiptReturnType,
+    })
+
+    expect(onReplaced).toHaveBeenCalledWith({
+      reason: 'replaced',
+      transactionHash: '0xnewhash',
+    })
   })
 })
 

src/hooks/transactions/waitForTransaction.ts

@@ -4,7 +4,7 @@ import type {
   EIP1193RequestFn,
   Hash,
   PublicRpcSchema,
-  WaitForTransactionReceiptParameters,
+  ReplacementReason,
   WaitForTransactionReceiptReturnType,
 } from 'viem'
 import { hexToString } from 'viem'
@@ -24,7 +24,7 @@ export type WaitForTransactionArgs = {
   /** Transaction hash to monitor */
   hash: Hash
   /** Callback to invoke when the transaction has been replaced (sped up). */
-  onReplaced?: WaitForTransactionReceiptParameters['onReplaced']
+  onReplaced?: (response: { reason: ReplacementReason; transactionHash: Hash }) => void
   /*
    * Maximum amount of time to wait before timing out in milliseconds
    * @default 0
@@ -81,7 +81,8 @@ export async function waitForTransaction(
   const receipt = await waitForTransactionReceipt(client, {
     hash,
     confirmations,
-    onReplaced,
+    onReplaced: ({ reason, transaction }) =>
+      onReplaced?.({ reason, transactionHash: transaction.hash }),
     timeout,
   })
   if (receipt.status === 'reverted') {
@@ -96,6 +97,11 @@ export async function waitForTransaction(
     } as CallParameters)) as unknown as string
     const reason = hexToString(`0x${code.substring(138)}`)
     throw new Error(reason)
+  } else if (isSafeTx) {
+    onReplaced?.({
+      reason: 'repriced',
+      transactionHash: receipt.transactionHash,
+    })
   }
   return receipt
 }