From a8d6ddb9c6d957db96c28b0c12475328e8b198dc Mon Sep 17 00:00:00 2001
From: Jorge Luis <28708889+hyphenized@users.noreply.github.com>
Date: Mon, 17 Feb 2025 14:08:21 -0500
Subject: [PATCH] Reuse existing activity state data

This adds a check into the account activity initialization process
so we re-use already-enriched activity data if it corresponds to a
finalized transaction.

Improves worker startup and prevents requests bursts by optimizing
activity initialization for tracked accounts.
---
 background/redux-slices/activities.ts | 103 +++++++++++++-------------
 background/services/redux/index.ts    |   1 +
 2 files changed, 51 insertions(+), 53 deletions(-)

diff --git a/background/redux-slices/activities.ts b/background/redux-slices/activities.ts
index fbc0894f70..920415472a 100644
--- a/background/redux-slices/activities.ts
+++ b/background/redux-slices/activities.ts
@@ -63,55 +63,6 @@ const addActivityToState =
     }
   }
 
-const initializeActivitiesFromTransactions = ({
-  transactions,
-  accounts,
-}: {
-  transactions: Transaction[]
-  accounts: AddressOnNetwork[]
-}): Activities => {
-  const activities: {
-    [address: string]: {
-      [chainID: string]: Activity[]
-    }
-  } = {}
-
-  const addActivity = addActivityToState(activities)
-
-  const normalizedAccounts = accounts.map((account) =>
-    normalizeAddressOnNetwork(account),
-  )
-
-  // Add transactions
-  transactions.forEach((transaction) => {
-    const { to, from, network } = transaction
-    const isTrackedTo = normalizedAccounts.some(
-      ({ address, network: activeNetwork }) =>
-        network.chainID === activeNetwork.chainID &&
-        sameEVMAddress(to, address),
-    )
-    const isTrackedFrom = normalizedAccounts.some(
-      ({ address, network: activeNetwork }) =>
-        network.chainID === activeNetwork.chainID &&
-        sameEVMAddress(from, address),
-    )
-
-    if (to && isTrackedTo) {
-      addActivity(to, network.chainID, transaction)
-    }
-    if (from && isTrackedFrom) {
-      addActivity(from, network.chainID, transaction)
-    }
-  })
-
-  // Sort and reduce # of transactions
-  normalizedAccounts.forEach(({ address, network }) =>
-    cleanActivitiesArray(activities[address]?.[network.chainID]),
-  )
-
-  return activities
-}
-
 const initialState: ActivitiesState = {
   activities: {},
 }
@@ -123,13 +74,59 @@ const activitiesSlice = createSlice({
     initializeActivities: (
       immerState,
       {
-        payload,
+        payload: { transactions, accounts },
       }: {
         payload: { transactions: Transaction[]; accounts: AddressOnNetwork[] }
       },
-    ) => ({
-      activities: initializeActivitiesFromTransactions(payload),
-    }),
+    ) => {
+      const activities: {
+        [address: string]: {
+          [chainID: string]: Activity[]
+        }
+      } = {}
+
+      const { activities: existingActivities } = immerState
+
+      const addActivity = addActivityToState(activities)
+
+      const normalizedAccounts = accounts.map((account) =>
+        normalizeAddressOnNetwork(account),
+      )
+
+      // Add transactions
+      transactions.forEach((transaction) => {
+        const { to, from, network } = transaction
+
+        const trackedAccounts = normalizedAccounts.filter(
+          ({ address, network: activeNetwork }) =>
+            network.chainID === activeNetwork.chainID &&
+            (sameEVMAddress(to, address) || sameEVMAddress(from, address)),
+        )
+
+        trackedAccounts.forEach(({ address, network: { chainID } }) => {
+          const accountData = existingActivities?.[address]?.[chainID] ?? []
+          const activityExists = accountData.find(
+            ({ hash }) => hash === transaction.hash,
+          )
+
+          // if activity transaction has finalized, reuse existing data
+          if (activityExists && activityExists.blockHeight) {
+            activities[address] ??= {}
+            activities[address][chainID] ??= []
+            activities[address][chainID].push(activityExists)
+          } else {
+            addActivity(address, chainID, transaction)
+          }
+        })
+      })
+
+      // Sort and reduce # of transactions
+      normalizedAccounts.forEach(({ address, network }) =>
+        cleanActivitiesArray(activities[address]?.[network.chainID]),
+      )
+
+      immerState.activities = activities
+    },
     initializeActivitiesForAccount: (
       immerState,
       {
diff --git a/background/services/redux/index.ts b/background/services/redux/index.ts
index 10b8f14d57..c3a57e2a15 100644
--- a/background/services/redux/index.ts
+++ b/background/services/redux/index.ts
@@ -589,6 +589,7 @@ export default class ReduxService extends BaseService<never> {
 
   async enrichActivities(addressNetwork: AddressOnNetwork): Promise<void> {
     const accountsToTrack = await this.chainService.getAccountsToTrack()
+
     const activitiesToEnrich = selectActivitesHashesForEnrichment(
       this.store.getState(),
     )