feat: targeted features

apps/mobile/src/tests/mocks.ts

@@ -159,7 +159,6 @@ export const mockSwapTransfer: SwapTransferTransactionInfo = {
   sellToken: fakeToken2,
   buyToken: fakeToken,
   explorerUrl: 'http://google.com',
-  executedSurplusFee: '',
   receiver: '0xbob',
   owner: '0xalice',
 }

apps/web/src/features/swap/helpers/swapOrderBuilder.ts

@@ -64,7 +64,6 @@ export function swapOrderBuilder(): IBuilder<SwapOrder> {
     buyToken: orderTokenBuilder().build(),
     explorerUrl:
       'https://explorer.cow.fi/orders/0x03a5d561ad2452d719a0d075573f4bed68217c696b52f151122c30e3e4426f1b05e6b5eb1d0e6aabab082057d5bb91f2ee6d11be66223d88',
-    executedSurplusFee: executedFee,
     executedFee,
     executedFeeToken: sellToken,
     fullAppData: appDataBuilder().build(),
@@ -86,7 +85,6 @@ export function twapOrderBuilder(): IBuilder<TwapOrder> {
     executedBuyAmount: faker.string.numeric(),
     sellToken: orderTokenBuilder().build(),
     buyToken: orderTokenBuilder().build(),
-    executedSurplusFee: executedFee,
     executedFee,
     executedFeeToken: sellToken,
     fullAppData: appDataBuilder().build(),

apps/web/src/features/targetedOutreach/constants.ts

@@ -1,5 +1,12 @@
+import { FEATURES } from '@/utils/chains'
+
 export const ACTIVE_OUTREACH = { id: 2, url: 'https://wn2n6ocviur.typeform.com/to/nlQlP7lU', targetAll: true }
 
+export const TARGETED_FEATURES = [
+  { id: 3, feature: FEATURES.NESTED_SAFES },
+  { id: 4, feature: FEATURES.MASS_PAYOUTS },
+] as const
+
 export const OUTREACH_LS_KEY = 'outreachPopup'
 export const OUTREACH_SS_KEY = 'outreachPopup_session'
 

apps/web/src/features/targetedOutreach/hooks/__tests__/useIsTargetedSafe.test.ts

@@ -0,0 +1,209 @@
+import { faker } from '@faker-js/faker'
+import * as targetedMessages from '@safe-global/store/gateway/AUTO_GENERATED/targeted-messages'
+
+import * as useChainsHook from '@/hooks/useChains'
+import * as useSafeInfoHook from '@/hooks/useSafeInfo'
+import * as useLocalStorageHook from '@/services/local-storage/useLocalStorage'
+import { safeInfoBuilder } from '@/tests/builders/safe'
+import { renderHook, waitFor } from '@/tests/test-utils'
+import * as useIsTargetedSafeHook from '../useIsTargetedSafe'
+import { useIsTargetedFeature, useIsTargetedSafe } from '../useIsTargetedSafe'
+import { TARGETED_FEATURES } from '../../constants'
+
+const targetedFeatureOutreachIds = TARGETED_FEATURES.map((f) => f.id)
+const targetedFeatures = TARGETED_FEATURES.map((f) => f.feature)
+
+describe('Targeted Safe', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('useIsTargetedSafe', () => {
+    it('returns true if the Safe is targeted', () => {
+      const safeInfo = safeInfoBuilder().build()
+      const outreachId = faker.helpers.arrayElement(targetedFeatureOutreachIds)
+      jest.spyOn(useSafeInfoHook, 'default').mockReturnValue({
+        safeAddress: safeInfo.address.value,
+        safe: {
+          ...safeInfo,
+          deployed: true,
+        },
+        safeLoaded: true,
+        safeLoading: false,
+        safeError: undefined,
+      })
+      jest.spyOn(targetedMessages, 'useTargetedMessagingGetTargetedSafeV1Query').mockReturnValue({
+        data: {
+          outreachId,
+          address: safeInfo.address.value,
+        },
+        refetch: jest.fn(),
+      })
+
+      const { result } = renderHook(() => useIsTargetedSafe(outreachId))
+
+      expect(result.current).toBe(true)
+    })
+
+    it('returns false if the Safe is not targeted', () => {
+      const safeInfo = safeInfoBuilder().build()
+      const outreachId = faker.helpers.arrayElement(targetedFeatureOutreachIds)
+      jest.spyOn(useSafeInfoHook, 'default').mockReturnValue({
+        safeAddress: safeInfo.address.value,
+        safe: {
+          ...safeInfo,
+          deployed: true,
+        },
+        safeLoaded: true,
+        safeLoading: false,
+        safeError: undefined,
+      })
+      jest.spyOn(targetedMessages, 'useTargetedMessagingGetTargetedSafeV1Query').mockReturnValue({
+        data: undefined,
+        error: new Error('Safe not targeted'),
+        refetch: jest.fn(),
+      })
+
+      const { result } = renderHook(() => useIsTargetedSafe(outreachId))
+
+      expect(result.current).toBe(false)
+    })
+
+    it('returns false if the data is not available', () => {
+      const safeInfo = safeInfoBuilder().build()
+      const outreachId = faker.helpers.arrayElement(targetedFeatureOutreachIds)
+      jest.spyOn(useSafeInfoHook, 'default').mockReturnValue({
+        safeAddress: safeInfo.address.value,
+        safe: {
+          ...safeInfo,
+          deployed: true,
+        },
+        safeLoaded: true,
+        safeLoading: false,
+        safeError: undefined,
+      })
+      jest.spyOn(targetedMessages, 'useTargetedMessagingGetTargetedSafeV1Query').mockReturnValue({
+        data: undefined, // Yet to be fetched
+        refetch: jest.fn(),
+      })
+
+      const { result } = renderHook(() => useIsTargetedSafe(outreachId))
+
+      expect(result.current).toBe(false)
+    })
+
+    it('returns false if the outreachId does not match', () => {
+      const safeInfo = safeInfoBuilder().build()
+      const outreachId = faker.helpers.arrayElement(targetedFeatureOutreachIds)
+      const otherOutreachId = 'OTHER_FEATURE'
+      jest.spyOn(useSafeInfoHook, 'default').mockReturnValue({
+        safeAddress: safeInfo.address.value,
+        safe: {
+          ...safeInfo,
+          deployed: true,
+        },
+        safeLoaded: true,
+        safeLoading: false,
+        safeError: undefined,
+      })
+      jest.spyOn(targetedMessages, 'useTargetedMessagingGetTargetedSafeV1Query').mockReturnValue({
+        data: {
+          outreachId: otherOutreachId,
+          address: safeInfo.address.value,
+        },
+        refetch: jest.fn(),
+      })
+
+      const { result } = renderHook(() => useIsTargetedSafe(outreachId))
+
+      expect(result.current).toBe(false)
+    })
+
+    it('returns false if the address does not match', () => {
+      const safeInfo = safeInfoBuilder().build()
+      const otherAddress = faker.finance.ethereumAddress()
+      const outreachId = faker.helpers.arrayElement(targetedFeatureOutreachIds)
+      jest.spyOn(useSafeInfoHook, 'default').mockReturnValue({
+        safeAddress: safeInfo.address.value,
+        safe: {
+          ...safeInfo,
+          deployed: true,
+        },
+        safeLoaded: true,
+        safeLoading: false,
+        safeError: undefined,
+      })
+      jest.spyOn(targetedMessages, 'useTargetedMessagingGetTargetedSafeV1Query').mockReturnValue({
+        data: {
+          outreachId,
+          address: otherAddress,
+        },
+        refetch: jest.fn(),
+      })
+
+      const { result } = renderHook(() => useIsTargetedSafe(outreachId))
+
+      expect(result.current).toBe(false)
+    })
+  })
+
+  describe('useIsTargetedFeature', () => {
+    it('returns true if the Safe is targeted and the feature is enabled', () => {
+      const feature = faker.helpers.arrayElement(targetedFeatures)
+      jest.spyOn(useChainsHook, 'useHasFeature').mockReturnValue(true)
+      jest.spyOn(useIsTargetedSafeHook, 'useIsTargetedSafe').mockReturnValue(true)
+      jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[feature], jest.fn()])
+
+      const { result } = renderHook(() => useIsTargetedFeature(feature))
+
+      expect(result.current).toBe(true)
+    })
+
+    it('returns true if the the feature is unlocked and enabled', () => {
+      const feature = faker.helpers.arrayElement(targetedFeatures)
+      jest.spyOn(useChainsHook, 'useHasFeature').mockReturnValue(true)
+      jest.spyOn(useIsTargetedSafeHook, 'useIsTargetedSafe').mockReturnValue(false)
+      jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[feature], jest.fn()])
+
+      const { result } = renderHook(() => useIsTargetedFeature(feature))
+
+      expect(result.current).toBe(true)
+    })
+
+    it('returns false if the Safe is targeted but the feature is disabled', () => {
+      const feature = faker.helpers.arrayElement(targetedFeatures)
+      jest.spyOn(useChainsHook, 'useHasFeature').mockReturnValue(false)
+      jest.spyOn(useIsTargetedSafeHook, 'useIsTargetedSafe').mockReturnValue(true)
+      jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[], jest.fn()])
+
+      const { result } = renderHook(() => useIsTargetedFeature(feature))
+
+      expect(result.current).toBe(false)
+    })
+
+    it('returns false if the Safe is targeted and the feature is unlocked', () => {
+      const feature = faker.helpers.arrayElement(targetedFeatures)
+      jest.spyOn(useChainsHook, 'useHasFeature').mockReturnValue(false)
+      jest.spyOn(useIsTargetedSafeHook, 'useIsTargetedSafe').mockReturnValue(true)
+      jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[feature], jest.fn()])
+
+      const { result } = renderHook(() => useIsTargetedFeature(feature))
+
+      expect(result.current).toBe(false)
+    })
+
+    it('caches targeted/enabled features', () => {
+      const feature = faker.helpers.arrayElement(targetedFeatures)
+      const setLocalStorageMock = jest.fn()
+      jest.spyOn(useChainsHook, 'useHasFeature').mockReturnValue(true)
+      jest.spyOn(useIsTargetedSafeHook, 'useIsTargetedSafe').mockReturnValue(true)
+      jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[feature], jest.fn()])
+
+      renderHook(() => useIsTargetedFeature(feature))
+
+      waitFor(() => {
+        expect(setLocalStorageMock).toHaveBeenCalledWith([feature])
+      })
+    })
+  })
+})

