feat: new tx history - cache tx details

packages/arb-token-bridge-ui/src/components/TransactionHistory/TransactionsTableClaimableRow.tsx

@@ -16,11 +16,7 @@ import {
   isNetwork
 } from '../../util/networks'
 import { InformationCircleIcon } from '@heroicons/react/24/outline'
-import {
-  isCustomDestinationAddressTx,
-  findMatchingL1TxForWithdrawal,
-  isPending
-} from '../../state/app/utils'
+import { isCustomDestinationAddressTx, isPending } from '../../state/app/utils'
 import { TokenIcon, TransactionDateTime } from './TransactionHistoryTable'
 import { formatAmount } from '../../util/NumberUtils'
 import { sanitizeTokenSymbol } from '../../util/TokenUtils'
@@ -29,6 +25,7 @@ import { useRemainingTime } from '../../state/cctpState'
 import { useChainLayers } from '../../hooks/useChainLayers'
 import { getWagmiChain } from '../../util/wagmi/getWagmiChain'
 import { NetworkImage } from '../common/NetworkImage'
+import { getWithdrawalClaimParentChainTxDetails } from './helpers'
 
 type CommonProps = {
   tx: MergedTransaction
@@ -37,9 +34,9 @@ type CommonProps = {
 
 function ClaimableRowStatus({ tx }: CommonProps) {
   const { parentLayer, layer } = useChainLayers()
-  const matchingL1Tx = tx.isCctp
+  const matchingL1TxId = tx.isCctp
     ? tx.cctpData?.receiveMessageTransactionHash
-    : findMatchingL1TxForWithdrawal(tx)
+    : getWithdrawalClaimParentChainTxDetails(tx)?.txId
 
   switch (tx.status) {
     case 'pending':
@@ -96,7 +93,7 @@ function ClaimableRowStatus({ tx }: CommonProps) {
       )
 
     case 'Executed': {
-      if (typeof matchingL1Tx === 'undefined') {
+      if (typeof matchingL1TxId === 'undefined') {
         return (
           <div className="flex flex-col space-y-1">
             <StatusBadge
@@ -187,13 +184,11 @@ function ClaimableRowTime({ tx }: CommonProps) {
     )
   }
 
-  const claimedTx = tx.isCctp
-    ? {
-        createdAt: tx.cctpData?.receiveMessageTimestamp
-      }
-    : findMatchingL1TxForWithdrawal(tx)
+  const claimedTxTimestamp = tx.isCctp
+    ? tx.cctpData?.receiveMessageTimestamp
+    : getWithdrawalClaimParentChainTxDetails(tx)?.timestamp
 
-  if (typeof claimedTx === 'undefined') {
+  if (typeof claimedTxTimestamp === 'undefined') {
     return (
       <div className="flex flex-col space-y-3">
         <Tooltip content={<span>{layer} Transaction time</span>}>
@@ -213,10 +208,10 @@ function ClaimableRowTime({ tx }: CommonProps) {
       <Tooltip content={<span>{layer} Transaction Time</span>}>
         <TransactionDateTime standardizedDate={tx.createdAt} />
       </Tooltip>
-      {claimedTx?.createdAt && (
+      {claimedTxTimestamp && (
         <Tooltip content={<span>{parentLayer} Transaction Time</span>}>
           <span className="whitespace-nowrap">
-            <TransactionDateTime standardizedDate={claimedTx?.createdAt} />
+            <TransactionDateTime standardizedDate={claimedTxTimestamp} />
           </span>
         </Tooltip>
       )}
@@ -231,13 +226,11 @@ function ClaimedTxInfo({ tx, isSourceChainArbitrum }: CommonProps) {
   const isExecuted = tx.status === 'Executed'
   const isBeingClaimed = tx.status === 'Confirmed' && tx.resolvedAt
 
-  const claimedTx = tx.isCctp
-    ? {
-        txId: tx.cctpData?.receiveMessageTransactionHash
-      }
-    : findMatchingL1TxForWithdrawal(tx)
+  const claimedTxId = tx.isCctp
+    ? tx.cctpData?.receiveMessageTransactionHash
+    : getWithdrawalClaimParentChainTxDetails(tx)?.txId
 
-  if (!claimedTx?.txId) {
+  if (!claimedTxId) {
     return (
       <span className="flex flex-nowrap items-center gap-1 whitespace-nowrap text-dark">
         <span className="w-8 rounded-md pr-2 text-xs text-dark">To</span>
@@ -257,10 +250,10 @@ function ClaimedTxInfo({ tx, isSourceChainArbitrum }: CommonProps) {
       <NetworkImage chainId={toNetworkId} />
       {getNetworkName(toNetworkId)}:{' '}
       <ExternalLink
-        href={`${getExplorerUrl(toNetworkId)}/tx/${claimedTx.txId}`}
+        href={`${getExplorerUrl(toNetworkId)}/tx/${claimedTxId}`}
         className="arb-hover text-blue-link"
       >
-        {shortenTxHash(claimedTx.txId)}
+        {shortenTxHash(claimedTxId)}
       </ExternalLink>
     </span>
   )

packages/arb-token-bridge-ui/src/components/TransactionHistory/helpers.ts

@@ -15,14 +15,22 @@ import {
   WithdrawalStatus
 } from '../../state/app/state'
 import { ChainId, getBlockTime, isNetwork, rpcURLs } from '../../util/networks'
-import { isCctpTransfer } from '../../hooks/useTransactionHistory'
+import {
+  ChainPair,
+  Deposit,
+  isCctpTransfer
+} from '../../hooks/useTransactionHistory'
 import { getWagmiChain } from '../../util/wagmi/getWagmiChain'
 import { getL1ToL2MessageDataFromL1TxHash } from '../../util/deposits/helpers'
 import { AssetType } from '../../hooks/arbTokenBridge.types'
 import { getDepositStatus } from '../../state/app/utils'
 import { getBlockBeforeConfirmation } from '../../state/cctpState'
 import { getAttestationHashAndMessageFromReceipt } from '../../util/cctp/getAttestationHashAndMessageFromReceipt'
 
+const CLAIM_PARENT_CHAIN_DETAILS_LOCAL_STORAGE_KEY =
+  'arbitrum:bridge:claim:parent:tx:details'
+const DEPOSITS_LOCAL_STORAGE_KEY = 'arbitrum:bridge:deposits'
+
 export enum StatusLabel {
   PENDING = 'Pending',
   CLAIMABLE = 'Claimable',
@@ -111,6 +119,22 @@ export function isSameTransaction(
   )
 }
 
+export function subgraphExistsForChainPair(chainPair: ChainPair) {
+  if (
+    chainPair.parentChain === ChainId.Ethereum &&
+    chainPair.chain === ChainId.ArbitrumOne
+  ) {
+    return true
+  }
+  if (
+    chainPair.parentChain === ChainId.Goerli &&
+    chainPair.chain === ChainId.ArbitrumGoerli
+  ) {
+    return true
+  }
+  return false
+}
+
 export function getTxReceipt(tx: MergedTransaction) {
   const parentChainProvider = getProvider(tx.parentChainId)
   const childChainProvider = getProvider(tx.childChainId)
@@ -133,6 +157,100 @@ function getWithdrawalStatusFromReceipt(
   }
 }
 
+export function getDepositsWithoutStatusesFromCache(): Deposit[] {
+  return JSON.parse(
+    localStorage.getItem(DEPOSITS_LOCAL_STORAGE_KEY) ?? '[]'
+  ) as Deposit[]
+}
+
+/**
+ * Cache deposits from event logs. We don't fetch these so we need to store them locally.
+ *
+ * @param {MergedTransaction} tx - Deposit from event logs to be cached.
+ */
+export function addDepositToCache(tx: Deposit) {
+  if (tx.direction !== 'deposit' || tx.source !== 'event_logs') {
+    return
+  }
+
+  const cachedDeposits = getDepositsWithoutStatusesFromCache()
+
+  const foundInCache = cachedDeposits.find(cachedTx => {
+    return (
+      cachedTx.txID === tx.txID &&
+      cachedTx.parentChainId === tx.parentChainId &&
+      cachedTx.childChainId === tx.childChainId
+    )
+  })
+
+  if (foundInCache) {
+    return
+  }
+
+  const newCachedDeposits = [tx, ...cachedDeposits]
+
+  localStorage.setItem(
+    DEPOSITS_LOCAL_STORAGE_KEY,
+    JSON.stringify(newCachedDeposits)
+  )
+}
+
+/**
+ * Cache parent chain tx details when claiming. This is the chain the funds were claimed on. We store locally because we don't have access to this tx from the child chain tx data.
+ *
+ * @param {MergedTransaction} tx - Transaction that initiated the withdrawal (child chain transaction).
+ * @param {string} parentChainTxId - Transaction ID of the claim transaction (parent chain transaction ID).
+ */
+export function setWithdrawalClaimParentChainTxDetails(
+  tx: MergedTransaction,
+  parentChainTxId: string
+) {
+  const key = `${tx.parentChainId}-${tx.childChainId}-${tx.txId}`
+
+  const cachedClaimParentChainTxId = JSON.parse(
+    localStorage.getItem(CLAIM_PARENT_CHAIN_DETAILS_LOCAL_STORAGE_KEY) ?? '{}'
+  )
+
+  if (key in cachedClaimParentChainTxId) {
+    // already set
+    return
+  }
+
+  localStorage.setItem(
+    CLAIM_PARENT_CHAIN_DETAILS_LOCAL_STORAGE_KEY,
+    JSON.stringify({
+      ...cachedClaimParentChainTxId,
+      [key]: {
+        txId: parentChainTxId,
+        timestamp: dayjs().valueOf()
+      }
+    })
+  )
+}
+
+export function getWithdrawalClaimParentChainTxDetails(
+  tx: MergedTransaction
+): { txId: string; timestamp: number } | undefined {
+  if (!tx.isWithdrawal || tx.isCctp) {
+    return undefined
+  }
+
+  const key = `${tx.parentChainId}-${tx.childChainId}-${tx.txId}`
+
+  const cachedClaimParentChainTxDetails = (
+    JSON.parse(
+      localStorage.getItem(CLAIM_PARENT_CHAIN_DETAILS_LOCAL_STORAGE_KEY) ?? '{}'
+    ) as {
+      [key in string]: {
+        txId: string
+        timestamp: number
+      }
+    }
+  )[key]
+
+  return cachedClaimParentChainTxDetails
+}
+
 export async function getUpdatedEthDeposit(
   tx: MergedTransaction
 ): Promise<MergedTransaction> {

packages/arb-token-bridge-ui/src/hooks/useArbTokenBridge.ts

@@ -46,6 +46,10 @@ import { useUpdateUSDCBalances } from './CCTP/useUpdateUSDCBalances'
 import { useNativeCurrency } from './useNativeCurrency'
 import { useTransactionHistory } from './useTransactionHistory'
 import { DepositStatus, WithdrawalStatus } from '../state/app/state'
+import {
+  addDepositToCache,
+  subgraphExistsForChainPair
+} from '../components/TransactionHistory/helpers'
 
 export const wait = (ms = 0) => {
   return new Promise(res => setTimeout(res, ms))
@@ -227,6 +231,30 @@ export const useArbTokenBridge = (
       childChainId: Number(l2NetworkID)
     })
 
+    addDepositToCache({
+      sender: walletAddress,
+      destination: walletAddress,
+      status: 'pending',
+      txID: tx.hash,
+      assetName: nativeCurrency.symbol,
+      assetType: AssetType.ETH,
+      l1NetworkID,
+      l2NetworkID,
+      value: utils.formatUnits(amount, nativeCurrency.decimals),
+      parentChainId: Number(l1NetworkID),
+      childChainId: Number(l2NetworkID),
+      direction: 'deposit',
+      type: 'deposit-l1',
+      source: subgraphExistsForChainPair({
+        parentChain: Number(l1NetworkID),
+        chain: Number(l2NetworkID)
+      })
+        ? 'subgraph'
+        : 'event_logs',
+      timestampCreated: String(dayjs().valueOf() / 1_000),
+      nonce: tx.nonce
+    })
+
     const receipt = await tx.wait()
 
     if (txLifecycle?.onTxConfirm) {
@@ -443,6 +471,30 @@ export const useArbTokenBridge = (
         childChainId: Number(l2NetworkID)
       })
 
+      addDepositToCache({
+        sender: walletAddress,
+        destination: walletAddress,
+        status: 'pending',
+        txID: tx.hash,
+        assetName: symbol,
+        assetType: AssetType.ERC20,
+        l1NetworkID,
+        l2NetworkID,
+        value: utils.formatUnits(amount, nativeCurrency.decimals),
+        parentChainId: Number(l1NetworkID),
+        childChainId: Number(l2NetworkID),
+        direction: 'deposit',
+        type: 'deposit-l1',
+        source: subgraphExistsForChainPair({
+          parentChain: Number(l1NetworkID),
+          chain: Number(l2NetworkID)
+        })
+          ? 'subgraph'
+          : 'event_logs',
+        timestampCreated: String(dayjs().valueOf() / 1_000),
+        nonce: tx.nonce
+      })
+
       const receipt = await tx.wait()
 
       if (txLifecycle?.onTxConfirm) {

packages/arb-token-bridge-ui/src/hooks/useClaimWithdrawal.ts

@@ -7,7 +7,10 @@ import { MergedTransaction, WithdrawalStatus } from '../state/app/state'
 import { isUserRejectedError } from '../util/isUserRejectedError'
 import { errorToast } from '../components/common/atoms/Toast'
 import { AssetType, L2ToL1EventResultPlus } from './arbTokenBridge.types'
-import { getProvider } from '../components/TransactionHistory/helpers'
+import {
+  getProvider,
+  setWithdrawalClaimParentChainTxDetails
+} from '../components/TransactionHistory/helpers'
 import { L2TransactionReceipt } from '@arbitrum/sdk'
 import { ContractReceipt, utils } from 'ethers'
 import { useTransactionHistory } from './useTransactionHistory'
@@ -109,12 +112,17 @@ export function useClaimWithdrawal(): UseClaimWithdrawalResult {
     }
 
     const isSuccess = (res as ContractReceipt).status === 1
+    const txHash = (res as ContractReceipt).transactionHash
 
     updatePendingTransaction({
       ...tx,
       status: isSuccess ? WithdrawalStatus.EXECUTED : WithdrawalStatus.FAILURE,
       resolvedAt: isSuccess ? dayjs().valueOf() : null
     })
+
+    if (isSuccess) {
+      setWithdrawalClaimParentChainTxDetails(tx, txHash)
+    }
   }
 
   return { claim, isClaiming }