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/targetedFeatures/constants.ts

@@ -0,0 +1,6 @@
+import { FEATURES } from '@/utils/chains'
+
+export const TARGETED_FEATURES = [
+  { id: 3, feature: FEATURES.TARGETED_NESTED_SAFES },
+  { id: 4, feature: FEATURES.TARGETED_MASS_PAYOUTS },
+] as const

apps/web/src/features/targetedFeatures/hooks/__tests__/useIsOutreachSafe.test.ts

@@ -0,0 +1,140 @@
+import { faker } from '@faker-js/faker'
+import * as targetedMessages from '@safe-global/store/gateway/AUTO_GENERATED/targeted-messages'
+
+import * as useSafeInfoHook from '@/hooks/useSafeInfo'
+import { safeInfoBuilder } from '@/tests/builders/safe'
+import { renderHook } from '@/tests/test-utils'
+import { useIsOutreachSafe } from '../useIsOutreachSafe'
+
+describe('useIsOutreachSafe', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('returns true if the Safe is targeted for messaging', () => {
+    const safeInfo = safeInfoBuilder().build()
+    const outreachId = faker.number.int()
+    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(() => useIsOutreachSafe(outreachId))
+
+    expect(result.current).toBe(true)
+  })
+
+  it('returns false if the Safe is not targeted for messaging', () => {
+    const safeInfo = safeInfoBuilder().build()
+    const outreachId = faker.number.int()
+    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(() => useIsOutreachSafe(outreachId))
+
+    expect(result.current).toBe(false)
+  })
+
+  it('returns false if the data is not available', () => {
+    const safeInfo = safeInfoBuilder().build()
+    const outreachId = faker.number.int()
+    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(() => useIsOutreachSafe(outreachId))
+
+    expect(result.current).toBe(false)
+  })
+
+  it('returns false if the outreachId does not match', () => {
+    const safeInfo = safeInfoBuilder().build()
+    const outreachId = faker.number.int()
+    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(() => useIsOutreachSafe(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.number.int()
+    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(() => useIsOutreachSafe(outreachId))
+
+    expect(result.current).toBe(false)
+  })
+})

apps/web/src/features/targetedFeatures/hooks/__tests__/useIsTargetedFeature.test.ts

@@ -0,0 +1,74 @@
+import { faker } from '@faker-js/faker'
+
+import * as useOutreachSafeHook from '@/features/targetedFeatures/hooks/useIsOutreachSafe'
+import * as useChainsHook from '@/hooks/useChains'
+import * as useLocalStorageHook from '@/services/local-storage/useLocalStorage'
+import { renderHook, waitFor } from '@/tests/test-utils'
+import { useIsTargetedFeature } from '../useIsTargetedFeature'
+import { TARGETED_FEATURES } from '../../constants'
+
+const targetedFeatures = TARGETED_FEATURES.map((f) => f.feature)
+
+describe('useIsTargetedFeature', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  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(useOutreachSafeHook, 'useIsOutreachSafe').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(useOutreachSafeHook, 'useIsOutreachSafe').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(useOutreachSafeHook, 'useIsOutreachSafe').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(useOutreachSafeHook, 'useIsOutreachSafe').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(useOutreachSafeHook, 'useIsOutreachSafe').mockReturnValue(true)
+    jest.spyOn(useLocalStorageHook, 'default').mockReturnValue([[feature], jest.fn()])
+
+    renderHook(() => useIsTargetedFeature(feature))
+
+    waitFor(() => {
+      expect(setLocalStorageMock).toHaveBeenCalledWith([feature])
+    })
+  })
+})

apps/web/src/features/targetedFeatures/hooks/useIsOutreachSafe.ts

@@ -0,0 +1,18 @@
+import { useTargetedMessagingGetTargetedSafeV1Query } from '@safe-global/store/gateway/AUTO_GENERATED/targeted-messages'
+
+import useSafeInfo from '@/hooks/useSafeInfo'
+import { sameAddress } from '@/utils/addresses'
+
+export function useIsOutreachSafe(outreachId: number): 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)
+}

apps/web/src/features/targetedFeatures/hooks/useIsTargetedFeature.ts

@@ -0,0 +1,29 @@
+import { useEffect } from 'react'
+
+import { useIsOutreachSafe } from '@/features/targetedFeatures/hooks/useIsOutreachSafe'
+import { useHasFeature } from '@/hooks/useChains'
+import useLocalStorage from '@/services/local-storage/useLocalStorage'
+import { TARGETED_FEATURES } from '../constants'
+
+const UNLOCKED_FEATURES_LS_KEY = 'unlockedFeatures'
+
+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 = useIsOutreachSafe(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',
+  TARGETED_NESTED_SAFES = 'TARGETED_NESTED_SAFES',
+  TARGETED_MASS_PAYOUTS = 'TARGETED_MASS_PAYOUTS',
 }
 
 export const FeatureRoutes = {