apps/web/src/features/targetedOutreach/hooks/useIsTargetedSafe.ts

@@ -0,0 +1,45 @@
+import { useEffect } from 'react'
+import { useTargetedMessagingGetTargetedSafeV1Query } from '@safe-global/store/gateway/AUTO_GENERATED/targeted-messages'
+
+import { useHasFeature } from '@/hooks/useChains'
+import useSafeInfo from '@/hooks/useSafeInfo'
+import useLocalStorage from '@/services/local-storage/useLocalStorage'
+import { sameAddress } from '@/utils/addresses'
+import { TARGETED_FEATURES } from '../constants'
+
+const UNLOCKED_FEATURES_LS_KEY = 'unlockedFeatures'
+
+export function useIsTargetedSafe(outreachId: (typeof TARGETED_FEATURES)[number]['id']): boolean {
+  const { safe } = useSafeInfo()
+  const { data } = useTargetedMessagingGetTargetedSafeV1Query(
+    {
+      outreachId,
+      chainId: safe.chainId,
+      safeAddress: safe.address.value,
+    },
+    { skip: !safe.address.value },
+  )
+
+  return data?.outreachId === outreachId && sameAddress(data.address, safe.address.value)
+}
+
+type TargetedFeatures = (typeof TARGETED_FEATURES)[number]['feature']
+
+export function useIsTargetedFeature(feature: TargetedFeatures): boolean {
+  const hasFeature = useHasFeature(feature)
+
+  const outreachId = TARGETED_FEATURES.find((f) => f.feature === feature)!.id
+  const isTargeted = useIsTargetedSafe(outreachId)
+
+  // Should a targeted Safe have been opened, we "unlock" the feature across the app
+  const [unlockedFeatures = [], setUnlockedFeatures] =
+    useLocalStorage<Array<TargetedFeatures>>(UNLOCKED_FEATURES_LS_KEY)
+  const isUnlocked = unlockedFeatures.includes(feature)
+  useEffect(() => {
+    if (hasFeature && isTargeted && !isUnlocked) {
+      setUnlockedFeatures([...unlockedFeatures, feature])
+    }
+  }, [feature, hasFeature, isTargeted, isUnlocked, setUnlockedFeatures, unlockedFeatures])
+
+  return !!hasFeature && (isTargeted || isUnlocked)
+}

apps/web/src/utils/chains.ts

@@ -41,6 +41,8 @@ export enum FEATURES {
   BRIDGE = 'BRIDGE',
   RENEW_NOTIFICATIONS_TOKEN = 'RENEW_NOTIFICATIONS_TOKEN',
   TX_NOTES = 'TX_NOTES',
+  NESTED_SAFES = 'NESTED_SAFES',
+  MASS_PAYOUTS = 'MASS_PAYOUTS',
 }
 
 export const FeatureRoutes = {