diff --git a/.vscode/settings.json b/.vscode/settings.json
index 6b2eddc6ac..4b8545f0a4 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,4 +1,13 @@
 {
     "java.configuration.updateBuildConfiguration": "disabled",
-    "typescript.tsdk": "node_modules/typescript/lib"
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "jestrunner.debugOptions": {
+        "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/react-scripts",
+        "runtimeArgs": [
+          "test",
+          "${fileBasename}",
+          "--no-cache",
+          "--color"
+        ]
+    },
 }
\ No newline at end of file
diff --git a/apps/wallet-mobile/ios/Podfile.lock b/apps/wallet-mobile/ios/Podfile.lock
index 5c9e32eaf9..b9cb45d978 100644
--- a/apps/wallet-mobile/ios/Podfile.lock
+++ b/apps/wallet-mobile/ios/Podfile.lock
@@ -495,10 +495,10 @@ PODS:
     - SentryPrivate (= 8.9.3)
   - SentryPrivate (8.9.3)
   - Yoga (1.14.0)
-  - ZXingObjC/Core (3.6.5)
-  - ZXingObjC/OneD (3.6.5):
+  - ZXingObjC/Core (3.6.9)
+  - ZXingObjC/OneD (3.6.9):
     - ZXingObjC/Core
-  - ZXingObjC/PDF417 (3.6.5):
+  - ZXingObjC/PDF417 (3.6.9):
     - ZXingObjC/Core
 
 DEPENDENCIES:
@@ -858,7 +858,7 @@ SPEC CHECKSUMS:
   Sentry: 97161cac725da1ecbe77d1445bf8a61c1e5667f1
   SentryPrivate: 9a76def09fb08f9501997b8df946e8097947b94f
   Yoga: e71803b4c1fff832ccf9b92541e00f9b873119b9
-  ZXingObjC: fdbb269f25dd2032da343e06f10224d62f537bdb
+  ZXingObjC: 8898711ab495761b2dbbdec76d90164a6d7e14c5
 
 PODFILE CHECKSUM: 31f344d67f1a9c35e34eb202e3cdfeb4907367e8
 
diff --git a/apps/wallet-mobile/package.json b/apps/wallet-mobile/package.json
index e204d6e44a..1137499aa3 100644
--- a/apps/wallet-mobile/package.json
+++ b/apps/wallet-mobile/package.json
@@ -126,12 +126,13 @@
     "@yoroi/common": "1.5.2",
     "@yoroi/exchange": "2.0.1",
     "@yoroi/links": "1.5.4",
+    "@yoroi/portfolio": "1.0.0",
     "@yoroi/resolver": "2.0.4",
+    "@yoroi/setup-wallet": "1.0.0",
     "@yoroi/staking": "1.5.1",
     "@yoroi/swap": "1.5.2",
     "@yoroi/theme": "^1.0.0",
     "@yoroi/transfer": "1.0.0",
-    "@yoroi/setup-wallet": "1.0.0",
     "add": "2.0.6",
     "assert": "^2.0.0",
     "axios": "^1.5.0",
@@ -190,6 +191,7 @@
     "react-native-webview": "^11.25.0",
     "react-query": "^3.39.3",
     "reselect": "^4.0.0",
+    "rxjs": "^7.8.1",
     "sentry-expo": "^7.0.1",
     "stream-browserify": "3.0.0",
     "tinycolor2": "1.4.2",
diff --git a/apps/wallet-mobile/scripts/create-mocked-token-infos.js b/apps/wallet-mobile/scripts/create-mocked-token-infos.js
new file mode 100644
index 0000000000..9bca7fa207
--- /dev/null
+++ b/apps/wallet-mobile/scripts/create-mocked-token-infos.js
@@ -0,0 +1,40 @@
+const nftCryptoKitty = {
+  decimals: 0,
+  ticker: 'CryptoKitty',
+  name: 'CryptoKitty #1234',
+  symbol: 'CK',
+  status: 'normal',
+  application: 'token',
+  tag: '',
+  reference: '0xabcdef1234567890.cryptokitty1234',
+  website: 'https://www.cryptokitties.co',
+  originalImage: 'https://cdn.example.com/ck-original1234.png',
+  id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.43554259',
+  fingerprint: 'asset1s7nlt45cc82upqewvjtgu7g97l7eg483c6wu75',
+  nature: 'secondary',
+  type: 'nft',
+}
+
+function generateTokenInfos(baseToken, count) {
+  const tokens = []
+  for (let i = 0; i < count; i++) {
+    // Clone the base token object to create a new token
+    const id = `${baseToken.id.split('.')[0]}.${Buffer.from(String(i)).toString('hex')}`
+    const name = `${baseToken.name.split(' ')[0]} #${i}`
+    const reference = `${baseToken.reference.split('.')[0]}.${Buffer.from(String(i)).toString('hex')}`
+    const fingerprint = `asset${i}s7nlt45cc82upqewvjtgu7g97l7eg483c6wu${i}`
+    
+    const newToken = {...baseToken, id, name, reference, fingerprint}
+
+    tokens.push(newToken)
+  }
+  return tokens
+}
+
+const generatedTokens = generateTokenInfos(nftCryptoKitty, 50)
+
+const apiResponseTokenInfos = generatedTokens.reduce((acc, token, index) => {
+  acc[token.id] = [200, token, `hash${index + 1}`, 3600]
+  return acc
+}, {})
+
diff --git a/apps/wallet-mobile/src/AppNavigator.tsx b/apps/wallet-mobile/src/AppNavigator.tsx
index cfdfb3a24d..d97f976e4b 100644
--- a/apps/wallet-mobile/src/AppNavigator.tsx
+++ b/apps/wallet-mobile/src/AppNavigator.tsx
@@ -19,6 +19,7 @@ import {ModalScreen} from './components/Modal/ModalScreen'
 import {AgreementChangedNavigator, InitializationNavigator} from './features/Initialization'
 import {LegalAgreement, useLegalAgreement} from './features/Initialization/common'
 import {useDeepLinkWatcher} from './features/Links/common/useDeepLinkWatcher'
+import {PortfolioScreen} from './features/Portfolio/useCases/PortfolioScreen'
 import {AddWalletNavigator} from './features/SetupWallet/SetupWalletNavigator'
 import {CONFIG} from './legacy/config'
 import {DeveloperScreen} from './legacy/DeveloperScreen'
@@ -160,6 +161,8 @@ export const AppNavigator = () => {
               <Stack.Screen name="developer" component={DeveloperScreen} options={{headerShown: false}} />
 
               <Stack.Screen name="storybook" component={StorybookScreen} />
+
+              <Stack.Screen name="portfolio-dashboard" component={PortfolioScreen} />
             </Stack.Group>
           )}
         </Stack.Navigator>
@@ -248,9 +251,9 @@ type FirstAction = 'auth-with-pin' | 'auth-with-os' | 'request-new-pin' | 'first
 const getFirstAction = (
   isAuthOsSupported: boolean,
   authSetting: AuthSetting,
-  agreement: LegalAgreement | undefined,
+  legalAgreement: LegalAgreement | undefined | null,
 ): FirstAction => {
-  const hasAccepted = agreement?.latestAcceptedAgreementsDate === CONFIG.AGREEMENT_DATE
+  const hasAccepted = legalAgreement?.latestAcceptedAgreementsDate === CONFIG.AGREEMENT_DATE
 
   if (isString(authSetting) && !hasAccepted) return 'show-agreement-changed-notice'
 
@@ -264,7 +267,7 @@ const getFirstAction = (
 const useFirstAction = () => {
   const authSetting = useAuthSetting()
   const isAuthOsSupported = useIsAuthOsSupported()
-  const terms = useLegalAgreement()
+  const legalAgreement = useLegalAgreement()
 
-  return getFirstAction(isAuthOsSupported, authSetting, terms)
+  return getFirstAction(isAuthOsSupported, authSetting, legalAgreement)
 }
diff --git a/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioBalanceManager.ts b/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioBalanceManager.ts
new file mode 100644
index 0000000000..faa177bea4
--- /dev/null
+++ b/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioBalanceManager.ts
@@ -0,0 +1,73 @@
+import {mountMMKVStorage, observableStorageMaker} from '@yoroi/common'
+import {createPrimaryTokenInfo, portfolioBalanceManagerMaker, portfolioBalanceStorageMaker} from '@yoroi/portfolio'
+import {Portfolio} from '@yoroi/types'
+import * as React from 'react'
+
+import {YoroiWallet} from '../../../yoroi-wallets/cardano/types'
+
+export const usePortfolioBalanceManager = ({
+  tokenManager,
+  walletId,
+}: {
+  tokenManager: Portfolio.Manager.Token
+  walletId: YoroiWallet['id']
+}) => {
+  return React.useMemo(() => {
+    const balanceStorageMounted = mountMMKVStorage<Portfolio.Token.Id>({path: `balance/${walletId}/`})
+    const primaryBreakdownStorageMounted = mountMMKVStorage<Portfolio.Token.Id>({
+      path: `/primary-breakdown/${walletId}/`,
+    })
+
+    const balanceStorage = portfolioBalanceStorageMaker({
+      balanceStorage: observableStorageMaker(balanceStorageMounted),
+      primaryBreakdownStorage: observableStorageMaker(primaryBreakdownStorageMounted),
+    })
+
+    const balanceManager = portfolioBalanceManagerMaker({
+      tokenManager,
+      storage: balanceStorage,
+      primaryToken: {
+        info: primaryTokenInfo,
+        discovery: {
+          counters: {
+            items: 0,
+            supply: 0n,
+            totalItems: 0,
+          },
+          id: primaryTokenInfo.id,
+          originalMetadata: {
+            filteredMintMetadatum: null,
+            referenceDatum: null,
+            tokenRegistry: null,
+          },
+          properties: {},
+          source: {
+            decimals: Portfolio.Token.Source.Metadata,
+            name: Portfolio.Token.Source.Metadata,
+            ticker: Portfolio.Token.Source.Metadata,
+            symbol: Portfolio.Token.Source.Metadata,
+            image: Portfolio.Token.Source.Metadata,
+          },
+        },
+      },
+      sourceId: walletId,
+    })
+
+    balanceManager.hydrate()
+    return {
+      balanceManager,
+      balanceStorage,
+    }
+  }, [tokenManager, walletId])
+}
+
+const primaryTokenInfo = createPrimaryTokenInfo({
+  decimals: 6,
+  name: 'ADA',
+  ticker: 'ADA',
+  symbol: '$',
+  reference: '',
+  tag: '',
+  website: '',
+  originalImage: '',
+})
diff --git a/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioTokenManager.ts b/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioTokenManager.ts
new file mode 100644
index 0000000000..6286ddfcaa
--- /dev/null
+++ b/apps/wallet-mobile/src/features/Portfolio/common/usePortfolioTokenManager.ts
@@ -0,0 +1,27 @@
+import {mountMMKVStorage, observableStorageMaker} from '@yoroi/common'
+import {portfolioApiMaker, portfolioTokenManagerMaker, portfolioTokenStorageMaker} from '@yoroi/portfolio'
+import {Chain, Portfolio} from '@yoroi/types'
+import * as React from 'react'
+
+export const usePortfolioTokenManager = ({network}: {network: Chain.Network}) => {
+  return React.useMemo(() => {
+    const tokenDiscoveryStorageMounted = mountMMKVStorage<Portfolio.Token.Id>({path: `${network}/token-discovery/`})
+    const tokenInfoStorageMounted = mountMMKVStorage<Portfolio.Token.Id>({path: `${network}/token-info/`})
+
+    const tokenStorage = portfolioTokenStorageMaker({
+      tokenDiscoveryStorage: observableStorageMaker(tokenDiscoveryStorageMounted),
+      tokenInfoStorage: observableStorageMaker(tokenInfoStorageMounted),
+    })
+    const api = portfolioApiMaker({
+      network,
+    })
+
+    const tokenManager = portfolioTokenManagerMaker({
+      api,
+      storage: tokenStorage,
+    })
+
+    tokenManager.hydrate({sourceId: 'initial'})
+    return {tokenManager, tokenStorage}
+  }, [network])
+}
diff --git a/apps/wallet-mobile/src/features/Portfolio/useCases/PortfolioScreen.tsx b/apps/wallet-mobile/src/features/Portfolio/useCases/PortfolioScreen.tsx
new file mode 100644
index 0000000000..b8d7b9a2ff
--- /dev/null
+++ b/apps/wallet-mobile/src/features/Portfolio/useCases/PortfolioScreen.tsx
@@ -0,0 +1,127 @@
+import {useNavigation} from '@react-navigation/native'
+import {useObserver} from '@yoroi/common'
+import {Chain} from '@yoroi/types'
+import * as React from 'react'
+import {Text, View} from 'react-native'
+import {FlatList} from 'react-native-gesture-handler'
+import {SafeAreaView} from 'react-native-safe-area-context'
+
+import {Button, Spacer} from '../../../components'
+import {useSelectedWallet} from '../../WalletManager/Context'
+import {usePortfolioBalanceManager} from '../common/usePortfolioBalanceManager'
+import {usePortfolioTokenManager} from '../common/usePortfolioTokenManager'
+
+export const PortfolioScreen = () => {
+  const navigation = useNavigation()
+  const wallet = useSelectedWallet()
+  const {tokenManager, tokenStorage} = usePortfolioTokenManager({network: Chain.Network.Main})
+  const {balanceManager: bmW1, balanceStorage: bs1} = usePortfolioBalanceManager({
+    tokenManager,
+    walletId: wallet.id,
+  })
+
+  // wallet 2 for testing
+  const {balanceManager: bmW2, balanceStorage: bs2} = usePortfolioBalanceManager({
+    tokenManager,
+    walletId: 'wallet-2',
+  })
+  const {data: balancesW2, isPending: isPendingW2} = useObserver({
+    observable: bmW2.observable,
+    executor: () => bmW2.getBalances().all,
+  })
+  // end of wallet 2
+
+  const {data: balances, isPending} = useObserver({
+    observable: bmW1.observable,
+    executor: () => bmW1.getBalances().all,
+  })
+  const opacity = isPending || isPendingW2 ? 0.5 : 1
+
+  const handleOnSync = () => {
+    bmW1.sync({
+      primaryBalance: {
+        balance: 1n,
+        lockedInBuiltTxs: 2n,
+        minRequiredByTokens: 0n,
+        records: [],
+      },
+      secondaryBalances: new Map([
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.34', {balance: 2n, lockedInBuiltTxs: 0n}],
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.35', {balance: 3n, lockedInBuiltTxs: 0n}],
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.36', {balance: 4n, lockedInBuiltTxs: 0n}],
+      ]),
+    })
+
+    bmW2.sync({
+      primaryBalance: {
+        balance: 2n,
+        lockedInBuiltTxs: 3n,
+        minRequiredByTokens: 0n,
+        records: [],
+      },
+      secondaryBalances: new Map([
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3130', {balance: 222n, lockedInBuiltTxs: 0n}],
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.35', {balance: 223n, lockedInBuiltTxs: 0n}],
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3131', {balance: 224n, lockedInBuiltTxs: 0n}],
+        ['14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3132', {balance: 224n, lockedInBuiltTxs: 0n}],
+      ]),
+    })
+  }
+
+  const handleOnReset = () => {
+    bs1.clear()
+    bs2.clear()
+    tokenStorage.clear()
+    navigation.goBack()
+  }
+
+  return (
+    <SafeAreaView edges={['bottom', 'top', 'left', 'right']}>
+      <View style={{padding: 16}}>
+        <Text>Portfolio playground</Text>
+
+        <Spacer height={16} />
+
+        <Button title="sync" onPress={handleOnSync} shelleyTheme />
+
+        <Spacer height={16} />
+
+        <Button title="reset" onPress={handleOnReset} outlineShelley />
+
+        <Spacer height={16} />
+
+        <Text>w1 {wallet.id}</Text>
+
+        <Text>all: {balances.length}</Text>
+
+        <FlatList
+          data={balances}
+          keyExtractor={(item) => item.info.id}
+          renderItem={({item}) => (
+            <View style={{padding: 8, backgroundColor: 'lightgray', marginVertical: 4, opacity}}>
+              <Text>{item.info.name}</Text>
+
+              <Text>{item.balance.toString()}</Text>
+            </View>
+          )}
+        />
+
+        <Text>wallet 2</Text>
+
+        <Text>all: {balances.length}</Text>
+
+        <FlatList
+          data={balancesW2}
+          keyExtractor={(item) => item.info.id}
+          renderItem={({item}) => (
+            <View style={{padding: 8, backgroundColor: 'lightgray', marginVertical: 4, opacity}}>
+              <Text>{item.info.name}</Text>
+
+              <Text>{item.balance.toString()}</Text>
+            </View>
+          )}
+        />
+      </View>
+    </SafeAreaView>
+  )
+}
diff --git a/apps/wallet-mobile/src/legacy/DeveloperScreen.tsx b/apps/wallet-mobile/src/legacy/DeveloperScreen.tsx
index a887c2b41d..981afa0eda 100644
--- a/apps/wallet-mobile/src/legacy/DeveloperScreen.tsx
+++ b/apps/wallet-mobile/src/legacy/DeveloperScreen.tsx
@@ -85,6 +85,8 @@ export const DeveloperScreen = () => {
           onPress={() => storageVersionMaker(rootStorage).remove()}
         />
 
+        <Button title="Portfolio" style={styles.button} onPress={() => navigation.navigate('portfolio-dashboard')} />
+
         <Button
           title="Logout"
           style={styles.button}
diff --git a/apps/wallet-mobile/src/migrations/4_9_0.test.ts b/apps/wallet-mobile/src/migrations/4_9_0.test.ts
index 65af0600eb..bb5cb645d2 100644
--- a/apps/wallet-mobile/src/migrations/4_9_0.test.ts
+++ b/apps/wallet-mobile/src/migrations/4_9_0.test.ts
@@ -30,7 +30,7 @@ describe('migrateAuthSetting', () => {
 
   // if the store is inconsistent we favor OS, so the user can disable on device and it will ask for a new pin
   it('old store is pin + os (inconsistent), method = "os"', async () => {
-    await rootStorage.join('appSettings/').multiSet([
+    await rootStorage.join('appSettings/').multiSet<string | boolean>([
       ['customPinHash', 'encrypted-hash'],
       [OLD_OS_AUTH_KEY, true],
     ])
@@ -41,7 +41,7 @@ describe('migrateAuthSetting', () => {
   })
 
   it('old store is pin, method = "pin"', async () => {
-    await rootStorage.join('appSettings/').multiSet([
+    await rootStorage.join('appSettings/').multiSet<string | boolean>([
       ['customPinHash', 'encrypted-hash'],
       [OLD_OS_AUTH_KEY, false],
     ])
diff --git a/apps/wallet-mobile/src/navigation.tsx b/apps/wallet-mobile/src/navigation.tsx
index 63e8692d07..eabbd51cfe 100644
--- a/apps/wallet-mobile/src/navigation.tsx
+++ b/apps/wallet-mobile/src/navigation.tsx
@@ -314,7 +314,12 @@ export type MenuRoutes = {
   'voting-registration': undefined
 }
 
-export type AppRoutes = {
+export type PortfolioRoutes = {
+  'portfolio-dashboard': undefined
+}
+
+// TODO revisit portfolio
+export type AppRoutes = PortfolioRoutes & {
   'first-run': NavigatorScreenParams<FirstRunRoutes>
   developer: undefined
   storybook: undefined
diff --git a/apps/wallet-mobile/src/yoroi-wallets/auth/auth.ts b/apps/wallet-mobile/src/yoroi-wallets/auth/auth.ts
index cf6a1ac38c..128d5e0be4 100644
--- a/apps/wallet-mobile/src/yoroi-wallets/auth/auth.ts
+++ b/apps/wallet-mobile/src/yoroi-wallets/auth/auth.ts
@@ -159,9 +159,10 @@ export const disableAllEasyConfirmation = async (storage: App.Storage) => {
   })
 
   const updateWalletJSONs = walletIds.map(async (walletId) => {
-    const walletJSON: Record<string, unknown> & {isEasyConfirmationEnabled: boolean} = await walletStorage
+    const walletJSON: null | (Record<string, unknown> & {isEasyConfirmationEnabled: boolean}) = await walletStorage
       .join(`${walletId}/`)
       .getItem('data')
+    if (walletJSON == null) return
     await walletStorage.join(`${walletId}/`).setItem('data', {...walletJSON, isEasyConfirmationEnabled: false})
   })
 
@@ -227,12 +228,14 @@ export const useAuthSetting = (options?: UseQueryOptions<AuthSetting, Error>) =>
   return query.data
 }
 
-export const getAuthSetting = async (storage: App.Storage) =>
-  storage.join('appSettings/').getItem('auth', parseAuthSetting)
+export const getAuthSetting = async (storage: App.Storage) => {
+  const authSetting = await storage.join('appSettings/').getItem('auth', parseAuthSetting)
+  return authSetting ?? undefined
+}
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isAuthSetting = (data: any): data is 'os' | 'pin' | undefined => ['os', 'pin', undefined].includes(data)
 const parseAuthSetting = (data: unknown) => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const isAuthSetting = (data: any): data is 'os' | 'pin' | undefined => ['os', 'pin', undefined].includes(data)
   const parsed = parseSafe(data)
   return isAuthSetting(parsed) ? parsed : undefined
 }
diff --git a/apps/wallet-mobile/src/yoroi-wallets/cardano/transactionManager/transactionManager.test.ts b/apps/wallet-mobile/src/yoroi-wallets/cardano/transactionManager/transactionManager.test.ts
index 4ef3dc4c0e..b07a08985a 100644
--- a/apps/wallet-mobile/src/yoroi-wallets/cardano/transactionManager/transactionManager.test.ts
+++ b/apps/wallet-mobile/src/yoroi-wallets/cardano/transactionManager/transactionManager.test.ts
@@ -3,6 +3,7 @@ import {fromPairs} from 'lodash'
 import DeviceInfo from 'react-native-device-info'
 
 import {rootStorage} from '../../storage/rootStorage'
+import {Transaction} from '../../types/other'
 import {ApiHistoryError} from '../errors'
 import {
   mockedAddressesByChunks,
@@ -32,7 +33,7 @@ describe('transactionManager', () => {
     DeviceInfo.getVersion = () => '9.9.9'
 
     const mockStorage = rootStorage.join('txs/')
-    mockStorage.multiSet([
+    await mockStorage.multiSet<Transaction | [string]>([
       [mockTx.id, mockTx],
       ['txids', [mockTx.id]],
     ])
@@ -82,7 +83,7 @@ describe('transaction storage', () => {
 
   it('drops transaction if invalid format', async () => {
     const storage = rootStorage.join('txs/')
-    storage.multiSet([
+    await storage.multiSet([
       [mockTx.id, undefined],
       ['txids', [mockTx.id]],
     ])
@@ -96,7 +97,7 @@ describe('transaction storage', () => {
 
   it('starts fresh if txids is invalid format', async () => {
     const storage = rootStorage.join('txs/')
-    storage.multiSet([
+    await storage.multiSet([
       [mockTx.id, mockTx],
       ['txids', undefined],
     ])
diff --git a/apps/wallet-mobile/src/yoroi-wallets/cardano/utxoManager/utxoManager.ts b/apps/wallet-mobile/src/yoroi-wallets/cardano/utxoManager/utxoManager.ts
index d8bc11a182..7d1bcfac47 100644
--- a/apps/wallet-mobile/src/yoroi-wallets/cardano/utxoManager/utxoManager.ts
+++ b/apps/wallet-mobile/src/yoroi-wallets/cardano/utxoManager/utxoManager.ts
@@ -15,7 +15,13 @@ export const makeUtxoManager = async ({storage, apiUrl}: {storage: App.Storage;
 
   const getCachedUtxos = () => service.getAvailableUtxos().then((utxos) => utxos.map(serializer))
   const initialUtxos = await getCachedUtxos()
-  const initialCollateralId = await managerStorage.collateral.read()
+
+  const getCollateralId = async (): Promise<string> => {
+    const collateralId = await managerStorage.collateral.read()
+    return collateralId ?? ''
+  }
+
+  const initialCollateralId = await getCollateralId()
 
   // utxo state is related to the addresses used, if it changes a reset is needed
   const sync = (addresses: Array<string>) => {
@@ -41,7 +47,7 @@ export const makeUtxoManager = async ({storage, apiUrl}: {storage: App.Storage;
     sync,
 
     initialCollateralId,
-    getCollateralId: () => managerStorage.collateral.read(),
+    getCollateralId,
     setCollateralId: (utxoId: RawUtxo['utxo_id']) => managerStorage.collateral.save(utxoId),
   } as const
 }
@@ -87,7 +93,11 @@ export const makeUtxoStorage = (storage: App.Storage) => {
   const setUtxoDiffToBestBlock = (utxoDiffToBestBlock: UtxoDiffToBestBlock[]) =>
     storage.setItem(diffPath, utxoDiffToBestBlock)
 
-  const getUtxoAtSafePoint = () => storage.getItem(safePointPath, parseSafePoint)
+  const getUtxoAtSafePoint = async (): Promise<UtxoModels.UtxoAtSafePoint | undefined> => {
+    const safePoint = await storage.getItem(safePointPath, parseSafePoint)
+    if (!safePoint) return undefined
+    return safePoint
+  }
   const setUtxoAtSafePoint = (utxoAtSafePoint: UtxoAtSafePoint) => storage.setItem(safePointPath, utxoAtSafePoint)
 
   const utxoStorage: UtxoStorage = {
diff --git a/apps/wallet-mobile/src/yoroi-wallets/memos/memosManager.ts b/apps/wallet-mobile/src/yoroi-wallets/memos/memosManager.ts
index b164e46889..5e5f7ebdcf 100644
--- a/apps/wallet-mobile/src/yoroi-wallets/memos/memosManager.ts
+++ b/apps/wallet-mobile/src/yoroi-wallets/memos/memosManager.ts
@@ -33,7 +33,7 @@ export const makeMemosManager = async (storage: App.Storage) => {
   } as const
 }
 
-const filterCorruptEntries = (tuples: ReadonlyArray<[string, string | undefined]>) => {
+const filterCorruptEntries = (tuples: ReadonlyArray<[string, unknown]>) => {
   return tuples.filter((tuple): tuple is [string, string] => isString(tuple[1]))
 }
 
diff --git a/apps/wallet-mobile/src/yoroi-wallets/storage/rootStorage.ts b/apps/wallet-mobile/src/yoroi-wallets/storage/rootStorage.ts
index 932041c51c..ab001e48c2 100644
--- a/apps/wallet-mobile/src/yoroi-wallets/storage/rootStorage.ts
+++ b/apps/wallet-mobile/src/yoroi-wallets/storage/rootStorage.ts
@@ -1,3 +1,3 @@
 import {mountAsyncStorage} from '@yoroi/common'
 
-export const rootStorage = mountAsyncStorage('/')
+export const rootStorage = mountAsyncStorage({path: '/'})
diff --git a/apps/wallet-mobile/translations/messages/src/AppNavigator.json b/apps/wallet-mobile/translations/messages/src/AppNavigator.json
index 79455e774c..7ac0089c44 100644
--- a/apps/wallet-mobile/translations/messages/src/AppNavigator.json
+++ b/apps/wallet-mobile/translations/messages/src/AppNavigator.json
@@ -4,14 +4,14 @@
     "defaultMessage": "!!!Enter PIN",
     "file": "src/AppNavigator.tsx",
     "start": {
-      "line": 189,
+      "line": 192,
       "column": 17,
-      "index": 6488
+      "index": 6653
     },
     "end": {
-      "line": 192,
+      "line": 195,
       "column": 3,
-      "index": 6578
+      "index": 6743
     }
   },
   {
@@ -19,14 +19,14 @@
     "defaultMessage": "!!!Set PIN",
     "file": "src/AppNavigator.tsx",
     "start": {
-      "line": 193,
+      "line": 196,
       "column": 18,
-      "index": 6598
+      "index": 6763
     },
     "end": {
-      "line": 196,
+      "line": 199,
       "column": 3,
-      "index": 6696
+      "index": 6861
     }
   },
   {
@@ -34,14 +34,14 @@
     "defaultMessage": "!!!Auth with OS changes",
     "file": "src/AppNavigator.tsx",
     "start": {
-      "line": 197,
+      "line": 200,
       "column": 25,
-      "index": 6723
+      "index": 6888
     },
     "end": {
-      "line": 200,
+      "line": 203,
       "column": 3,
-      "index": 6837
+      "index": 7002
     }
   },
   {
@@ -49,14 +49,14 @@
     "defaultMessage": "!!!Auth with OS changed detected",
     "file": "src/AppNavigator.tsx",
     "start": {
-      "line": 201,
+      "line": 204,
       "column": 27,
-      "index": 6866
+      "index": 7031
     },
     "end": {
-      "line": 204,
+      "line": 207,
       "column": 3,
-      "index": 6987
+      "index": 7152
     }
   }
 ]
\ No newline at end of file
diff --git a/apps/wallet-mobile/translations/messages/src/yoroi-wallets/auth/auth.json b/apps/wallet-mobile/translations/messages/src/yoroi-wallets/auth/auth.json
index fd8fd739ee..632c2fafe4 100644
--- a/apps/wallet-mobile/translations/messages/src/yoroi-wallets/auth/auth.json
+++ b/apps/wallet-mobile/translations/messages/src/yoroi-wallets/auth/auth.json
@@ -4,14 +4,14 @@
     "defaultMessage": "!!!Authorize",
     "file": "src/yoroi-wallets/auth/auth.ts",
     "start": {
-      "line": 253,
+      "line": 256,
       "column": 13,
-      "index": 8464
+      "index": 8568
     },
     "end": {
-      "line": 256,
+      "line": 259,
       "column": 3,
-      "index": 8571
+      "index": 8675
     }
   },
   {
@@ -19,14 +19,14 @@
     "defaultMessage": "!!!Too many attempts",
     "file": "src/yoroi-wallets/auth/auth.ts",
     "start": {
-      "line": 257,
+      "line": 260,
       "column": 19,
-      "index": 8592
+      "index": 8696
     },
     "end": {
-      "line": 260,
+      "line": 263,
       "column": 3,
-      "index": 8703
+      "index": 8807
     }
   },
   {
@@ -34,14 +34,14 @@
     "defaultMessage": "!!!Unknown error!",
     "file": "src/yoroi-wallets/auth/auth.ts",
     "start": {
-      "line": 261,
+      "line": 264,
       "column": 16,
-      "index": 8721
+      "index": 8825
     },
     "end": {
-      "line": 264,
+      "line": 267,
       "column": 3,
-      "index": 8828
+      "index": 8932
     }
   }
 ]
\ No newline at end of file
diff --git a/metro.config.js b/metro.config.js
index 6ff064b5f7..7fb9840ddb 100644
--- a/metro.config.js
+++ b/metro.config.js
@@ -8,6 +8,7 @@ module.exports = {
     path.resolve(__dirname, "packages/common"),
     path.resolve(__dirname, "packages/api"),
     path.resolve(__dirname, "packages/exchange"),
+    path.resolve(__dirname, "packages/portfolio"),
     path.resolve(__dirname, "packages/links"),
     path.resolve(__dirname, "packages/resolver"),
     path.resolve(__dirname, "packages/swap"),
diff --git a/packages/common/package.json b/packages/common/package.json
index 33908387cb..78dba50451 100644
--- a/packages/common/package.json
+++ b/packages/common/package.json
@@ -58,8 +58,8 @@
     "prepublish:prod": "yarn build:release",
     "publish:prod": "npm publish --scope yoroi --access public",
     "release": "release-it",
-    "test": "jest",
-    "test:watch": "jest --watch --debug",
+    "test": "jest --maxWorkers=1",
+    "test:watch": "jest --watch --debug --maxWorkers=1",
     "tsc": "tsc --noEmit -p tsconfig.json"
   },
   "commitlint": {
@@ -108,7 +108,8 @@
     "collectCoverage": true,
     "collectCoverageFrom": [
       "src/**/*.{js,jsx,ts,tsx}",
-      "!src/**/*.d.ts"
+      "!src/**/*.d.ts",
+      "!src/fixtures/**"
     ],
     "coverageReporters": [
       "text-summary",
@@ -154,6 +155,7 @@
     "eslint-plugin-ft-flow": "^3.0.0",
     "eslint-plugin-prettier": "^4.0.0",
     "flowgen": "^1.21.0",
+    "immer": "^10.0.3",
     "jest": "^28.1.1",
     "pod-install": "^0.1.0",
     "prettier": "^2.0.5",
@@ -164,6 +166,7 @@
     "react-query": "^3.39.3",
     "react-test-renderer": "^18.2.0",
     "release-it": "^15.0.0",
+    "rxjs": "^7.8.1",
     "typescript": "^5.3.3",
     "zod": "^3.22.1"
   },
@@ -173,9 +176,12 @@
   "peerDependencies": {
     "@react-native-async-storage/async-storage": ">= 1.19.3 <= 1.20.0",
     "axios": "^1.5.0",
+    "bignumber.js": "^9.0.1",
+    "immer": "^10.0.3",
     "react": ">= 16.8.0 <= 19.0.0",
     "react-native-mmkv": "^2.11.0",
     "react-query": "^3.39.3",
+    "rxjs": "^7.8.1",
     "zod": "^3.22.1"
   },
   "packageManager": "yarn@1.22.21",
diff --git a/packages/common/src/api/fetchData.ts b/packages/common/src/api/fetchData.ts
index 99bf2c691f..7f228b688d 100644
--- a/packages/common/src/api/fetchData.ts
+++ b/packages/common/src/api/fetchData.ts
@@ -1,6 +1,13 @@
 import axios, {AxiosError, AxiosRequestConfig, AxiosResponse} from 'axios'
 import {Api} from '@yoroi/types'
 
+// Module augmentation to extend AxiosRequestConfig
+declare module 'axios' {
+  export interface AxiosRequestConfig {
+    metadata?: {startTime: number; duration: number}
+  }
+}
+
 type GetRequestConfig = {
   url: string
   method?: 'get'
@@ -56,7 +63,7 @@ export type FetchData = <T, D = any>(
  * fetchData<{ someDataType }, { somePayloadType }>({
  *   url: 'https://example.com/data',
  *   method: 'post',
- *   data: { /* some data *\/ }
+ *   data: {...somePayload}
  * }).then(response => {
  *   // Handle response
  * }).catch(error => {
@@ -77,13 +84,16 @@ export const fetchData: FetchData = <T, D = any>(
     method: method,
     headers: config.headers ?? {'Content-Type': 'application/json'},
     ...(isNotGet && 'data' in config && {data: config.data}),
+
+    // updated by the interceptors
+    metadata: {startTime: new Date().getTime(), duration: 0},
   }
 
   return axios(axiosConfig)
-    .then((response: AxiosResponse<T>) => {
+    .then(({status, data}: AxiosResponse<T>) => {
       return {
         tag: 'right',
-        value: {status: response.status, data: response.data},
+        value: {status, data},
       } as const
     })
     .catch((error: AxiosError) => {
@@ -117,3 +127,31 @@ export const fetchData: FetchData = <T, D = any>(
       }
     })
 }
+
+/* istanbul ignore next */
+axios.interceptors.request.use(
+  (config) => {
+    config.metadata = {startTime: new Date().getTime(), duration: 0}
+    return config
+  },
+  (error) => {
+    return Promise.reject(error)
+  },
+)
+
+/* istanbul ignore next */
+axios.interceptors.response.use(
+  (response) => {
+    if (response.config.metadata) {
+      const endTime = new Date().getTime()
+      const startTime = response.config.metadata.startTime
+      const duration = endTime - startTime
+      response.config.metadata.duration = duration
+    }
+
+    return response
+  },
+  (error) => {
+    return Promise.reject(error)
+  },
+)
diff --git a/packages/common/src/cache/cache-manage-multi-request.test.ts b/packages/common/src/cache/cache-manage-multi-request.test.ts
new file mode 100644
index 0000000000..d7464c09d8
--- /dev/null
+++ b/packages/common/src/cache/cache-manage-multi-request.test.ts
@@ -0,0 +1,451 @@
+import {Api, App} from '@yoroi/types'
+
+import {cacheManageMultiRequest} from './cache-manage-multi-request'
+
+describe('cacheManageMultiRequest', () => {
+  let cachedInfosWithoutRecord = new Map<string, App.CacheInfo>()
+  let ids = ['id1', 'id2', 'id3']
+  const request = jest.fn()
+  const persistance = {
+    read: jest.fn(),
+    save: jest.fn(),
+  }
+  const unknownRecordFactory = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    ids = ['id1', 'id2', 'id3']
+    persistance.read.mockReturnValue([])
+    request.mockResolvedValue([])
+    cachedInfosWithoutRecord = new Map<string, App.CacheInfo>()
+  })
+
+  it('should fetch records from API and update cache with unknowns', async () => {
+    const recordsFromApi = {
+      id1: [200, {}, 'etag1', 3600],
+      id2: [200, {}, 'etag2', 3600],
+    }
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: recordsFromApi,
+      },
+    })
+    unknownRecordFactory.mockImplementation(() => ({
+      hash: '',
+      expires: 0,
+      record: {},
+    }))
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+      unknownRecordFactory,
+    })
+
+    expect(request).toHaveBeenCalledWith([
+      ['id1', ''],
+      ['id2', ''],
+      ['id3', ''],
+    ])
+    expect(persistance.read).toHaveBeenCalledWith(['id3'])
+    expect(persistance.save).toHaveBeenCalledWith([
+      [
+        'id1',
+        {
+          hash: 'etag1',
+          expires: expect.any(Number),
+          record: {},
+        },
+      ],
+      [
+        'id2',
+        {
+          hash: 'etag2',
+          expires: expect.any(Number),
+          record: {},
+        },
+      ],
+      [
+        'id3',
+        {
+          hash: '',
+          expires: 0,
+          record: {},
+        },
+      ],
+    ])
+    expect(result.records.get('id1')).toEqual({
+      hash: 'etag1',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.records.get('id2')).toEqual({
+      hash: 'etag2',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.records.get('id3')).toEqual({
+      hash: '',
+      expires: 0,
+      record: {},
+    })
+    expect(result.updatedIds).toEqual(['id1', 'id2'])
+    expect(result.unknownIds).toEqual(['id3'])
+    expect(result.revalidatedIds).toEqual([])
+    expect(unknownRecordFactory).toHaveBeenCalledTimes(1)
+    expect(unknownRecordFactory).toHaveBeenCalledWith('id3')
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(true)
+  })
+
+  it('should handle not-modified responses and revalidate cache', async () => {
+    ids = ['id1', 'id2']
+    cachedInfosWithoutRecord = new Map([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: past,
+        },
+      ],
+      [
+        'id2',
+        {
+          hash: 'etag2-storage',
+          expires: past,
+        },
+      ],
+    ])
+    const recordsFromApi = {
+      id1: [Api.HttpStatusCode.NotModified, 3600],
+      id2: [Api.HttpStatusCode.NotModified, 3600],
+    }
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: recordsFromApi,
+      },
+    })
+
+    persistance.read.mockReturnValueOnce([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: Date.now() - 3600 * 1000,
+          record: {},
+        },
+      ],
+      [
+        'id2',
+        {
+          hash: 'etag2-storage',
+          expires: Date.now() - 3600 * 1000,
+          record: {},
+        },
+      ],
+    ])
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+      unknownRecordFactory,
+    })
+
+    expect(request).toHaveBeenCalledWith([
+      ['id1', 'etag1-storage'],
+      ['id2', 'etag2-storage'],
+    ])
+    expect(persistance.read).toHaveBeenCalledWith(['id1', 'id2'])
+    expect(persistance.save).toHaveBeenCalledWith([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: expect.any(Number),
+          record: {},
+        },
+      ],
+      [
+        'id2',
+        {
+          hash: 'etag2-storage',
+          expires: expect.any(Number),
+          record: {},
+        },
+      ],
+    ])
+    expect(result.records.get('id1')).toEqual({
+      hash: 'etag1-storage',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.records.get('id2')).toEqual({
+      hash: 'etag2-storage',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual([])
+    expect(result.revalidatedIds).toEqual(['id1', 'id2'])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(false)
+  })
+
+  it('should handle unknown records and save them to cache', async () => {
+    ids = ['id1']
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: {},
+      },
+    })
+
+    persistance.read.mockReturnValueOnce([['id1', null]])
+
+    unknownRecordFactory.mockReturnValueOnce({
+      hash: '',
+      expires: 0,
+      record: {},
+    })
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+      unknownRecordFactory,
+    })
+
+    expect(request).toHaveBeenCalledWith([['id1', '']])
+    expect(persistance.read).toHaveBeenCalledWith(['id1'])
+    expect(persistance.save).toHaveBeenCalledWith([
+      [
+        'id1',
+        {
+          hash: '',
+          expires: 0,
+          record: {},
+        },
+      ],
+    ])
+    expect(result.records.get('id1')).toEqual({
+      hash: '',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual(['id1'])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(true)
+  })
+
+  it('should handle unknown records and return the ids (no-factory)', async () => {
+    ids = ['id1']
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: {},
+      },
+    })
+
+    persistance.read.mockReturnValueOnce([['id1', null]])
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+    })
+
+    expect(request).toHaveBeenCalledWith([['id1', '']])
+    expect(persistance.read).toHaveBeenCalledWith(['id1'])
+    expect(persistance.save).not.toHaveBeenCalled()
+    expect(result.records.get('id1')).toBeNull()
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual(['id1'])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(false)
+  })
+
+  it('should resolve as unkonwn if API fails', async () => {
+    ids = ['id1']
+    request.mockResolvedValueOnce({
+      tag: 'left',
+      value: {
+        responseData: 'error',
+        message: 'error',
+      },
+    })
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+    })
+
+    expect(request).toHaveBeenCalledWith([['id1', '']])
+    expect(persistance.read).toHaveBeenCalledWith(['id1'])
+    expect(persistance.save).not.toHaveBeenCalled()
+    expect(result.records.get('id1')).toBeNull()
+
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual(['id1'])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(false)
+  })
+
+  it('should return as unkonwn if is local record but in memory and API returns as not-modified', async () => {
+    ids = ['id1']
+    cachedInfosWithoutRecord = new Map([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: past,
+        },
+      ],
+    ])
+    const recordsFromApi = {
+      id1: [Api.HttpStatusCode.NotModified, 3600],
+    }
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: recordsFromApi,
+      },
+    })
+    persistance.read.mockReturnValueOnce([[]])
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+    })
+
+    expect(request).toHaveBeenCalledWith([['id1', 'etag1-storage']])
+    expect(persistance.read).toHaveBeenCalledWith(['id1'])
+    expect(persistance.save).not.toHaveBeenCalled()
+    expect(result.records.get('id1')).toBeNull()
+
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual(['id1'])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(false)
+  })
+
+  it('should handle records to fetch when no cached data', async () => {
+    ids = ['id1']
+    request.mockResolvedValueOnce({
+      tag: 'right',
+      value: {
+        status: Api.HttpStatusCode.Ok,
+        data: {
+          id1: [Api.HttpStatusCode.Ok, {}, 'etag1', 3600],
+        },
+      },
+    })
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+    })
+
+    expect(request).toHaveBeenCalledWith([['id1', '']])
+    expect(persistance.read).not.toHaveBeenCalled()
+    expect(persistance.save).toHaveBeenCalledWith([
+      [
+        'id1',
+        {
+          hash: 'etag1',
+          expires: expect.any(Number),
+          record: {},
+        },
+      ],
+    ])
+    expect(result.records.get('id1')).toEqual({
+      hash: 'etag1',
+      expires: expect.any(Number),
+      record: {},
+    })
+    expect(result.updatedIds).toEqual(['id1'])
+    expect(result.unknownIds).toEqual([])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual([])
+    expect(result.isInvalidated).toBe(true)
+  })
+
+  it('should not hit the API if local cache is valid', async () => {
+    ids = ['id1']
+    cachedInfosWithoutRecord = new Map([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: future,
+        },
+      ],
+    ])
+    request.mockResolvedValueOnce({
+      tag: 'left',
+      value: {
+        responseData: 'error',
+        message: 'error',
+      },
+    })
+    persistance.read.mockReturnValueOnce([
+      [
+        'id1',
+        {
+          hash: 'etag1-storage',
+          expires: future,
+          record: {},
+        },
+      ],
+    ])
+
+    const result = await cacheManageMultiRequest({
+      cachedInfosWithoutRecord,
+      ids,
+      request,
+      persistance,
+    })
+
+    expect(request).not.toHaveBeenCalled()
+    expect(persistance.read).toHaveBeenCalledWith(['id1'])
+    expect(persistance.save).not.toHaveBeenCalled()
+    expect(result.records.get('id1')).toEqual({
+      hash: 'etag1-storage',
+      expires: future,
+      record: {},
+    })
+
+    expect(result.updatedIds).toEqual([])
+    expect(result.unknownIds).toEqual([])
+    expect(result.revalidatedIds).toEqual([])
+    expect(result.fromCacheIds).toEqual(['id1'])
+    expect(result.isInvalidated).toBe(false)
+  })
+})
+
+const past = Date.now() - 3_600 * 1_000
+const future = Date.now() + 3_600 * 1_000
diff --git a/packages/common/src/cache/cache-manage-multi-request.ts b/packages/common/src/cache/cache-manage-multi-request.ts
new file mode 100644
index 0000000000..3b5c955230
--- /dev/null
+++ b/packages/common/src/cache/cache-manage-multi-request.ts
@@ -0,0 +1,143 @@
+import {Api, App} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {cacheResolveRecordsSource} from './cache-resolve-records-source'
+import {isRight} from '../utils/monads'
+import {hasEntryValue} from '../utils/predicates'
+
+type CacheMultiRequestParams<K extends string, V> = {
+  // current cache info
+  cachedInfosWithoutRecord: Readonly<Map<K, App.CacheInfo>>
+  // new ids to be resolved -> api or persistance
+  ids: ReadonlyArray<K>
+  // api request to fetch the records
+  request: (
+    ids: ReadonlyArray<Api.RequestWithCache<K>>,
+  ) => Promise<Readonly<Api.Response<{[key in K]: Api.ResponseWithCache<V>}>>>
+  // cache persistance
+  persistance: {
+    read: (
+      ids: ReadonlyArray<K>,
+    ) => ReadonlyArray<[K, App.CacheRecord<V> | null]>
+    save: (records: ReadonlyArray<[K, App.CacheRecord<V>]>) => void
+  }
+  // factory to create unknown records when not provided return null for records not found
+  unknownRecordFactory?: (id: K) => Readonly<App.CacheRecord<V>>
+}
+
+export const cacheManageMultiRequest = async <K extends string, V>({
+  cachedInfosWithoutRecord,
+  ids,
+  request,
+  persistance,
+  unknownRecordFactory,
+}: CacheMultiRequestParams<K, V>) => {
+  // resolve the ids to be fetched and the ones that should be read from cache
+  const {toFetch, fromCache} = cacheResolveRecordsSource({
+    ids,
+    cachedInfosWithoutRecord,
+  })
+  let updatedIds: Array<K> = []
+
+  let toSaveRevalidatingCache: Map<K, App.CacheRecord<V>> = new Map()
+  let toRevalidateCache: Map<K, number> = new Map()
+  let toResolveLocally = new Set<K>(fromCache)
+  let cachedRecords: Map<K, App.CacheRecord<V> | null> = new Map()
+
+  let unknownIds: Array<K> = []
+  let unknownEmptyRecords: Array<[K, null]> = []
+  let toSaveNewUnknownRecord: Map<K, App.CacheRecord<V>> = new Map()
+
+  let toSaveNewFromApi: Map<K, App.CacheRecord<V>> = new Map()
+  let recordsFromApi: Record<K, Api.ResponseWithCache<V>> = {} as Record<
+    K,
+    Api.ResponseWithCache<V>
+  >
+
+  if (toFetch.length > 0) {
+    const apiResponse = await request(toFetch)
+    // if the request fails, we will show unknown tokens and wont block the user
+    if (isRight(apiResponse)) recordsFromApi = apiResponse.value.data
+  }
+  // to make same request time for all records, to avoid ms of difference
+  const baseDate = Date.now()
+
+  toFetch.forEach(([id]) => {
+    const recordFromApi = recordsFromApi[id]
+    if (!recordFromApi) {
+      toResolveLocally.add(id)
+      return
+    }
+
+    const [statusCode] = recordFromApi
+
+    // when not-modified add to revalidate cache by updating expires
+    if (statusCode === Api.HttpStatusCode.NotModified) {
+      const [, maxAge] = recordFromApi
+      toRevalidateCache.set(id, baseDate + maxAge * 1_000)
+      return
+    }
+
+    const [, record, eTag, maxAge] = recordFromApi
+    toSaveNewFromApi.set(id, {
+      hash: eTag,
+      expires: baseDate + maxAge * 1_000,
+      record,
+    })
+  })
+  updatedIds = [...toSaveNewFromApi.keys()]
+
+  // if there are empties (not-found) by the api and to refresh cache (not-modified)
+  if (toResolveLocally.size > 0 || toRevalidateCache.size > 0) {
+    const idsToReadFromPersistance = [
+      ...toResolveLocally.keys(),
+      ...toRevalidateCache.keys(),
+    ]
+    // WARN: should be the only reading operation
+    cachedRecords = new Map(
+      persistance.read(idsToReadFromPersistance).filter(hasEntryValue),
+    )
+
+    toRevalidateCache.forEach((expires, id) => {
+      const recordFromApi = cachedRecords.get(id)
+      if (recordFromApi != null)
+        toSaveRevalidatingCache.set(id, {...recordFromApi, expires})
+    })
+
+    // ids not found at this point should create an unknown record if factory is provided
+    unknownIds = idsToReadFromPersistance.filter((id) => !cachedRecords.has(id))
+    if (unknownRecordFactory) {
+      unknownIds
+        .map((id): [K, Readonly<App.CacheRecord<V>>] => [
+          id,
+          unknownRecordFactory(id),
+        ])
+        .forEach(([id, record]) => toSaveNewUnknownRecord.set(id, record))
+    } else {
+      unknownEmptyRecords = unknownIds.map((id) => [id, null])
+    }
+  }
+
+  // WARN: should be the only writing operation
+  const toSave = [
+    ...toSaveNewFromApi.entries(),
+    ...toSaveRevalidatingCache.entries(),
+    ...toSaveNewUnknownRecord.entries(),
+  ]
+  if (toSave.length > 0) persistance.save(toSave)
+
+  const result = freeze({
+    records: new Map([
+      ...cachedRecords.entries(),
+      ...toSave,
+      ...unknownEmptyRecords,
+    ]),
+    updatedIds,
+    unknownIds,
+    revalidatedIds: [...toSaveRevalidatingCache.keys()],
+    fromCacheIds: fromCache.filter((id) => cachedRecords.has(id)),
+    isInvalidated: updatedIds.length > 0 || toSaveNewUnknownRecord.size > 0,
+  })
+
+  return result
+}
diff --git a/packages/common/src/cache/cache-record-maker.test.ts b/packages/common/src/cache/cache-record-maker.test.ts
new file mode 100644
index 0000000000..bebc1d1ad5
--- /dev/null
+++ b/packages/common/src/cache/cache-record-maker.test.ts
@@ -0,0 +1,22 @@
+import {cacheRecordMaker} from './cache-record-maker'
+import {App} from '@yoroi/types'
+
+describe('cacheRecordMaker', () => {
+  it('should create a cache record with the provided information', () => {
+    const cacheInfo: App.CacheInfo = {
+      expires: 1234567890,
+      hash: 'abc123',
+    }
+    const record = {data: 'test'}
+
+    const expectedCacheRecord: App.CacheRecord<typeof record> = {
+      record,
+      expires: cacheInfo.expires,
+      hash: cacheInfo.hash,
+    }
+
+    const result = cacheRecordMaker(cacheInfo, record)
+
+    expect(result).toEqual(expectedCacheRecord)
+  })
+})
diff --git a/packages/common/src/cache/cache-record-maker.ts b/packages/common/src/cache/cache-record-maker.ts
new file mode 100644
index 0000000000..ffd7ab2eff
--- /dev/null
+++ b/packages/common/src/cache/cache-record-maker.ts
@@ -0,0 +1,12 @@
+import {App} from '@yoroi/types'
+
+export const cacheRecordMaker = <T>(
+  {expires, hash}: App.CacheInfo,
+  record: T,
+): App.CacheRecord<T> => {
+  return {
+    record,
+    expires,
+    hash,
+  }
+}
diff --git a/packages/common/src/cache/cache-record-schema-maker.test.ts b/packages/common/src/cache/cache-record-schema-maker.test.ts
new file mode 100644
index 0000000000..e52ac36232
--- /dev/null
+++ b/packages/common/src/cache/cache-record-schema-maker.test.ts
@@ -0,0 +1,137 @@
+import {App} from '@yoroi/types'
+import z from 'zod'
+
+import {
+  cacheRecordSchemaMaker,
+  isCacheRecord,
+  parseCacheRecord,
+} from './cache-record-schema-maker'
+
+describe('cacheRecordSchemaMaker', () => {
+  it('should validate a valid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const cacheRecordSchema = cacheRecordSchemaMaker(recordSchema)
+
+    const validCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 'Test',
+      },
+      expires: 1000,
+      hash: 'hash123',
+    }
+
+    const result = cacheRecordSchema.safeParse(validCacheRecord)
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should not validate an invalid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const cacheRecordSchema = cacheRecordSchemaMaker(recordSchema)
+
+    const invalidCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 123 as any,
+      },
+      expires: -100,
+      hash: 'hash123',
+    }
+
+    const result = cacheRecordSchema.safeParse(invalidCacheRecord)
+
+    expect(result.success).toBe(false)
+  })
+})
+describe('isCacheRecord', () => {
+  it('should return true for a valid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const validCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 'Test',
+      },
+      expires: 1000,
+      hash: 'hash123',
+    }
+
+    const result = isCacheRecord(recordSchema, validCacheRecord)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const invalidCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 123 as any,
+      },
+      expires: -100,
+      hash: 'hash123',
+    }
+
+    const result = isCacheRecord(recordSchema, invalidCacheRecord)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseCacheRecord', () => {
+  it('should return the cache record for a valid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const validCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 'Test',
+      },
+      expires: 1000,
+      hash: 'hash123',
+    }
+
+    const result = parseCacheRecord(recordSchema, validCacheRecord)
+
+    expect(result).toEqual(validCacheRecord)
+  })
+
+  it('should return undefined for an invalid cache record', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+
+    const invalidCacheRecord: App.CacheRecord<{id: string; name: string}> = {
+      record: {
+        id: '123',
+        name: 123 as any,
+      },
+      expires: -100,
+      hash: 'hash123',
+    }
+
+    const result = parseCacheRecord(recordSchema, invalidCacheRecord)
+
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/common/src/cache/cache-record-schema-maker.ts b/packages/common/src/cache/cache-record-schema-maker.ts
new file mode 100644
index 0000000000..e33ce37a24
--- /dev/null
+++ b/packages/common/src/cache/cache-record-schema-maker.ts
@@ -0,0 +1,27 @@
+import {App} from '@yoroi/types'
+import z, {ZodType} from 'zod'
+
+export const cacheRecordSchemaMaker = <T>(
+  recordSchema: ZodType<T>,
+): ZodType<App.CacheRecord<T>> => {
+  return z.object({
+    record: recordSchema,
+    expires: z.number().nonnegative(),
+    hash: z.string(),
+    // Zod is not infering the type correctly when using interface
+  }) as unknown as ZodType<App.CacheRecord<T>>
+}
+
+export const isCacheRecord = <T>(
+  recordSchema: ZodType<T>,
+  data: unknown,
+): data is App.CacheRecord<T> => {
+  return cacheRecordSchemaMaker<T>(recordSchema).safeParse(data).success
+}
+
+export const parseCacheRecord = <T>(
+  recordSchema: ZodType<T>,
+  data: unknown,
+): App.CacheRecord<T> | undefined => {
+  return isCacheRecord<T>(recordSchema, data) ? data : undefined
+}
diff --git a/packages/common/src/cache/cache-resolve-records-source.test.ts b/packages/common/src/cache/cache-resolve-records-source.test.ts
new file mode 100644
index 0000000000..6111ac9c29
--- /dev/null
+++ b/packages/common/src/cache/cache-resolve-records-source.test.ts
@@ -0,0 +1,78 @@
+import {Portfolio, App} from '@yoroi/types'
+
+import {cacheResolveRecordsSource} from './cache-resolve-records-source'
+
+describe('cacheResolveRecordsSource', () => {
+  it('should return an empty array when ids is empty', () => {
+    const ids: Portfolio.Token.Id[] = []
+    const cachedInfosWithoutRecord = new Map<Portfolio.Token.Id, App.CacheInfo>(
+      [['id.1', {expires: 1635724800000, hash: 'hash1'}]],
+    )
+
+    const {toFetch, fromCache} = cacheResolveRecordsSource({
+      ids,
+      cachedInfosWithoutRecord,
+    })
+
+    expect(toFetch).toEqual([])
+    expect(fromCache).toEqual([])
+  })
+
+  it('should return an array of records to fetch when ids are not cached', () => {
+    const ids: Portfolio.Token.Id[] = ['id.1', 'id.2']
+    const cachedInfosWithoutRecord = new Map<
+      Portfolio.Token.Id,
+      App.CacheInfo
+    >()
+
+    const {toFetch, fromCache} = cacheResolveRecordsSource({
+      ids,
+      cachedInfosWithoutRecord,
+    })
+
+    expect(toFetch).toEqual([
+      ['id.1', ''],
+      ['id.2', ''],
+    ])
+    expect(fromCache).toEqual([])
+  })
+
+  it('should return an array of records to fetch when ids are expired', () => {
+    const ids: Portfolio.Token.Id[] = ['id.1', 'id.2']
+    const past = Date.now() - 1000000
+    const future = Date.now() + 1000000
+    const cachedInfosWithoutRecord = new Map<Portfolio.Token.Id, App.CacheInfo>(
+      [
+        ['id.1', {expires: past, hash: 'hash1'}],
+        ['id.2', {expires: future, hash: 'hash2'}],
+      ],
+    )
+
+    const {toFetch, fromCache} = cacheResolveRecordsSource({
+      ids,
+      cachedInfosWithoutRecord,
+    })
+
+    expect(toFetch).toEqual([['id.1', 'hash1']])
+    expect(fromCache).toEqual(['id.2'])
+  })
+
+  it('should return an empty array when all ids are not expired', () => {
+    const ids: Portfolio.Token.Id[] = ['id.1', 'id.2']
+    const future = Date.now() + 1000000
+    const cachedInfosWithoutRecord = new Map<Portfolio.Token.Id, App.CacheInfo>(
+      [
+        ['id.1', {expires: future, hash: 'hash1'}],
+        ['id.2', {expires: future, hash: 'hash2'}],
+      ],
+    )
+
+    const {toFetch, fromCache} = cacheResolveRecordsSource({
+      ids,
+      cachedInfosWithoutRecord,
+    })
+
+    expect(toFetch).toEqual([])
+    expect(fromCache).toEqual(['id.1', 'id.2'])
+  })
+})
diff --git a/packages/common/src/cache/cache-resolve-records-source.ts b/packages/common/src/cache/cache-resolve-records-source.ts
new file mode 100644
index 0000000000..3633982a4d
--- /dev/null
+++ b/packages/common/src/cache/cache-resolve-records-source.ts
@@ -0,0 +1,28 @@
+import {Api, App} from '@yoroi/types'
+
+import {recordWithETag} from './record-with-etag'
+import {isExpired} from './is-expired'
+
+export const cacheResolveRecordsSource = <T>({
+  ids,
+  cachedInfosWithoutRecord,
+}: {
+  ids: ReadonlyArray<T>
+  cachedInfosWithoutRecord: Readonly<Map<T, App.CacheInfo | null | undefined>>
+}) => {
+  const toFetch: Array<Api.RequestWithCache<T>> = []
+  const fromCache: Array<T> = []
+  ids.forEach((id) => {
+    const cachedRecord = cachedInfosWithoutRecord.get(id)
+    if (cachedRecord) {
+      if (isExpired(cachedRecord)) {
+        toFetch.push(recordWithETag(id, cachedRecord.hash))
+      } else {
+        fromCache.push(id)
+      }
+    } else {
+      toFetch.push(recordWithETag(id))
+    }
+  })
+  return {toFetch, fromCache}
+}
diff --git a/packages/common/src/cache/extract-entry-cache-info.test.ts b/packages/common/src/cache/extract-entry-cache-info.test.ts
new file mode 100644
index 0000000000..8be1ebdb4c
--- /dev/null
+++ b/packages/common/src/cache/extract-entry-cache-info.test.ts
@@ -0,0 +1,24 @@
+import {extractEntryCacheInfo} from './extract-entry-cache-info'
+
+describe('extractEntryCacheInfo', () => {
+  it('should return cache info when record is not null', () => {
+    const key = 'exampleKey'
+    const record = {
+      expires: 123456789,
+      hash: 'exampleHash',
+    }
+
+    const result = extractEntryCacheInfo([key, record])
+
+    expect(result).toEqual([key, {expires: record.expires, hash: record.hash}])
+  })
+
+  it('should return null when record is null', () => {
+    const key = 'exampleKey'
+    const record = null
+
+    const result = extractEntryCacheInfo([key, record])
+
+    expect(result).toEqual([key, null])
+  })
+})
diff --git a/packages/common/src/cache/extract-entry-cache-info.ts b/packages/common/src/cache/extract-entry-cache-info.ts
new file mode 100644
index 0000000000..60ec60bb72
--- /dev/null
+++ b/packages/common/src/cache/extract-entry-cache-info.ts
@@ -0,0 +1,9 @@
+import {App} from '@yoroi/types'
+
+export const extractEntryCacheInfo = <
+  T extends App.CacheInfo | null | undefined,
+  K extends string,
+>([key, value]: [K, T]): [K, App.CacheInfo | null] =>
+  value != null
+    ? [key, {expires: value.expires, hash: value.hash}]
+    : [key, null]
diff --git a/packages/common/src/cache/is-expired.test.ts b/packages/common/src/cache/is-expired.test.ts
new file mode 100644
index 0000000000..1a40910400
--- /dev/null
+++ b/packages/common/src/cache/is-expired.test.ts
@@ -0,0 +1,14 @@
+import {isExpired} from './is-expired'
+
+const tenSeconds = 10 * 1000
+describe('isExpired', () => {
+  it.each`
+    description                     | cacheInfo                                                   | expected
+    ${'expired cache'}              | ${{expires: Date.now() - tenSeconds, hash: 'hash'}}         | ${true}
+    ${'not expired cache'}          | ${{expires: Date.now() + tenSeconds, hash: 'hash'}}         | ${false}
+    ${'expired cache as tuple'}     | ${[null, {expires: Date.now() - tenSeconds, hash: 'hash'}]} | ${true}
+    ${'not expired cache as tuple'} | ${[null, {expires: Date.now() + tenSeconds, hash: 'hash'}]} | ${false}
+  `('should return $expected if $description', ({expected, cacheInfo}) => {
+    expect(isExpired(cacheInfo)).toBe(expected)
+  })
+})
diff --git a/packages/common/src/cache/is-expired.ts b/packages/common/src/cache/is-expired.ts
new file mode 100644
index 0000000000..73f9cc92fc
--- /dev/null
+++ b/packages/common/src/cache/is-expired.ts
@@ -0,0 +1,12 @@
+import {App} from '@yoroi/types'
+
+import {isArray} from '../utils/parsers'
+
+export function isExpired([_, cacheInfo]: [unknown, App.CacheInfo]): boolean
+export function isExpired(cacheInfo: App.CacheInfo): boolean
+export function isExpired(
+  cacheInfo: App.CacheInfo | [unknown, App.CacheInfo],
+): boolean {
+  const expires = isArray(cacheInfo) ? cacheInfo[1].expires : cacheInfo.expires
+  return expires < Date.now()
+}
diff --git a/packages/common/src/cache/record-with-etag.test.ts b/packages/common/src/cache/record-with-etag.test.ts
new file mode 100644
index 0000000000..c0a33fe9b4
--- /dev/null
+++ b/packages/common/src/cache/record-with-etag.test.ts
@@ -0,0 +1,20 @@
+import {recordWithETag} from './record-with-etag'
+
+describe('recordWithETag', () => {
+  it('should return an array with the provided value and etag', () => {
+    const value = {data: 'test'}
+    const etag = '12345'
+
+    const result = recordWithETag(value, etag)
+
+    expect(result).toEqual([value, etag])
+  })
+
+  it('should return an array with the provided value and an empty etag if not provided', () => {
+    const value = {data: 'test'}
+
+    const result = recordWithETag(value)
+
+    expect(result).toEqual([value, ''])
+  })
+})
diff --git a/packages/common/src/cache/record-with-etag.ts b/packages/common/src/cache/record-with-etag.ts
new file mode 100644
index 0000000000..3b39c5062e
--- /dev/null
+++ b/packages/common/src/cache/record-with-etag.ts
@@ -0,0 +1,6 @@
+import {Api} from '@yoroi/types'
+
+export const recordWithETag = <T>(
+  value: T,
+  etag: string = '',
+): Api.RequestWithCache<T> => [value, etag]
diff --git a/packages/common/src/fixtures/ErrorBoundary.tsx b/packages/common/src/fixtures/ErrorBoundary.tsx
index 2cc55d1de9..80c2d199b6 100644
--- a/packages/common/src/fixtures/ErrorBoundary.tsx
+++ b/packages/common/src/fixtures/ErrorBoundary.tsx
@@ -1,8 +1,8 @@
-import React, {Component, ReactNode} from 'react'
+import * as React from 'react'
 import {View, Text} from 'react-native'
 
 interface Props {
-  children: ReactNode
+  children: React.ReactNode
 }
 
 interface State {
@@ -10,7 +10,7 @@ interface State {
   error?: Error
 }
 
-export class ErrorBoundary extends Component<Props, State> {
+export class ErrorBoundary extends React.Component<Props, State> {
   state: State = {
     hasError: false,
   }
diff --git a/packages/common/src/fixtures/async-behavior.ts b/packages/common/src/fixtures/async-behavior.ts
new file mode 100644
index 0000000000..5c8551c2df
--- /dev/null
+++ b/packages/common/src/fixtures/async-behavior.ts
@@ -0,0 +1,47 @@
+import {freeze} from 'immer'
+
+const success = <T = never>(result: T) => Promise.resolve(result)
+const loading = <T = never>() => new Promise<T>(() => {})
+const error = <T = never>(rejectWith?: Error) =>
+  Promise.reject<T>(rejectWith ?? new Error('Unknown error'))
+const delayed = <T = never>({
+  data,
+  timeout = 3000,
+}: {
+  data: T
+  timeout?: number
+}) =>
+  new Promise<T>((resolve) => {
+    setTimeout(() => resolve(data), timeout)
+  })
+const empty = <T = never>(emptyRepresentation: T) =>
+  Promise.resolve(emptyRepresentation)
+
+const asyncBehaviorMaker = <T>({
+  otherErrors,
+  data,
+  timeout,
+  emptyRepresentation,
+}: {
+  otherErrors?: {[error: string]: typeof error}
+  data: T
+  timeout?: number
+  emptyRepresentation: any
+}) =>
+  freeze({
+    delayed: (..._args: never) => delayed<T>({data, timeout}),
+    empty: (..._args: never) => empty<T>(emptyRepresentation),
+    error: {...otherErrors, unknown: (..._args: never) => error<T>()},
+    loading,
+    success: (..._args: never) => success<T>(data),
+  })
+
+export const asyncBehavior = freeze({
+  delayed,
+  empty,
+  error,
+  loading,
+  success,
+
+  maker: asyncBehaviorMaker,
+})
diff --git a/packages/common/src/index.ts b/packages/common/src/index.ts
index bdb10a94ce..92c3436192 100644
--- a/packages/common/src/index.ts
+++ b/packages/common/src/index.ts
@@ -1,17 +1,41 @@
-export * from './helpers/arrays'
+export * from './api/fetchData'
+export * from './api/getApiError'
+export * from './api/fetcher'
+
+export * from './cache/cache-manage-multi-request'
+export * from './cache/cache-record-maker'
+export * from './cache/cache-record-schema-maker'
+export * from './cache/cache-resolve-records-source'
+export * from './cache/extract-entry-cache-info'
+export * from './cache/is-expired'
+export * from './cache/record-with-etag'
+
 export * from './errors/errors'
-export * from './helpers/parsers'
-export * from './helpers/strings'
+
+export * from './fixtures/async-behavior'
+export * from './fixtures/ErrorBoundary'
+export * from './fixtures/query-client'
+export * from './fixtures/SuspenseBoundary'
+
+export * from './utils/arrays'
+export * from './utils/monads'
+export * from './utils/parsers'
+export * from './utils/predicates'
+export * from './utils/strings'
+
+export * from './numbers/as-atomic-value'
+
+export * from './observer/observer'
+
+export * from './queue/queue-task'
+
 export * from './storage/adapters/async-storage'
 export * from './storage/adapters/mmkv-storage'
-export * from './storage/translators/sync-storage-reactjs'
+export * from './storage/adapters/observable-storage'
 export * from './storage/translators/async-storage-reactjs'
-export * from './api/fetcher'
-export * from './api/fetchData'
-export * from './api/getApiError'
-export * from './observer/observer'
+export * from './storage/translators/sync-storage-reactjs'
+export * from './storage/helpers/storage-serializer'
+export * from './storage/helpers/storage-deserializer-maker'
+
 export * from './translators/reactjs/hooks/useMutationWithInvalidations'
-export * from './helpers/monads'
-export * from './fixtures/ErrorBoundary'
-export * from './fixtures/SuspenseBoundary'
-export * from './fixtures/query-client'
+export * from './translators/reactjs/hooks/useObserver'
diff --git a/packages/common/src/numbers/as-atomic-value.test.ts b/packages/common/src/numbers/as-atomic-value.test.ts
new file mode 100644
index 0000000000..83d8211670
--- /dev/null
+++ b/packages/common/src/numbers/as-atomic-value.test.ts
@@ -0,0 +1,36 @@
+import {Numbers} from '@yoroi/types'
+
+import {asAtomicValue} from './as-atomic-value'
+
+describe('asAtomicValue', () => {
+  it.each`
+    input             | expected
+    ${BigInt('1000')} | ${'1000'}
+    ${'1000'}         | ${'1000'}
+    ${1000}           | ${'1000'}
+    ${-1000}          | ${'-1000'}
+    ${1e3}            | ${'1000'}
+    ${1000n}          | ${'1000'}
+    ${1000e-3}        | ${'1'}
+    ${false}          | ${'0'}
+    ${true}           | ${'1'}
+  `(
+    'should convert accepted types to Portfolio.Quantity',
+    ({input, expected}) => {
+      expect(asAtomicValue(input)).toBe(expected)
+    },
+  )
+
+  it.each`
+    input
+    ${NaN}
+    ${-1.1}
+    ${1.1}
+    ${Infinity}
+    ${-Infinity}
+  `('should throw an error for invalid input %s', ({input}) => {
+    expect(() => asAtomicValue(input)).toThrow(
+      Numbers.Errors.InvalidAtomicValue,
+    )
+  })
+})
diff --git a/packages/common/src/numbers/as-atomic-value.ts b/packages/common/src/numbers/as-atomic-value.ts
new file mode 100644
index 0000000000..b53dd29a02
--- /dev/null
+++ b/packages/common/src/numbers/as-atomic-value.ts
@@ -0,0 +1,9 @@
+import {Numbers} from '@yoroi/types'
+
+export const asAtomicValue = (value: bigint | number | string | boolean) => {
+  try {
+    return BigInt(value).toString(10) as Numbers.AtomicValue
+  } catch (_) {
+    throw new Numbers.Errors.InvalidAtomicValue()
+  }
+}
diff --git a/packages/common/src/observer/observer.test.ts b/packages/common/src/observer/observer.test.ts
index 8b37bd2d5e..d827848aa6 100644
--- a/packages/common/src/observer/observer.test.ts
+++ b/packages/common/src/observer/observer.test.ts
@@ -1,10 +1,11 @@
 import {App} from '@yoroi/types'
+
 import {observerMaker} from './observer'
 
 describe('Observer', () => {
-  let observer: App.Observer<number>
-  let mockSubscriber1: jest.Mock
-  let mockSubscriber2: jest.Mock
+  let observer: App.ObserverManager<number>
+  let mockSubscriber1: App.Subscriber<number>
+  let mockSubscriber2: App.Subscriber<number>
 
   beforeEach(() => {
     observer = observerMaker<number>()
@@ -19,34 +20,32 @@ describe('Observer', () => {
   })
 
   it('should allow multiple subscribers to subscribe', () => {
-    const unsubscribe1 = observer.subscribe(mockSubscriber1)
-    const unsubscribe2 = observer.subscribe(mockSubscriber2)
+    const client1 = observer.subscribe(mockSubscriber1)
+    const client2 = observer.subscribe(mockSubscriber2)
     observer.notify(42)
     expect(mockSubscriber1).toHaveBeenCalledWith(42)
     expect(mockSubscriber2).toHaveBeenCalledWith(42)
-    unsubscribe1()
-    unsubscribe2()
+    client1.unsubscribe()
+    client2.unsubscribe()
   })
 
   it('should allow subscribers to unsubscribe', () => {
-    observer.subscribe(mockSubscriber1)
-    observer.unsubscribe(mockSubscriber1)
-    observer.notify(42)
-    expect(mockSubscriber1).not.toHaveBeenCalled()
-    const unsubscribe = observer.subscribe(mockSubscriber1)
-    unsubscribe()
+    const client1 = observer.subscribe(mockSubscriber1)
+    client1.unsubscribe()
     observer.notify(42)
     expect(mockSubscriber1).not.toHaveBeenCalled()
   })
 
   it('should allow destroying all subscriptions', () => {
-    const unsubscribe1 = observer.subscribe(mockSubscriber1)
-    const unsubscribe2 = observer.subscribe(mockSubscriber2)
+    const client1 = observer.subscribe(mockSubscriber1)
+    observer.subscribe(mockSubscriber2)
+    observer.unsubscribe(client1)
+    observer.notify(42)
+    expect(mockSubscriber2).toHaveBeenCalledWith(42)
+    expect(mockSubscriber1).not.toHaveBeenCalled()
     observer.destroy()
     observer.notify(42)
     expect(mockSubscriber1).not.toHaveBeenCalled()
-    expect(mockSubscriber2).not.toHaveBeenCalled()
-    unsubscribe1()
-    unsubscribe2()
+    expect(mockSubscriber2).toHaveBeenCalledTimes(1)
   })
 })
diff --git a/packages/common/src/observer/observer.ts b/packages/common/src/observer/observer.ts
index c1d5cc79f6..f42a724672 100644
--- a/packages/common/src/observer/observer.ts
+++ b/packages/common/src/observer/observer.ts
@@ -1,23 +1,23 @@
 import {App} from '@yoroi/types'
+import {freeze} from 'immer'
+import {Subject, Subscription} from 'rxjs'
 
-export const observerMaker = <T>(): App.Observer<T> => {
-  const subscribers: Set<App.Subscriber<T>> = new Set()
+export const observerMaker = <T>(): App.ObserverManager<T> => {
+  const eventSubject = new Subject<T>()
 
-  return {
-    subscribe: (callback: App.Subscriber<T>) => {
-      subscribers.add(callback)
-      return () => {
-        subscribers.delete(callback)
-      }
+  return freeze({
+    subscribe: (observer: App.Subscriber<T>): Subscription => {
+      return eventSubject.subscribe(observer)
     },
-    unsubscribe(subscriber: App.Subscriber<T>) {
-      subscribers.delete(subscriber)
+    unsubscribe: (subscription: Subscription) => {
+      subscription.unsubscribe()
     },
-    notify: (data: T) => {
-      subscribers.forEach((callback) => callback(data))
+    notify: (value: T) => {
+      eventSubject.next(value)
     },
     destroy: () => {
-      subscribers.clear()
+      eventSubject.complete()
     },
-  } as const
+    observable: eventSubject.asObservable(),
+  })
 }
diff --git a/packages/common/src/queue/queue-task.test.ts b/packages/common/src/queue/queue-task.test.ts
new file mode 100644
index 0000000000..c6cf7fac34
--- /dev/null
+++ b/packages/common/src/queue/queue-task.test.ts
@@ -0,0 +1,38 @@
+import {queueTaskMaker} from './queue-task'
+
+describe('queueTaskMaker', () => {
+  it('should enqueue and execute tasks in order', async () => {
+    const queue = queueTaskMaker()
+
+    const task1 = jest.fn().mockResolvedValue(undefined)
+    const task2 = jest.fn().mockResolvedValue(undefined)
+    const task3 = jest.fn().mockResolvedValue(undefined)
+
+    queue.enqueue(task1)
+    queue.enqueue(task2)
+    queue.enqueue(task3)
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    expect(task1).toHaveBeenCalledTimes(1)
+    expect(task2).toHaveBeenCalledTimes(1)
+    expect(task3).toHaveBeenCalledTimes(1)
+  })
+
+  it('should destroy the queue and stop executing tasks', async () => {
+    const queue = queueTaskMaker()
+
+    const task1 = jest.fn().mockResolvedValue(undefined)
+    const task2 = jest.fn().mockResolvedValue(undefined)
+
+    queue.destroy()
+
+    queue.enqueue(task1)
+    queue.enqueue(task2)
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    expect(task1).not.toHaveBeenCalled()
+    expect(task2).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/common/src/queue/queue-task.ts b/packages/common/src/queue/queue-task.ts
new file mode 100644
index 0000000000..297d2bd87e
--- /dev/null
+++ b/packages/common/src/queue/queue-task.ts
@@ -0,0 +1,23 @@
+import {App} from '@yoroi/types'
+import {freeze} from 'immer'
+import {Subject} from 'rxjs'
+import {concatMap} from 'rxjs/operators'
+
+export const queueTaskMaker = (): App.QueueTaskManager => {
+  const queueSubject = new Subject<App.QueueTask>()
+
+  const subscription = queueSubject
+    .pipe(concatMap((task) => task()))
+    .subscribe()
+
+  const enqueue = (task: App.QueueTask) => {
+    queueSubject.next(task)
+  }
+
+  const destroy = () => {
+    subscription.unsubscribe()
+    queueSubject.complete()
+  }
+
+  return freeze({enqueue, destroy}, true)
+}
diff --git a/packages/common/src/storage/adapters/async-storage.test.ts b/packages/common/src/storage/adapters/async-storage.test.ts
index 20fe854074..9129272fde 100644
--- a/packages/common/src/storage/adapters/async-storage.test.ts
+++ b/packages/common/src/storage/adapters/async-storage.test.ts
@@ -2,14 +2,14 @@
 import AsyncStorage from '@react-native-async-storage/async-storage'
 import {App} from '@yoroi/types'
 
-import {parseSafe} from '../../helpers/parsers'
+import {parseSafe} from '../../utils/parsers'
 import {mountAsyncMultiStorage, mountAsyncStorage} from './async-storage'
 
 describe('prefixed storage', () => {
   beforeEach(() => AsyncStorage.clear())
 
   it('getAllKeys, setItem, getItem, removeItem, clear', async () => {
-    const storage = mountAsyncStorage('/')
+    const storage = mountAsyncStorage({path: '/'})
     await storage
       .getAllKeys()
       .then((keys: ReadonlyArray<string>) => expect(keys).toEqual([]))
@@ -30,7 +30,7 @@ describe('prefixed storage', () => {
   })
 
   it('getAllKeys, setItem, getItem, removeItem, clear, with prefix', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
     const storage = rootStorage.join('prefix/')
     expect(await storage.getAllKeys()).toEqual([])
 
@@ -50,10 +50,10 @@ describe('prefixed storage', () => {
   })
 
   it('getAllKeys, multiSet, multiGet, multiRemove', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
     const storage = rootStorage.join('prefix/')
 
-    await storage.multiSet([
+    await storage.multiSet<any>([
       ['item1', item1],
       ['item2', item2],
     ])
@@ -79,7 +79,7 @@ describe('prefixed storage', () => {
   })
 
   it('getAllKeys', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
 
     const storage1 = rootStorage.join('prefix/1/')
     expect(await storage1.getAllKeys()).toEqual([])
@@ -101,7 +101,7 @@ describe('prefixed storage', () => {
   })
 
   it('join', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
 
     const root = rootStorage.join('/')
     await root.setItem('key1', item1)
@@ -128,7 +128,7 @@ describe('prefixed storage', () => {
 
   describe('stringify/parse', () => {
     it('getItem, setItem', async () => {
-      const storage = mountAsyncStorage('/')
+      const storage = mountAsyncStorage({path: '/'})
       const item = 'text'
       const storedItem = 'item123'
 
@@ -146,7 +146,7 @@ describe('prefixed storage', () => {
     })
 
     it('multiGet, multiSet', async () => {
-      const storage = mountAsyncStorage('/')
+      const storage = mountAsyncStorage({path: '/'})
       const item1 = 'item1'
       const storedItem1 = `${item1}-modified`
       const item2 = 'item2'
@@ -156,7 +156,7 @@ describe('prefixed storage', () => {
         ['item2', item2],
       ]
 
-      await storage.multiSet(tuples, (data: unknown) => {
+      await storage.multiSet<any>(tuples, (data: unknown) => {
         expect([item1, item2]).toContain(data)
         return `${data}-modified`
       }) // overrides JSON.stringify
@@ -174,7 +174,7 @@ describe('prefixed storage', () => {
   })
 
   it('clears sub-storage', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
     const storage1 = rootStorage.join('1/')
     const storage2 = storage1.join('2/')
     const storage3 = storage2.join('3/')
@@ -207,7 +207,7 @@ describe('prefixed storage', () => {
   })
 
   it('removeFolder', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
     const storage1 = rootStorage.join('1/')
     const storage2 = storage1.join('2/')
     const storage3 = storage2.join('3/')
@@ -273,7 +273,7 @@ describe('multi storage', () => {
     expect(emptyKeys).toEqual([])
   })
   it('saveMany, readAll, readMany, keys, and clear default serializers / key as extractor', async () => {
-    const rootStorage = mountAsyncStorage('/')
+    const rootStorage = mountAsyncStorage({path: '/'})
     const storage = mountAsyncMultiStorage({
       storage: rootStorage.join('multiStorage/'),
       dataFolder: 'dataFolder/',
@@ -303,7 +303,7 @@ describe('multi storage', () => {
 })
 
 const options: App.MultiStorageOptions<any> = {
-  storage: mountAsyncStorage('/').join('multiStorage/'),
+  storage: mountAsyncStorage({path: '/'}).join('multiStorage/'),
   dataFolder: 'dataFolder/',
   keyExtractor: (item: any) => item.id,
   serializer: JSON.stringify,
diff --git a/packages/common/src/storage/adapters/async-storage.ts b/packages/common/src/storage/adapters/async-storage.ts
index 0491f9e9dc..bc01cd76fa 100644
--- a/packages/common/src/storage/adapters/async-storage.ts
+++ b/packages/common/src/storage/adapters/async-storage.ts
@@ -1,13 +1,15 @@
 import AsyncStorage from '@react-native-async-storage/async-storage'
-import {App, Nullable} from '@yoroi/types'
+import {App} from '@yoroi/types'
 
-import {parseSafe} from '../../helpers/parsers'
+import {parseSafe} from '../../utils/parsers'
 import {isFolderKey} from '../helpers/is-folder-key'
 import {isFileKey} from '../helpers/is-file-key'
 
-// -------
-// FACTORY
-export const mountAsyncStorage = (path: App.StorageFolderName): App.Storage => {
+export const mountAsyncStorage = ({
+  path,
+}: {
+  path: App.StorageFolderName
+}): App.Storage => {
   const withPath = (key: string) =>
     `${path}${key}` as `${App.StorageFolderName}${string}`
   const withoutPath = (value: string) => value.slice(path.length)
@@ -39,7 +41,7 @@ export const mountAsyncStorage = (path: App.StorageFolderName): App.Storage => {
 
   return {
     join: (folderName: App.StorageFolderName) =>
-      mountAsyncStorage(`${path}${folderName}`),
+      mountAsyncStorage({path: `${path}${folderName}`}),
 
     getItem,
     multiGet,
@@ -51,9 +53,9 @@ export const mountAsyncStorage = (path: App.StorageFolderName): App.Storage => {
       const item = stringify(value)
       await AsyncStorage.setItem(withPath(key), item)
     },
-    multiSet: async (
-      tuples: ReadonlyArray<[key: string, value: unknown]>,
-      stringify: (data: unknown) => string = JSON.stringify,
+    multiSet: async <T = unknown>(
+      tuples: ReadonlyArray<[key: string, value: T]>,
+      stringify: (data: T) => string = JSON.stringify,
     ) => {
       const items: Array<[string, string]> = tuples.map(([key, value]) => [
         withPath(key),
@@ -83,7 +85,10 @@ export const mountAsyncStorage = (path: App.StorageFolderName): App.Storage => {
         .then((keys) =>
           keys.filter((key) => key.startsWith(path) && isFileKey({key, path})),
         )
-        .then((filteredKeys) => filteredKeys.map(withoutPath))
+        .then(
+          // temporary any until async interface is migrated to receive keys for multi storage
+          (filteredKeys) => filteredKeys.map(withoutPath) as ReadonlyArray<any>,
+        )
     },
     clear: async () => {
       const keys = await AsyncStorage.getAllKeys()
@@ -102,7 +107,7 @@ export const mountAsyncMultiStorage = <T = unknown>(
     dataFolder,
     keyExtractor,
     serializer = JSON.stringify,
-    deserializer = parseSafe as (item: string | null) => Nullable<T>,
+    deserializer = parseSafe as (item: string | null) => T | null,
   } = options
   const dataStorage = storage.join(dataFolder)
   const {getAllKeys: getAllKeysStorage, multiSet, multiGet} = dataStorage
@@ -120,10 +125,10 @@ export const mountAsyncMultiStorage = <T = unknown>(
   }
   const readAll = () =>
     getAllKeys().then((keysToRead) =>
-      multiGet<Nullable<T>>(keysToRead, deserializer),
+      multiGet<T | null>(keysToRead, deserializer),
     )
   const readMany = (keysToRead: ReadonlyArray<string>) =>
-    dataStorage.multiGet<Nullable<T>>(keysToRead, deserializer)
+    dataStorage.multiGet<T | null>(keysToRead, deserializer)
   const removeMany = (keysToRead: ReadonlyArray<string>) =>
     dataStorage.multiRemove(keysToRead)
   const getAllKeys = () => getAllKeysStorage().then((keys) => keys)
diff --git a/packages/common/src/storage/adapters/mmkv-storage.test.ts b/packages/common/src/storage/adapters/mmkv-storage.test.ts
index ea671f8915..ac5b8e1d6e 100644
--- a/packages/common/src/storage/adapters/mmkv-storage.test.ts
+++ b/packages/common/src/storage/adapters/mmkv-storage.test.ts
@@ -1,17 +1,20 @@
 import {App} from '@yoroi/types'
 
-import {parseSafe} from '../../helpers/parsers'
+import {parseSafe} from '../../utils/parsers'
 import {mountMMKVMultiStorage, mountMMKVStorage} from './mmkv-storage'
 import {MMKV} from 'react-native-mmkv'
 
 const mmkv = new MMKV({id: 'default.mmkv'})
-const rootStorage = mountMMKVStorage('/', 'default.mmkv', mmkv)
+const rootStorage = mountMMKVStorage(
+  {path: '/', id: 'default.mmkv'},
+  {instance: mmkv},
+)
 
 describe('prefixed storage', () => {
   beforeEach(() => rootStorage.clear())
 
   it('getAllKeys, setItem, getItem, removeItem, clear', async () => {
-    const storage = mountMMKVStorage('/')
+    const storage = mountMMKVStorage({path: '/'})
     expect(storage.getAllKeys()).toEqual([])
 
     storage.setItem('item1', item1)
@@ -51,7 +54,7 @@ describe('prefixed storage', () => {
   it('getAllKeys, multiSet, multiGet, multiRemove', async () => {
     const storage = rootStorage.join('prefix/')
 
-    storage.multiSet([
+    storage.multiSet<any>([
       ['item1', item1],
       ['item2', item2],
     ])
@@ -290,7 +293,7 @@ describe('multi storage', () => {
 })
 
 const options: App.MultiStorageOptions<any, false> = {
-  storage: mountMMKVStorage('/').join('multiStorage/'),
+  storage: mountMMKVStorage({path: '/'}).join('multiStorage/'),
   dataFolder: 'dataFolder/',
   keyExtractor: (item: any) => item.id,
   serializer: JSON.stringify,
diff --git a/packages/common/src/storage/adapters/mmkv-storage.ts b/packages/common/src/storage/adapters/mmkv-storage.ts
index 982b534ff2..c83964f4a0 100644
--- a/packages/common/src/storage/adapters/mmkv-storage.ts
+++ b/packages/common/src/storage/adapters/mmkv-storage.ts
@@ -1,17 +1,22 @@
 import {MMKV} from 'react-native-mmkv'
-import {App, Nullable} from '@yoroi/types'
+import {App} from '@yoroi/types'
 
-import {parseSafe} from '../../helpers/parsers'
+import {parseSafe} from '../../utils/parsers'
 import {isFolderKey} from '../helpers/is-folder-key'
 import {isFileKey} from '../helpers/is-file-key'
 
 // -------
 // FACTORY
-export const mountMMKVStorage = (
-  path: App.StorageFolderName,
-  id: string = 'default.mmkv',
-  instance?: MMKV,
-): App.Storage<false> => {
+export const mountMMKVStorage = <Key extends string = string>(
+  {
+    path,
+    id = 'default.mmkv',
+  }: {
+    path: App.StorageFolderName
+    id?: string
+  },
+  {instance}: {instance?: MMKV} = {},
+): App.Storage<false, Key> => {
   // mmkv uses id as file and the path is irrelevant if sharing content amongst app (iOS)
   // therefore the client needs to know all the ids to delete all data
   // which means that it works differently than AsyncStorage
@@ -20,66 +25,78 @@ export const mountMMKVStorage = (
 
   const withPath = (key: string) =>
     `${path}${key}` as `${App.StorageFolderName}${string}`
-  const withoutPath = (absolutePath: string) => absolutePath.slice(path.length)
+  const withoutPath = <K extends string = Key>(absolutePath: string): K =>
+    absolutePath.slice(path.length) as K
 
   function join(folderToJoin: App.StorageFolderName) {
-    return mountMMKVStorage(`${path}${folderToJoin}`, id, storage)
+    return mountMMKVStorage<Key>(
+      {path: `${path}${folderToJoin}`, id},
+      {instance: storage},
+    )
   }
 
-  function getItem<T>(key: string, parse: (item: string | null) => T): T
-  function getItem<T = unknown>(key: string): T
-  function getItem(key: string, parse = parseSafe) {
+  function getItem<T, K extends string = Key>(
+    key: K,
+    deserializer: (item: string | null) => T | null,
+  ): T | null
+  function getItem<T = unknown, K extends string = Key>(key: K): T | null
+  function getItem<K extends string = Key>(key: K, deserializer = parseSafe) {
     const item = storage.getString(withPath(key)) ?? null
-    return parse(item)
+    return deserializer(item)
   }
 
-  function multiGet<T>(
-    keys: ReadonlyArray<string>,
-    parse: (item: string | null) => T,
-  ): ReadonlyArray<[string, T]>
-  function multiGet<T = unknown>(
-    keys: ReadonlyArray<string>,
-  ): ReadonlyArray<[string, T]>
-  function multiGet(keys: ReadonlyArray<string>, parse = parseSafe) {
+  function multiGet<T, K extends string = Key>(
+    keys: ReadonlyArray<K>,
+    deserializer: (item: string | null) => T | null,
+  ): ReadonlyArray<[K, T | null]>
+  function multiGet<T = unknown, K extends string = Key>(
+    keys: ReadonlyArray<K>,
+  ): ReadonlyArray<[K, T | null]>
+  function multiGet<K extends string = Key>(
+    keys: ReadonlyArray<K>,
+    deserializer = parseSafe,
+  ) {
     const absolutePaths = keys.map((key) => withPath(key))
     return Object.freeze(
       absolutePaths.map((key) => [
-        withoutPath(key),
-        parse(storage.getString(key) ?? null),
+        withoutPath<K>(key),
+        deserializer(storage.getString(key) ?? null),
       ]),
     )
   }
 
-  function setItem<T = unknown>(key: string, value: T): void
-  function setItem<T = unknown>(
-    key: string,
+  function setItem<T = unknown, K extends string = Key>(key: K, value: T): void
+  function setItem<T = unknown, K extends string = Key>(
+    key: K,
     value: T,
-    stringify: (data: T) => string,
+    serializer: (data: T) => string,
   ): void
-  function setItem<T = unknown>(
-    key: string,
+  function setItem<T = unknown, K extends string = Key>(
+    key: K,
     value: T,
-    stringify: (data: T) => string = JSON.stringify,
+    serializer: (data: T) => string = JSON.stringify,
   ) {
-    const item = stringify(value)
+    const item = serializer(value)
     storage.set(withPath(key), item)
   }
 
-  function multiSet(tuples: ReadonlyArray<[key: string, value: unknown]>): void
-  function multiSet(
-    tuples: ReadonlyArray<[key: string, value: unknown]>,
-    stringify: (data: unknown) => string,
+  function multiSet<T = unknown, K extends string = Key>(
+    tuples: ReadonlyArray<[key: K, value: T]>,
   ): void
-  function multiSet(
-    tuples: ReadonlyArray<[key: string, value: unknown]>,
-    stringify: (data: unknown) => string = JSON.stringify,
+  function multiSet<T = unknown, K extends string = Key>(
+    tuples: ReadonlyArray<[key: K, value: T]>,
+    serializer: (data: T) => string,
+  ): void
+  function multiSet<T = unknown, K extends string = Key>(
+    tuples: ReadonlyArray<[key: K, value: T]>,
+    serializer: (data: T) => string = JSON.stringify,
   ) {
     tuples.forEach(([key, value]) =>
-      storage.set(withPath(key), stringify(value)),
+      storage.set(withPath(key), serializer(value)),
     )
   }
 
-  function removeItem(key: string) {
+  function removeItem<K extends string = Key>(key: K) {
     storage.delete(withPath(key))
   }
 
@@ -94,17 +111,17 @@ export const mountMMKVStorage = (
     filteredKeys.forEach((key) => storage.delete(key))
   }
 
-  function multiRemove(keys: ReadonlyArray<string>) {
+  function multiRemove<K extends string = Key>(keys: ReadonlyArray<K>) {
     const absolutePaths = keys.map((key) => withPath(key))
     absolutePaths.forEach((key) => storage.delete(key))
   }
 
-  function getAllKeys() {
+  function getAllKeys<K extends string = Key>() {
     return Object.freeze(
       storage
         .getAllKeys()
         .filter((key) => key.startsWith(path) && isFileKey({key, path}))
-        .map(withoutPath),
+        .map(withoutPath<K>),
     )
   }
 
@@ -128,36 +145,33 @@ export const mountMMKVStorage = (
     clear,
   } as const
 }
-
-export const mountMMKVMultiStorage = <T = unknown>(
-  options: App.MultiStorageOptions<T, false>,
-): Readonly<App.MultiStorage<T, false>> => {
+export const mountMMKVMultiStorage = <T = unknown, K extends string = string>(
+  options: App.MultiStorageOptions<T, false, K>,
+): Readonly<App.MultiStorage<T, false, K>> => {
   const {
     storage,
     dataFolder,
     keyExtractor,
     serializer = JSON.stringify,
-    deserializer = parseSafe as (item: string | null) => Nullable<T>,
+    deserializer = parseSafe as (item: unknown) => T | null,
   } = options
   const dataStorage = storage.join(dataFolder)
   const {getAllKeys, multiSet, multiGet} = dataStorage
 
   const clear = () => storage.removeFolder(dataFolder)
   const saveMany = (items: ReadonlyArray<NonNullable<T>>) => {
-    const entries: [string, T][] = items.map((item) => {
+    const entries: [K, T][] = items.map((item) => {
       if (typeof keyExtractor === 'function') {
-        return [keyExtractor(item), item]
+        return [keyExtractor(item) as K, item]
       }
-      return [String(item[keyExtractor]), item]
+      return [String(item[keyExtractor]) as K, item]
     })
     const entriesWithKeys = entries.filter(([key]) => key != null && key !== '')
     return multiSet(entriesWithKeys, serializer as (item: unknown) => string)
   }
-  const readAll = () => multiGet<Nullable<T>>(getAllKeys(), deserializer)
-  const readMany = (keys: ReadonlyArray<string>) =>
-    multiGet<Nullable<T>>(keys, deserializer)
-  const removeMany = (keys: ReadonlyArray<string>) =>
-    dataStorage.multiRemove(keys)
+  const readAll = () => multiGet(getAllKeys(), deserializer)
+  const readMany = (keys: ReadonlyArray<K>) => multiGet(keys, deserializer)
+  const removeMany = (keys: ReadonlyArray<K>) => dataStorage.multiRemove(keys)
 
   return {
     getAllKeys,
diff --git a/packages/common/src/storage/adapters/observable-storage.test.ts b/packages/common/src/storage/adapters/observable-storage.test.ts
index 46fa9ead2f..b4e04ccf6d 100644
--- a/packages/common/src/storage/adapters/observable-storage.test.ts
+++ b/packages/common/src/storage/adapters/observable-storage.test.ts
@@ -24,7 +24,7 @@ describe('observableStorageMaker', () => {
 
     const observableStorage = observableStorageMaker(storage)
 
-    const unsubscribe = observableStorage.onUpdate(
+    const client1 = observableStorage.onChange(
       ['key1', 'key2'],
       observerCallback,
     )
@@ -44,7 +44,7 @@ describe('observableStorageMaker', () => {
       ['key4', 'value4'],
     ])
 
-    unsubscribe()
+    client1.unsubscribe()
     expect(storage.clear).toHaveBeenCalled()
     expect(storage.setItem).toHaveBeenCalledWith('key1', 'value1')
     expect(storage.multiRemove).toHaveBeenCalledWith(['key1', 'key2'])
@@ -67,7 +67,7 @@ describe('observableStorageMaker', () => {
 
     const observableStorage = observableStorageMaker(storage)
 
-    const unsubscribe = observableStorage.onUpdate(
+    const client1 = observableStorage.onChange(
       ['key1', 'key2'],
       observerCallback,
     )
@@ -87,7 +87,7 @@ describe('observableStorageMaker', () => {
       ['key4', 'value4'],
     ])
 
-    unsubscribe()
+    client1.unsubscribe()
     expect(storage.clear).toHaveBeenCalled()
     expect(storage.setItem).toHaveBeenCalledWith('key1', 'value1')
     expect(storage.multiRemove).toHaveBeenCalledWith(['key1', 'key2'])
@@ -114,7 +114,7 @@ describe('observableMultiStorageMaker', () => {
 
     const observableStorage = observableMultiStorageMaker(storage)
 
-    const unsubscribe = observableStorage.onUpdate(observerCallback)
+    const client1 = observableStorage.onChange(observerCallback)
 
     observableStorage.clear()
     expect(observerCallback).toHaveBeenCalledWith(null)
@@ -122,7 +122,7 @@ describe('observableMultiStorageMaker', () => {
     observableStorage.saveMany([{id: 'key1', value: 'value1'}])
     expect(observerCallback).toHaveBeenCalledWith(null)
 
-    unsubscribe()
+    client1.unsubscribe()
     expect(storage.clear).toHaveBeenCalled()
     expect(storage.saveMany).toHaveBeenCalledWith([
       {id: 'key1', value: 'value1'},
@@ -142,7 +142,7 @@ describe('observableMultiStorageMaker', () => {
 
     const observableStorage = observableMultiStorageMaker(storage)
 
-    const unsubscribe = observableStorage.onUpdate(observerCallback)
+    const client1 = observableStorage.onChange(observerCallback)
 
     await observableStorage.clear()
     expect(observerCallback).toHaveBeenCalledWith(null)
@@ -150,7 +150,7 @@ describe('observableMultiStorageMaker', () => {
     await observableStorage.saveMany([{id: 'key1', value: 'value1'}])
     expect(observerCallback).toHaveBeenCalledWith(null)
 
-    unsubscribe()
+    client1.unsubscribe()
     expect(storage.clear).toHaveBeenCalled()
     expect(storage.saveMany).toHaveBeenCalledWith([
       {id: 'key1', value: 'value1'},
diff --git a/packages/common/src/storage/adapters/observable-storage.ts b/packages/common/src/storage/adapters/observable-storage.ts
index 961a1999ae..9e7d25f0f0 100644
--- a/packages/common/src/storage/adapters/observable-storage.ts
+++ b/packages/common/src/storage/adapters/observable-storage.ts
@@ -1,12 +1,16 @@
 import {App} from '@yoroi/types'
+
 import {observerMaker} from '../../observer/observer'
-import {isString} from '../../helpers/parsers'
-import {intersection} from '../../helpers/arrays'
+import {isString} from '../../utils/parsers'
+import {intersection} from '../../utils/arrays'
 
-export const observableStorageMaker = <IsAsync extends boolean>(
-  storage: App.Storage<IsAsync>,
-): App.ObservableStorage<IsAsync> => {
-  const triggers: Array<keyof App.Storage<IsAsync>> = [
+export const observableStorageMaker = <
+  IsAsync extends boolean,
+  K extends string,
+>(
+  storage: App.Storage<IsAsync, K>,
+): App.ObservableStorage<IsAsync, K> => {
+  const triggers: Array<keyof App.Storage<IsAsync, K>> = [
     'clear',
     // 'removeFolder', can be added later as long the key checks for "/" in the arg when string
     'multiSet',
@@ -14,13 +18,13 @@ export const observableStorageMaker = <IsAsync extends boolean>(
     'multiRemove',
     'removeItem',
   ]
-  const observable = observerMaker<string[] | null>()
+  const observable = observerMaker<K[] | null>()
 
-  const onUpdate = (
-    keysToObserve: ReadonlyArray<string>,
-    callback: (keysAnnounced: ReadonlyArray<string> | null) => void,
+  const onChange = (
+    keysToObserve: ReadonlyArray<K>,
+    callback: (keysAnnounced: ReadonlyArray<K> | null) => void,
   ) => {
-    const wrappedCallback = (keysUpdated: string[] | null) => {
+    const wrappedCallback = (keysUpdated: K[] | null) => {
       if (!keysUpdated) {
         callback(null)
       } else {
@@ -33,8 +37,8 @@ export const observableStorageMaker = <IsAsync extends boolean>(
 
   const proxyHandler = {
     get(
-      target: App.Storage<IsAsync>,
-      property: keyof App.Storage<IsAsync>,
+      target: App.Storage<IsAsync, K>,
+      property: keyof App.Storage<IsAsync, K>,
       receiver: any,
     ) {
       const origProperty = target[property]
@@ -44,12 +48,12 @@ export const observableStorageMaker = <IsAsync extends boolean>(
           const notify = () => {
             const [firstArg] = args
             const isArray = Array.isArray(firstArg)
-            if (isString(firstArg)) {
+            if (isString(firstArg as K)) {
               // single operations
               observable.notify([firstArg])
             } else if (isArray) {
               // multi operations
-              const keys = firstArg as string[]
+              const keys = firstArg as K[]
               observable.notify(keys)
             } else {
               // clear
@@ -77,27 +81,34 @@ export const observableStorageMaker = <IsAsync extends boolean>(
     },
   }
 
-  const proxiedStorage: App.Storage<IsAsync> = new Proxy(storage, proxyHandler)
+  const proxiedStorage: App.Storage<IsAsync, K> = new Proxy(
+    storage,
+    proxyHandler,
+  )
   return {
     ...proxiedStorage,
-    onUpdate,
+    onChange,
   } as const
 }
 
-export const observableMultiStorageMaker = <T, IsAsync extends boolean>(
-  storage: App.MultiStorage<T, IsAsync>,
-): App.ObservableMultiStorage<T, IsAsync> => {
-  const triggers: Array<keyof App.MultiStorage<T, IsAsync>> = [
+export const observableMultiStorageMaker = <
+  T,
+  IsAsync extends boolean = true,
+  K extends string = string,
+>(
+  storage: App.MultiStorage<T, IsAsync, K>,
+): App.ObservableMultiStorage<T, IsAsync, K> => {
+  const triggers: Array<keyof App.MultiStorage<T, IsAsync, K>> = [
     'clear',
     'saveMany',
   ]
   const observable = observerMaker<null>()
-  const onUpdate = (callback: () => void) => observable.subscribe(callback)
+  const onChange = (callback: () => void) => observable.subscribe(callback)
 
   const proxyHandler = {
     get(
-      target: App.MultiStorage<T, IsAsync>,
-      property: keyof App.MultiStorage<T, IsAsync>,
+      target: App.MultiStorage<T, IsAsync, K>,
+      property: keyof App.MultiStorage<T, IsAsync, K>,
       receiver: any,
     ) {
       const origProperty = target[property]
@@ -125,12 +136,12 @@ export const observableMultiStorageMaker = <T, IsAsync extends boolean>(
     },
   }
 
-  const proxiedStorage: App.MultiStorage<T, IsAsync> = new Proxy(
+  const proxiedStorage: App.MultiStorage<T, IsAsync, K> = new Proxy(
     storage,
     proxyHandler,
   )
   return {
     ...proxiedStorage,
-    onUpdate,
+    onChange,
   } as const
 }
diff --git a/packages/common/src/storage/helpers/storage-deserializer-maker.test.ts b/packages/common/src/storage/helpers/storage-deserializer-maker.test.ts
new file mode 100644
index 0000000000..64f55dd00d
--- /dev/null
+++ b/packages/common/src/storage/helpers/storage-deserializer-maker.test.ts
@@ -0,0 +1,62 @@
+import BigNumber from 'bignumber.js'
+
+import {
+  StorageReviverType,
+  storageDeserializerMaker,
+} from './storage-deserializer-maker'
+
+describe('storageDeserializerMaker', () => {
+  const mapping = {
+    age: StorageReviverType.AsBigInt,
+    balance: StorageReviverType.AsBigNumber,
+  }
+  const deserializer = storageDeserializerMaker(mapping)
+
+  it('should parse JSON string and convert properties', () => {
+    const whatever = JSON.stringify({
+      name: 'John',
+      age: '25',
+      balance: '100',
+      nested: {
+        balance: '111',
+        age: '10',
+        data: [{age: '1'}],
+        nullable: {
+          balance: null,
+          age: null,
+        },
+      },
+    })
+
+    const result = deserializer(whatever)
+
+    expect(result).toEqual({
+      name: 'John',
+      age: 25n,
+      balance: new BigNumber('100'),
+      nested: {
+        balance: new BigNumber('111'),
+        age: 10n,
+        data: [{age: 1n}],
+        nullable: {
+          balance: null,
+          age: null,
+        },
+      },
+    })
+  })
+
+  it('should return null if jsonString is null', () => {
+    const nullable = JSON.stringify(null)
+    const empty = undefined
+    const invalid = '{x:'
+
+    const nullResult = storageDeserializerMaker(mapping)(nullable)
+    const emptyResult = storageDeserializerMaker(mapping)(empty as any)
+    const invalidResult = storageDeserializerMaker(mapping)(invalid as any)
+
+    expect(nullResult).toBeNull()
+    expect(emptyResult).toBeNull()
+    expect(invalidResult).toBeNull()
+  })
+})
diff --git a/packages/common/src/storage/helpers/storage-deserializer-maker.ts b/packages/common/src/storage/helpers/storage-deserializer-maker.ts
new file mode 100644
index 0000000000..d4cca0421c
--- /dev/null
+++ b/packages/common/src/storage/helpers/storage-deserializer-maker.ts
@@ -0,0 +1,58 @@
+import BigNumber from 'bignumber.js'
+import {isRecord} from '../../utils/parsers'
+
+export enum StorageReviverType {
+  AsBigInt = 'AsBigInt',
+  AsBigNumber = 'AsBigNumber',
+}
+
+export type StorageReviverMapping = {
+  [key: string]: StorageReviverType
+}
+
+/**
+ * Creates a storage deserializer function based on the provided mapping.
+ * Since BigInt and BigNumber are not supported by JSON.parse, it stores as strings and revive as BigInt or BigNumber.
+ *
+ * @param mapping - The mapping of keys to reviver types.
+ * @returns JSON object revived according to the mapping, string -> BigInt or BigNumber.
+ */
+export const storageDeserializerMaker = (mapping: StorageReviverMapping) => {
+  const reviver = (key: string, value: any) => {
+    switch (mapping[key]) {
+      case StorageReviverType.AsBigInt:
+        return value == null ? value : BigInt(value)
+      case StorageReviverType.AsBigNumber:
+      default:
+        return value === null ? value : new BigNumber(value)
+    }
+  }
+
+  const convertProperties = (obj: unknown): unknown => {
+    if (Array.isArray(obj)) return obj.map((item) => convertProperties(item))
+
+    if (isRecord(obj)) {
+      Object.keys(obj).forEach((key) => {
+        obj[key] = convertProperties(obj[key])
+      })
+      return obj
+    }
+
+    return obj
+  }
+
+  return (jsonString: string | null) => {
+    if (jsonString == null) return null
+    try {
+      const parsed = JSON.parse(jsonString, (key, value) => {
+        if (key && mapping[key]) {
+          return reviver(key as any, value)
+        }
+        return value
+      })
+      return convertProperties(parsed)
+    } catch (e) {
+      return null
+    }
+  }
+}
diff --git a/packages/common/src/storage/helpers/storage-serializer.test.ts b/packages/common/src/storage/helpers/storage-serializer.test.ts
new file mode 100644
index 0000000000..be9fe86aa2
--- /dev/null
+++ b/packages/common/src/storage/helpers/storage-serializer.test.ts
@@ -0,0 +1,52 @@
+import BigNumber from 'bignumber.js'
+import {storageSerializer} from './storage-serializer'
+
+describe('storageSerializer', () => {
+  it('should stringify numbers correctly', () => {
+    const input = 123
+    const expected = '123'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+
+  it('should stringify strings correctly', () => {
+    const input = 'hello world'
+    const expected = '"hello world"'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+
+  it('should stringify objects correctly', () => {
+    const input = {name: 'John', age: 30}
+    const expected = '{"name":"John","age":30}'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+
+  it('should stringify arrays correctly', () => {
+    const input = {a: [1, 2n, 3]}
+    const expected = '{"a":[1,"2",3]}'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+
+  it('should stringify big numbers correctly', () => {
+    const input = new BigNumber('12345678901234567890')
+    const expected = '"12345678901234567890"'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+
+  it('should handle undefined correctly', () => {
+    const input = undefined
+    const result = storageSerializer(input)
+    expect(result).toBeUndefined()
+  })
+
+  it('should handle null correctly', () => {
+    const input = null
+    const expected = 'null'
+    const result = storageSerializer(input)
+    expect(result).toEqual(expected)
+  })
+})
diff --git a/packages/common/src/storage/helpers/storage-serializer.ts b/packages/common/src/storage/helpers/storage-serializer.ts
new file mode 100644
index 0000000000..c8983a1879
--- /dev/null
+++ b/packages/common/src/storage/helpers/storage-serializer.ts
@@ -0,0 +1,19 @@
+import BigNumber from 'bignumber.js'
+
+/**
+ * Serializes the given object into a JSON string, with support for BigInt and BigNumber values.
+ * Since BigInt and BigNumber are not supported by JSON.stringify, it serialize them as strings.
+ *
+ * @param toStringify - The object to be serialized.
+ * @returns A stringfied JSON object with BigInt and BigNumber values serialized as strings.
+ */
+export const storageSerializer = (toStringify: unknown) => {
+  const replacer = (_: unknown, value: unknown) => {
+    if (typeof value === 'bigint' || BigNumber.isBigNumber(value)) {
+      return value.toString()
+    }
+    return value
+  }
+
+  return JSON.stringify(toStringify, replacer)
+}
diff --git a/packages/common/src/storage/translators/async-storage-reactjs.test.tsx b/packages/common/src/storage/translators/async-storage-reactjs.test.tsx
index 5dd447c0d5..0e04abec8f 100644
--- a/packages/common/src/storage/translators/async-storage-reactjs.test.tsx
+++ b/packages/common/src/storage/translators/async-storage-reactjs.test.tsx
@@ -4,7 +4,7 @@ import renderer from 'react-test-renderer'
 import {AsyncStorageProvider, useAsyncStorage} from './async-storage-reactjs' // Update with the actual module path
 import {mountAsyncStorage} from '../adapters/async-storage'
 
-const rootStorage = mountAsyncStorage('/')
+const rootStorage = mountAsyncStorage({path: '/'})
 
 describe('AsyncStorageProvider and useAsyncStorage Tests', () => {
   test('AsyncStorageProvider provides storage context', () => {
diff --git a/packages/common/src/storage/translators/async-storage-reactjs.tsx b/packages/common/src/storage/translators/async-storage-reactjs.tsx
index b6b6bf7385..dace4aeb73 100644
--- a/packages/common/src/storage/translators/async-storage-reactjs.tsx
+++ b/packages/common/src/storage/translators/async-storage-reactjs.tsx
@@ -9,7 +9,7 @@ const AsyncStorageContext = React.createContext<undefined | App.Storage>(
 )
 export const AsyncStorageProvider = ({
   children,
-  storage = mountAsyncStorage('/'),
+  storage = mountAsyncStorage({path: '/'}),
 }: {
   storage?: App.Storage
   children: React.ReactNode
diff --git a/packages/common/src/storage/translators/sync-storage-reactjs.test.tsx b/packages/common/src/storage/translators/sync-storage-reactjs.test.tsx
index 4ca9beac6e..9186119e91 100644
--- a/packages/common/src/storage/translators/sync-storage-reactjs.test.tsx
+++ b/packages/common/src/storage/translators/sync-storage-reactjs.test.tsx
@@ -4,7 +4,7 @@ import renderer from 'react-test-renderer'
 import {SyncStorageProvider, useSyncStorage} from './sync-storage-reactjs' // Update with the actual module path
 import {mountMMKVStorage} from '../adapters/mmkv-storage'
 
-const rootStorage = mountMMKVStorage('/')
+const rootStorage = mountMMKVStorage({path: '/'})
 
 describe('SyncStorageProvider and useSyncStorage Tests', () => {
   test('SyncStorageProvider provides storage context', () => {
diff --git a/packages/common/src/storage/translators/sync-storage-reactjs.tsx b/packages/common/src/storage/translators/sync-storage-reactjs.tsx
index 1481b507d4..8f98219666 100644
--- a/packages/common/src/storage/translators/sync-storage-reactjs.tsx
+++ b/packages/common/src/storage/translators/sync-storage-reactjs.tsx
@@ -9,7 +9,7 @@ const SyncStorageContext = React.createContext<undefined | App.Storage<false>>(
 )
 export const SyncStorageProvider = ({
   children,
-  storage = mountMMKVStorage('/'),
+  storage = mountMMKVStorage({path: '/'}),
 }: {
   storage?: App.Storage<false>
   children: React.ReactNode
diff --git a/packages/common/src/translators/reactjs/hooks/useObserver.test.ts b/packages/common/src/translators/reactjs/hooks/useObserver.test.ts
new file mode 100644
index 0000000000..21c35e1e68
--- /dev/null
+++ b/packages/common/src/translators/reactjs/hooks/useObserver.test.ts
@@ -0,0 +1,34 @@
+import {act, renderHook, waitFor} from '@testing-library/react-native'
+import {Subject} from 'rxjs'
+
+import {useObserver} from './useObserver'
+
+describe('useObserver', () => {
+  it('should update the data when the observable emits a value', async () => {
+    const observable = new Subject<string>()
+    const executor = jest.fn().mockReturnValue('Initial Data')
+
+    const {result} = renderHook(() =>
+      useObserver({
+        observable,
+        executor,
+      }),
+    )
+
+    expect(result.current.data).toBe('Initial Data')
+    expect(result.current.isPending).toBe(false)
+
+    act(() => {
+      observable.next('World')
+    })
+
+    await waitFor(() => {
+      expect(result.current.isPending).toBe(false)
+    })
+
+    // initial state
+    // + 1st event
+    // + 2nd event
+    expect(executor).toHaveBeenCalledTimes(3)
+  })
+})
diff --git a/packages/common/src/translators/reactjs/hooks/useObserver.ts b/packages/common/src/translators/reactjs/hooks/useObserver.ts
new file mode 100644
index 0000000000..da08b0fa15
--- /dev/null
+++ b/packages/common/src/translators/reactjs/hooks/useObserver.ts
@@ -0,0 +1,30 @@
+import * as React from 'react'
+import {Observable} from 'rxjs'
+
+// for some reason React.useSyncExternalStore is not working properly
+export function useObserver<E, T>({
+  observable,
+  executor,
+}: {
+  observable: Observable<E>
+  executor: () => T
+}) {
+  // calling executor to populate state to enqueue dispatch render
+  const [isPending, startTransition] = React.useTransition()
+  const [data, setData] = React.useState<T>(executor())
+
+  React.useEffect(() => {
+    const subscription = observable.subscribe(() =>
+      startTransition(() => setData(() => executor())),
+    )
+    return () => subscription.unsubscribe()
+  }, [executor, observable])
+
+  return React.useMemo(
+    () => ({
+      data,
+      isPending,
+    }),
+    [data, isPending],
+  )
+}
diff --git a/packages/common/src/helpers/arrays.test.ts b/packages/common/src/utils/arrays.test.ts
similarity index 100%
rename from packages/common/src/helpers/arrays.test.ts
rename to packages/common/src/utils/arrays.test.ts
diff --git a/packages/common/src/helpers/arrays.ts b/packages/common/src/utils/arrays.ts
similarity index 86%
rename from packages/common/src/helpers/arrays.ts
rename to packages/common/src/utils/arrays.ts
index 55acca4504..b462d2dcc7 100644
--- a/packages/common/src/helpers/arrays.ts
+++ b/packages/common/src/utils/arrays.ts
@@ -2,7 +2,7 @@ export function difference<T = unknown>(
   a: ReadonlyArray<T>,
   b: ReadonlyArray<T>,
 ): ReadonlyArray<T> {
-  const bSet = new Set(b)
+  const bSet = new Set<T>(b)
   return a.filter((value) => !bSet.has(value))
 }
 
@@ -10,7 +10,7 @@ export function intersection<T = unknown>(
   a: ReadonlyArray<T>,
   b: ReadonlyArray<T>,
 ): ReadonlyArray<T> {
-  const bSet = new Set(b)
+  const bSet = new Set<T>(b)
   return a.filter((value) => bSet.has(value))
 }
 
diff --git a/packages/common/src/helpers/monads.test.ts b/packages/common/src/utils/monads.test.ts
similarity index 100%
rename from packages/common/src/helpers/monads.test.ts
rename to packages/common/src/utils/monads.test.ts
diff --git a/packages/common/src/helpers/monads.ts b/packages/common/src/utils/monads.ts
similarity index 100%
rename from packages/common/src/helpers/monads.ts
rename to packages/common/src/utils/monads.ts
diff --git a/packages/common/src/helpers/parsers.test.ts b/packages/common/src/utils/parsers.test.ts
similarity index 100%
rename from packages/common/src/helpers/parsers.test.ts
rename to packages/common/src/utils/parsers.test.ts
diff --git a/packages/common/src/helpers/parsers.ts b/packages/common/src/utils/parsers.ts
similarity index 100%
rename from packages/common/src/helpers/parsers.ts
rename to packages/common/src/utils/parsers.ts
diff --git a/packages/common/src/utils/predicates.test.ts b/packages/common/src/utils/predicates.test.ts
new file mode 100644
index 0000000000..b4be1bb74c
--- /dev/null
+++ b/packages/common/src/utils/predicates.test.ts
@@ -0,0 +1,31 @@
+import {hasEntryValue, hasValue} from './predicates'
+
+describe('hasValue', () => {
+  it('should return true for non-empty values', () => {
+    expect(hasValue(0)).toBe(true)
+    expect(hasValue('')).toBe(true)
+    expect(hasValue(false)).toBe(true)
+    expect(hasValue([])).toBe(true)
+    expect(hasValue({})).toBe(true)
+  })
+
+  it('should return false for null or undefined values', () => {
+    expect(hasValue(null)).toBe(false)
+    expect(hasValue(undefined)).toBe(false)
+  })
+})
+
+describe('hasEntryValue', () => {
+  it('should return true for entries with non-empty values', () => {
+    expect(hasEntryValue(['key', 0])).toBe(true)
+    expect(hasEntryValue(['key', ''])).toBe(true)
+    expect(hasEntryValue(['key', false])).toBe(true)
+    expect(hasEntryValue(['key', []])).toBe(true)
+    expect(hasEntryValue(['key', {}])).toBe(true)
+  })
+
+  it('should return false for entries with null or undefined values', () => {
+    expect(hasEntryValue(['key', null])).toBe(false)
+    expect(hasEntryValue(['key', undefined])).toBe(false)
+  })
+})
diff --git a/packages/common/src/utils/predicates.ts b/packages/common/src/utils/predicates.ts
new file mode 100644
index 0000000000..ec17c7df73
--- /dev/null
+++ b/packages/common/src/utils/predicates.ts
@@ -0,0 +1,6 @@
+export const hasValue = <V>(value: V | null | undefined): value is V =>
+  value != null
+
+export const hasEntryValue = <K, V>(
+  entry: [K, V | null | undefined],
+): entry is [K, V] => hasValue(entry[1])
diff --git a/packages/common/src/helpers/strings.test.ts b/packages/common/src/utils/strings.test.ts
similarity index 100%
rename from packages/common/src/helpers/strings.test.ts
rename to packages/common/src/utils/strings.test.ts
diff --git a/packages/common/src/helpers/strings.ts b/packages/common/src/utils/strings.ts
similarity index 100%
rename from packages/common/src/helpers/strings.ts
rename to packages/common/src/utils/strings.ts
diff --git a/packages/common/tsconfig.json b/packages/common/tsconfig.json
index a074f3ce47..9bc42343f1 100644
--- a/packages/common/tsconfig.json
+++ b/packages/common/tsconfig.json
@@ -7,7 +7,9 @@
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "jsx": "react",
-    "lib": ["esnext"],
+    "lib": [
+      "esnext"
+    ],
     "module": "esnext",
     "moduleResolution": "node",
     "noFallthroughCasesInSwitch": true,
@@ -21,5 +23,5 @@
     "skipLibCheck": true,
     "strict": true,
     "target": "esnext"
-  }
-}
+  },
+}
\ No newline at end of file
diff --git a/packages/links/src/translators/reactjs/state/state.ts b/packages/links/src/translators/reactjs/state/state.ts
index 3c2a738a3e..8168f14b60 100644
--- a/packages/links/src/translators/reactjs/state/state.ts
+++ b/packages/links/src/translators/reactjs/state/state.ts
@@ -1,11 +1,11 @@
-import {Links, Nullable} from '@yoroi/types'
+import {Links} from '@yoroi/types'
 import {freeze, produce, castDraft} from 'immer'
 
 export type LinksState = Readonly<{
   // walletId -> authorization (handle 1 per wallet at time)
   authorizations: ReadonlyMap<string, string>
 
-  action: Nullable<Links.YoroiAction>
+  action: Links.YoroiAction | null
 }>
 
 export type LinksActions = Readonly<{
diff --git a/packages/portfolio/.dependency-cruiser.js b/packages/portfolio/.dependency-cruiser.js
new file mode 100644
index 0000000000..fff414129a
--- /dev/null
+++ b/packages/portfolio/.dependency-cruiser.js
@@ -0,0 +1,449 @@
+/** @type {import('dependency-cruiser').IConfiguration} */
+module.exports = {
+  forbidden: [
+    /* rules from the 'recommended' preset: */
+    {
+      name: 'fix-circular',
+      severity: 'error',
+      comment:
+        'This dependency is part of a circular relationship. You might want to revise ' +
+        'your solution (i.e. use dependency inversion, make sure the modules have a single responsibility) ',
+      from: {},
+      to: {
+        circular: true
+      }
+    },
+    {
+      name: 'no-orphans',
+      comment:
+        "This is an orphan module - it's likely not used (anymore?). Either use it or " +
+        "remove it. If it's logical this module is an orphan (i.e. it's a config file), " +
+        "add an exception for it in your dependency-cruiser configuration. By default " +
+        "this rule does not scrutinize dot-files (e.g. .eslintrc.js), TypeScript declaration " +
+        "files (.d.ts), tsconfig.json and some of the babel and webpack configs.",
+      severity: 'warn',
+      from: {
+        orphan: true,
+        pathNot: [
+          '(^|/)\\.[^/]+\\.(js|cjs|mjs|ts|json)$', // dot files
+          '\\.d\\.ts$',                            // TypeScript declaration files
+          '(^|/)tsconfig\\.json$',                 // TypeScript config
+          '(^|/)(babel|webpack)\\.config\\.(js|cjs|mjs|ts|json)$' // other configs
+        ]
+      },
+      to: {},
+    },
+    {
+      name: 'no-deprecated-core',
+      comment:
+        'A module depends on a node core module that has been deprecated. Find an alternative - these are ' +
+        "bound to exist - node doesn't deprecate lightly.",
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'core'
+        ],
+        path: [
+          '^(v8\/tools\/codemap)$',
+          '^(v8\/tools\/consarray)$',
+          '^(v8\/tools\/csvparser)$',
+          '^(v8\/tools\/logreader)$',
+          '^(v8\/tools\/profile_view)$',
+          '^(v8\/tools\/profile)$',
+          '^(v8\/tools\/SourceMap)$',
+          '^(v8\/tools\/splaytree)$',
+          '^(v8\/tools\/tickprocessor-driver)$',
+          '^(v8\/tools\/tickprocessor)$',
+          '^(node-inspect\/lib\/_inspect)$',
+          '^(node-inspect\/lib\/internal\/inspect_client)$',
+          '^(node-inspect\/lib\/internal\/inspect_repl)$',
+          '^(async_hooks)$',
+          '^(punycode)$',
+          '^(domain)$',
+          '^(constants)$',
+          '^(sys)$',
+          '^(_linklist)$',
+          '^(_stream_wrap)$'
+        ],
+      }
+    },
+    {
+      name: 'not-to-deprecated',
+      comment:
+        'This module uses a (version of an) npm module that has been deprecated. Either upgrade to a later ' +
+        'version of that module, or find an alternative. Deprecated modules are a security risk.',
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'deprecated'
+        ]
+      }
+    },
+    {
+      name: 'no-non-package-json',
+      severity: 'error',
+      comment:
+        "This module depends on an npm package that isn't in the 'dependencies' section of your package.json. " +
+        "That's problematic as the package either (1) won't be available on live (2 - worse) will be " +
+        "available on live with an non-guaranteed version. Fix it by adding the package to the dependencies " +
+        "in your package.json.",
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-no-pkg',
+          'npm-unknown'
+        ]
+      }
+    },
+    {
+      name: 'not-to-unresolvable',
+      comment:
+        "This module depends on a module that cannot be found ('resolved to disk'). If it's an npm " +
+        'module: add it to your package.json. In all other cases you likely already know what to do.',
+      severity: 'error',
+      from: {},
+      to: {
+        couldNotResolve: true
+      }
+    },
+    {
+      name: 'no-duplicate-dep-types',
+      comment:
+        "Likely this module depends on an external ('npm') package that occurs more than once " +
+        "in your package.json i.e. bot as a devDependencies and in dependencies. This will cause " +
+        "maintenance problems later on.",
+      severity: 'warn',
+      from: {},
+      to: {
+        moreThanOneDependencyType: true,
+        // as it's pretty common to have a type import be a type only import 
+        // _and_ (e.g.) a devDependency - don't consider type-only dependency
+        // types for this rule
+        dependencyTypesNot: ["type-only"]
+      }
+    },
+
+    /* rules you might want to tweak for your specific situation: */
+    {
+      name: 'not-to-spec',
+      comment:
+        'This module depends on a spec (test) file. The sole responsibility of a spec file is to test code. ' +
+        "If there's something in a spec that's of use to other modules, it doesn't have that single " +
+        'responsibility anymore. Factor it out into (e.g.) a separate utility/ helper or a mock.',
+      severity: 'error',
+      from: {},
+      to: {
+        path: '\\.(spec|test)\\.(js|mjs|cjs|ts|ls|coffee|litcoffee|coffee\\.md)$'
+      }
+    },
+    {
+      name: 'not-to-dev-dep',
+      severity: 'error',
+      comment:
+        "This module depends on an npm package from the 'devDependencies' section of your " +
+        'package.json. It looks like something that ships to production, though. To prevent problems ' +
+        "with npm packages that aren't there on production declare it (only!) in the 'dependencies'" +
+        'section of your package.json. If this module is development only - add it to the ' +
+        'from.pathNot re of the not-to-dev-dep rule in the dependency-cruiser configuration',
+      from: {
+        path: '^(src)',
+        pathNot: '\\.(spec|test)\\.(js|mjs|cjs|ts|ls|coffee|litcoffee|coffee\\.md)$'
+      },
+      to: {
+        dependencyTypes: [
+          'npm-dev'
+        ]
+      }
+    },
+    {
+      name: 'optional-deps-used',
+      severity: 'info',
+      comment:
+        "This module depends on an npm package that is declared as an optional dependency " +
+        "in your package.json. As this makes sense in limited situations only, it's flagged here. " +
+        "If you're using an optional dependency here by design - add an exception to your" +
+        "dependency-cruiser configuration.",
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-optional'
+        ]
+      }
+    },
+    {
+      name: 'peer-deps-used',
+      comment:
+        "This module depends on an npm package that is declared as a peer dependency " +
+        "in your package.json. This makes sense if your package is e.g. a plugin, but in " +
+        "other cases - maybe not so much. If the use of a peer dependency is intentional " +
+        "add an exception to your dependency-cruiser configuration.",
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-peer'
+        ]
+      }
+    }
+  ],
+  options: {
+
+    /* conditions specifying which files not to follow further when encountered:
+       - path: a regular expression to match
+       - dependencyTypes: see https://github.com/sverweij/dependency-cruiser/blob/master/doc/rules-reference.md#dependencytypes-and-dependencytypesnot
+       for a complete list
+    */
+    doNotFollow: {
+      path: 'node_modules'
+    },
+
+    /* conditions specifying which dependencies to exclude
+       - path: a regular expression to match
+       - dynamic: a boolean indicating whether to ignore dynamic (true) or static (false) dependencies.
+          leave out if you want to exclude neither (recommended!)
+    */
+    // exclude : {
+    //   path: '',
+    //   dynamic: true
+    // },
+
+    /* pattern specifying which files to include (regular expression)
+       dependency-cruiser will skip everything not matching this pattern
+    */
+    // includeOnly : '',
+
+    /* dependency-cruiser will include modules matching against the focus
+       regular expression in its output, as well as their neighbours (direct
+       dependencies and dependents)
+    */
+    // focus : '',
+
+    /* list of module systems to cruise */
+    // moduleSystems: ['amd', 'cjs', 'es6', 'tsd'],
+
+    /* prefix for links in html and svg output (e.g. 'https://github.com/you/yourrepo/blob/develop/'
+       to open it on your online repo or `vscode://file/${process.cwd()}/` to 
+       open it in visual studio code),
+     */
+    // prefix: '',
+
+    /* false (the default): ignore dependencies that only exist before typescript-to-javascript compilation
+       true: also detect dependencies that only exist before typescript-to-javascript compilation
+       "specify": for each dependency identify whether it only exists before compilation or also after
+     */
+    tsPreCompilationDeps: true,
+    
+    /* 
+       list of extensions to scan that aren't javascript or compile-to-javascript. 
+       Empty by default. Only put extensions in here that you want to take into
+       account that are _not_ parsable. 
+    */
+    // extraExtensionsToScan: [".json", ".jpg", ".png", ".svg", ".webp"],
+
+    /* if true combines the package.jsons found from the module up to the base
+       folder the cruise is initiated from. Useful for how (some) mono-repos
+       manage dependencies & dependency definitions.
+     */
+    // combinedDependencies: false,
+
+    /* if true leave symlinks untouched, otherwise use the realpath */
+    // preserveSymlinks: false,
+
+    /* TypeScript project file ('tsconfig.json') to use for
+       (1) compilation and
+       (2) resolution (e.g. with the paths property)
+
+       The (optional) fileName attribute specifies which file to take (relative to
+       dependency-cruiser's current working directory). When not provided
+       defaults to './tsconfig.json'.
+     */
+    tsConfig: {
+      fileName: 'tsconfig.json'
+    },
+
+    /* Webpack configuration to use to get resolve options from.
+
+       The (optional) fileName attribute specifies which file to take (relative
+       to dependency-cruiser's current working directory. When not provided defaults
+       to './webpack.conf.js'.
+
+       The (optional) `env` and `args` attributes contain the parameters to be passed if
+       your webpack config is a function and takes them (see webpack documentation
+       for details)
+     */
+    // webpackConfig: {
+    //  fileName: './webpack.config.js',
+    //  env: {},
+    //  args: {},
+    // },
+
+    /* Babel config ('.babelrc', '.babelrc.json', '.babelrc.json5', ...) to use
+      for compilation (and whatever other naughty things babel plugins do to
+      source code). This feature is well tested and usable, but might change
+      behavior a bit over time (e.g. more precise results for used module 
+      systems) without dependency-cruiser getting a major version bump.
+     */
+    // babelConfig: {
+    //   fileName: './.babelrc'
+    // },
+
+    /* List of strings you have in use in addition to cjs/ es6 requires
+       & imports to declare module dependencies. Use this e.g. if you've
+       re-declared require, use a require-wrapper or use window.require as
+       a hack.
+    */
+    // exoticRequireStrings: [],
+    /* options to pass on to enhanced-resolve, the package dependency-cruiser
+       uses to resolve module references to disk. You can set most of these
+       options in a webpack.conf.js - this section is here for those
+       projects that don't have a separate webpack config file.
+
+       Note: settings in webpack.conf.js override the ones specified here.
+     */
+    enhancedResolveOptions: {
+      /* List of strings to consider as 'exports' fields in package.json. Use
+         ['exports'] when you use packages that use such a field and your environment
+         supports it (e.g. node ^12.19 || >=14.7 or recent versions of webpack).
+
+         If you have an `exportsFields` attribute in your webpack config, that one
+         will have precedence over the one specified here.
+      */ 
+      exportsFields: ["exports"],
+      /* List of conditions to check for in the exports field. e.g. use ['imports']
+         if you're only interested in exposed es6 modules, ['require'] for commonjs,
+         or all conditions at once `(['import', 'require', 'node', 'default']`)
+         if anything goes for you. Only works when the 'exportsFields' array is
+         non-empty.
+
+        If you have a 'conditionNames' attribute in your webpack config, that one will
+        have precedence over the one specified here.
+      */
+      conditionNames: ["import", "require", "node", "default"],
+      /*
+         The extensions, by default are the same as the ones dependency-cruiser
+         can access (run `npx depcruise --info` to see which ones that are in
+         _your_ environment. If that list is larger than what you need (e.g. 
+         it contains .js, .jsx, .ts, .tsx, .cts, .mts - but you don't use 
+         TypeScript you can pass just the extensions you actually use (e.g. 
+         [".js", ".jsx"]). This can speed up the most expensive step in 
+         dependency cruising (module resolution) quite a bit.
+       */
+      // extensions: [".js", ".jsx", ".ts", ".tsx", ".d.ts"],
+      /* 
+         If your TypeScript project makes use of types specified in 'types'
+         fields in package.jsons of external dependencies, specify "types"
+         in addition to "main" in here, so enhanced-resolve (the resolver
+         dependency-cruiser uses) knows to also look there. You can also do
+         this if you're not sure, but still use TypeScript. In a future version
+         of dependency-cruiser this will likely become the default.
+       */
+      mainFields: ["main", "types"],
+    },
+    reporterOptions: {
+      dot: {
+        /* pattern of modules that can be consolidated in the detailed
+           graphical dependency graph. The default pattern in this configuration
+           collapses everything in node_modules to one folder deep so you see
+           the external modules, but not the innards your app depends upon.
+         */
+        collapsePattern: 'node_modules/[^/]+',
+
+        /* Options to tweak the appearance of your graph.See
+           https://github.com/sverweij/dependency-cruiser/blob/master/doc/options-reference.md#reporteroptions
+           for details and some examples. If you don't specify a theme
+           don't worry - dependency-cruiser will fall back to the default one.
+        */
+        // theme: {
+        //   graph: {
+        //     /* use splines: "ortho" for straight lines. Be aware though
+        //       graphviz might take a long time calculating ortho(gonal)
+        //       routings.
+        //    */
+        //     splines: "true"
+        //   },
+        //   modules: [
+        //     {
+        //       criteria: { matchesFocus: true },
+        //       attributes: {
+        //         fillcolor: "lime",
+        //         penwidth: 2,
+        //       },
+        //     },
+        //     {
+        //       criteria: { matchesFocus: false },
+        //       attributes: {
+        //         fillcolor: "lightgrey",
+        //       },
+        //     },
+        //     {
+        //       criteria: { matchesReaches: true },
+        //       attributes: {
+        //         fillcolor: "lime",
+        //         penwidth: 2,
+        //       },
+        //     },
+        //     {
+        //       criteria: { matchesReaches: false },
+        //       attributes: {
+        //         fillcolor: "lightgrey",
+        //       },
+        //     },
+        //     {
+        //       criteria: { source: "^src/model" },
+        //       attributes: { fillcolor: "#ccccff" }
+        //     },
+        //     {
+        //       criteria: { source: "^src/view" },
+        //       attributes: { fillcolor: "#ccffcc" }
+        //     },
+        //   ],
+        //   dependencies: [
+        //     {
+        //       criteria: { "rules[0].severity": "error" },
+        //       attributes: { fontcolor: "red", color: "red" }
+        //     },
+        //     {
+        //       criteria: { "rules[0].severity": "warn" },
+        //       attributes: { fontcolor: "orange", color: "orange" }
+        //     },
+        //     {
+        //       criteria: { "rules[0].severity": "info" },
+        //       attributes: { fontcolor: "blue", color: "blue" }
+        //     },
+        //     {
+        //       criteria: { resolved: "^src/model" },
+        //       attributes: { color: "#0000ff77" }
+        //     },
+        //     {
+        //       criteria: { resolved: "^src/view" },
+        //       attributes: { color: "#00770077" }
+        //     }
+        //   ]
+        // }
+      },
+      archi: {
+        /* pattern of modules that can be consolidated in the high level
+          graphical dependency graph. If you use the high level graphical
+          dependency graph reporter (`archi`) you probably want to tweak
+          this collapsePattern to your situation.
+        */
+        collapsePattern: '^(packages|src|lib|app|bin|test(s?)|spec(s?))/[^/]+|node_modules/[^/]+',
+
+        /* Options to tweak the appearance of your graph.See
+           https://github.com/sverweij/dependency-cruiser/blob/master/doc/options-reference.md#reporteroptions
+           for details and some examples. If you don't specify a theme
+           for 'archi' dependency-cruiser will use the one specified in the
+           dot section (see above), if any, and otherwise use the default one.
+         */
+        // theme: {
+        // },
+      },
+      "text": {
+        "highlightFocused": true
+      },
+    }
+  }
+};
+// generated: dependency-cruiser@12.10.0 on 2023-03-08T01:53:10.874Z
\ No newline at end of file
diff --git a/packages/portfolio/.gitignore b/packages/portfolio/.gitignore
new file mode 100644
index 0000000000..32c6d7db77
--- /dev/null
+++ b/packages/portfolio/.gitignore
@@ -0,0 +1,71 @@
+# OSX
+#
+.DS_Store
+
+# XDE
+.expo/
+
+# VSCode
+.vscode/
+!.vscode/launch.json
+jsconfig.json
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IJ
+#
+.classpath
+.cxx
+.gradle
+.idea
+.project
+.settings
+local.properties
+android.iml
+
+# Cocoapods
+#
+example/ios/Pods
+
+# Ruby
+example/vendor/
+
+# node.js
+#
+node_modules/
+npm-debug.log
+yarn-debug.log
+yarn-error.log
+
+# BUCK
+buck-out/
+\.buckd/
+android/app/libs
+android/keystores/debug.keystore
+
+# Expo
+.expo/
+
+# Turborepo
+.turbo/
+
+# generated by bob
+lib/
diff --git a/packages/portfolio/.watchmanconfig b/packages/portfolio/.watchmanconfig
new file mode 100644
index 0000000000..0967ef424b
--- /dev/null
+++ b/packages/portfolio/.watchmanconfig
@@ -0,0 +1 @@
+{}
diff --git a/packages/portfolio/README.md b/packages/portfolio/README.md
new file mode 100644
index 0000000000..06cfef0f74
--- /dev/null
+++ b/packages/portfolio/README.md
@@ -0,0 +1 @@
+# Portfolio package for Yoroi
diff --git a/packages/portfolio/babel.config.js b/packages/portfolio/babel.config.js
new file mode 100644
index 0000000000..f842b77fcf
--- /dev/null
+++ b/packages/portfolio/babel.config.js
@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+};
diff --git a/packages/portfolio/jest.setup.js b/packages/portfolio/jest.setup.js
new file mode 100644
index 0000000000..10deefd07a
--- /dev/null
+++ b/packages/portfolio/jest.setup.js
@@ -0,0 +1,5 @@
+jest.mock('@react-native-async-storage/async-storage', () =>
+  require('@react-native-async-storage/async-storage/jest/async-storage-mock'),
+)
+
+jest.setTimeout(30000)
\ No newline at end of file
diff --git a/packages/portfolio/package.json b/packages/portfolio/package.json
new file mode 100644
index 0000000000..d48caa4a40
--- /dev/null
+++ b/packages/portfolio/package.json
@@ -0,0 +1,221 @@
+{
+  "name": "@yoroi/portfolio",
+  "version": "1.0.0",
+  "description": "The Portfolio package of Yoroi SDK",
+  "keywords": [
+    "yoroi",
+    "cardano",
+    "portfolio",
+    "browser",
+    "react"
+  ],
+  "homepage": "https://github.com/Emurgo/yoroi/packages/portfolio#readme",
+  "bugs": {
+    "url": "https://github.com/Emurgo/yoroi/issues"
+  },
+  "repository": {
+    "type": "github",
+    "url": "https://github.com/Emurgo/yoroi.git",
+    "directory": "packages/portfolio"
+  },
+  "license": "Apache-2.0",
+  "author": "EMURGO Fintech <support@emurgo.com> (https://github.com/Emurgo/yoroi)",
+  "contributors": [
+    {
+      "name": "Juliano Lazzarotto",
+      "email": "30806844+stackchain@users.noreply.github.com"
+    }
+  ],
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "source": "src/index",
+  "browser": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "files": [
+    "src",
+    "lib",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "build": "yarn tsc && yarn lint && yarn test --ci --silent && yarn clean && bob build",
+    "build:release": "yarn build && yarn flow",
+    "clean": "del-cli lib",
+    "dev": "yarn clean && bob build",
+    "dgraph": "depcruise src --include-only \"^src\" --output-type dot | dot -T svg > dependency-graph.svg",
+    "flow": ". ./scripts/flowgen.sh",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "prepack": "yarn build:release",
+    "prepublish:beta": "yarn build:release",
+    "publish:beta": "npm publish --scope yoroi --tag beta --access beta",
+    "prepublish:prod": "yarn build:release",
+    "publish:prod": "npm publish --scope yoroi --access public",
+    "release": "release-it",
+    "test": "jest --maxWorkers=1",
+    "test:watch": "jest --watch --maxWorkers=1",
+    "tsc": "tsc --noEmit -p tsconfig.json"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "quoteProps": "consistent",
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "all",
+    "useTabs": false
+  },
+  "eslintConfig": {
+    "extends": [
+      "@react-native-community",
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "quoteProps": "consistent",
+          "bracketSpacing": false,
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "all",
+          "useTabs": false,
+          "semi": false
+        }
+      ]
+    },
+    "root": true
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/",
+    "babel.config.js",
+    "jest.setup.js",
+    "coverage/"
+  ],
+  "jest": {
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts",
+      "!src/**/*.mocks.{js,jsx,ts,tsx}"
+    ],
+    "coverageReporters": [
+      "text-summary",
+      "html"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 100,
+        "functions": 100,
+        "lines": 100,
+        "statements": 100
+      }
+    },
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ],
+    "preset": "react-native",
+    "setupFiles": [
+      "<rootDir>/jest.setup.js"
+    ]
+  },
+  "dependencies": {
+    "@yoroi/api": "1.5.1",
+    "@yoroi/common": "1.5.2",
+    "@yoroi/types": "1.5.4"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^17.0.2",
+    "@react-native-async-storage/async-storage": "^1.19.3",
+    "@react-native-community/eslint-config": "^3.0.2",
+    "@release-it/conventional-changelog": "^5.0.0",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/react-native": "^12.3.0",
+    "@types/jest": "^29.5.12",
+    "@types/react": "^18.2.55",
+    "@types/react-test-renderer": "^18.0.7",
+    "commitlint": "^17.0.2",
+    "del-cli": "^5.0.0",
+    "dependency-cruiser": "^13.1.1",
+    "eslint": "^8.4.1",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-ft-flow": "^3.0.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "flowgen": "^1.21.0",
+    "jest": "^29.7.0",
+    "pod-install": "^0.1.0",
+    "prettier": "^2.0.5",
+    "react": "18.2.0",
+    "react-native": "~0.71.0",
+    "react-native-builder-bob": "^0.23.2",
+    "react-native-mmkv": "^2.11.0",
+    "react-query": "^3.39.3",
+    "react-test-renderer": "^18.2.0",
+    "release-it": "^15.0.0",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.3",
+    "bignumber.js": "^9.0.1",
+    "immer": "^10.0.3",
+    "react": ">= 16.8.0 <= 19.0.0",
+    "react-native-mmkv": "^2.11.0",
+    "react-query": "^3.39.3",
+    "rxjs": "^7.8.1",
+    "zod": "^3.22.2"
+  },
+  "packageManager": "yarn@1.22.21",
+  "engines": {
+    "node": ">= 16.19.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json",
+          "tsc": "./node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": false
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": "angular"
+      }
+    }
+  }
+}
diff --git a/packages/portfolio/scripts/flowgen.sh b/packages/portfolio/scripts/flowgen.sh
new file mode 100644
index 0000000000..2638ef8d27
--- /dev/null
+++ b/packages/portfolio/scripts/flowgen.sh
@@ -0,0 +1,3 @@
+for i in $(find lib -type f -name "*.d.ts");
+  do sh -c "npx flowgen $i -o ${i%.*.*}.js.flow";
+done;
diff --git a/packages/portfolio/src/adapters/amount.mocks.ts b/packages/portfolio/src/adapters/amount.mocks.ts
new file mode 100644
index 0000000000..c1d319d8fc
--- /dev/null
+++ b/packages/portfolio/src/adapters/amount.mocks.ts
@@ -0,0 +1,31 @@
+import {Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {tokenInfoMocks} from './token-info.mocks'
+
+const amounts1: Portfolio.Amounts = {
+  [tokenInfoMocks.primaryETH.id]: 42_000_000_000_000_000_000n,
+  [tokenInfoMocks.nftCryptoKitty.id]: 1n,
+  [tokenInfoMocks.rnftWhatever.id]: 1n,
+}
+
+const amounts = {
+  primaryETH: {
+    id: tokenInfoMocks.primaryETH.id,
+    quantity: 42_000_000_000_000_000_000n,
+  },
+  nftCryptoKitty: {id: tokenInfoMocks.nftCryptoKitty.id, quantity: 1n},
+  rnftWhatever: {id: tokenInfoMocks.rnftWhatever.id, quantity: 1n},
+}
+
+const entries1: [Portfolio.Token.Id, Portfolio.Amount][] = [
+  [tokenInfoMocks.primaryETH.id, amounts.primaryETH],
+  [tokenInfoMocks.nftCryptoKitty.id, amounts.nftCryptoKitty],
+  [tokenInfoMocks.rnftWhatever.id, amounts.rnftWhatever],
+]
+
+export const amountMocks = freeze({
+  amounts1,
+  amounts,
+  entries1,
+})
diff --git a/packages/portfolio/src/adapters/dullahan-api/api-maker.mocks.ts b/packages/portfolio/src/adapters/dullahan-api/api-maker.mocks.ts
new file mode 100644
index 0000000000..1bfe301c23
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/api-maker.mocks.ts
@@ -0,0 +1,77 @@
+import {freeze} from 'immer'
+import {asyncBehavior} from '@yoroi/common'
+import {Api, Portfolio} from '@yoroi/types'
+
+import {tokenMocks} from '../token.mocks'
+
+export const responseTokenDiscoveriesMocks = asyncBehavior.maker<
+  Api.Response<Portfolio.Api.TokenDiscoveriesResponse>
+>({
+  data: {
+    tag: 'right',
+    value: {status: 200, data: tokenMocks.apiResponse.tokenDiscoveries},
+  },
+  emptyRepresentation: [],
+})
+
+export const responseTokenInfosMocks = asyncBehavior.maker<
+  Api.Response<Portfolio.Api.TokenInfosResponse>
+>({
+  data: {
+    tag: 'right',
+    value: {status: 200, data: tokenMocks.apiResponse.tokenInfos},
+  },
+  emptyRepresentation: [],
+})
+
+const success: Portfolio.Api.Api = {
+  tokenDiscoveries: responseTokenDiscoveriesMocks.success,
+  tokenInfos: responseTokenInfosMocks.success,
+}
+
+const delayed: Portfolio.Api.Api = {
+  tokenDiscoveries: responseTokenDiscoveriesMocks.delayed,
+  tokenInfos: responseTokenInfosMocks.delayed,
+}
+
+const loading: Portfolio.Api.Api = {
+  tokenDiscoveries: responseTokenDiscoveriesMocks.loading,
+  tokenInfos: responseTokenInfosMocks.loading,
+}
+
+const error: Portfolio.Api.Api = {
+  tokenDiscoveries: () =>
+    Promise.resolve({
+      tag: 'left',
+      error: {
+        status: 400,
+        message: 'Bad Request',
+        responseData: {message: 'Bad Request'},
+      },
+    }),
+  tokenInfos: () =>
+    Promise.resolve({
+      tag: 'left',
+      error: {
+        status: 400,
+        message: 'Bad Request',
+        responseData: {message: 'Bad Request'},
+      },
+    }),
+}
+
+const empty: Portfolio.Api.Api = {
+  tokenDiscoveries: responseTokenDiscoveriesMocks.empty,
+  tokenInfos: responseTokenInfosMocks.empty,
+}
+
+export const portfolioApiMock = freeze(
+  {
+    success,
+    delayed,
+    loading,
+    error,
+    empty,
+  },
+  true,
+)
diff --git a/packages/portfolio/src/adapters/dullahan-api/api-maker.test.ts b/packages/portfolio/src/adapters/dullahan-api/api-maker.test.ts
new file mode 100644
index 0000000000..2687e96fb3
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/api-maker.test.ts
@@ -0,0 +1,115 @@
+import {Api, Chain, Portfolio} from '@yoroi/types'
+
+import {apiConfig, portfolioApiMaker} from './api-maker'
+
+describe('portfolioApiMaker', () => {
+  const mockNetwork: Chain.Network = Chain.Network.Main
+  const mockRequest = jest.fn()
+
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('should return a PortfolioApi object', () => {
+    const api = portfolioApiMaker({
+      network: mockNetwork,
+      request: mockRequest,
+    })
+
+    expect(Object.isFrozen(api)).toBe(true)
+    expect(api).toBeDefined()
+    expect(api).toHaveProperty('tokenDiscoveries')
+    expect(api).toHaveProperty('tokenInfos')
+  })
+
+  it('should return a PortfolioApi object with default fetchData (coverage)', () => {
+    const api = portfolioApiMaker({
+      network: mockNetwork,
+    })
+
+    expect(api).toBeDefined()
+    expect(api).toHaveProperty('tokenDiscoveries')
+    expect(api).toHaveProperty('tokenInfos')
+  })
+
+  it('should call the fetchData function with the correct arguments', async () => {
+    mockRequest.mockResolvedValue({
+      tag: 'right',
+      value: {
+        status: 200,
+        data: {},
+      },
+    })
+    const api = portfolioApiMaker({
+      network: mockNetwork,
+      request: mockRequest,
+    })
+    const mockTokenIdsWithCache: ReadonlyArray<
+      Api.RequestWithCache<Portfolio.Token.Id>
+    > = [['token.id', 'etag-hash']]
+
+    await api.tokenDiscoveries(mockTokenIdsWithCache)
+    await api.tokenInfos(mockTokenIdsWithCache)
+
+    expect(mockRequest).toHaveBeenCalledTimes(2)
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'post',
+      url: apiConfig[Chain.Network.Main].tokenDiscoveries,
+      data: mockTokenIdsWithCache,
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      },
+    })
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'post',
+      url: apiConfig[Chain.Network.Main].tokenInfos,
+      data: mockTokenIdsWithCache,
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      },
+    })
+  })
+
+  it('should return the error and not throw', async () => {
+    mockRequest.mockResolvedValue({
+      tag: 'left',
+      value: {
+        status: 500,
+        message: 'Internal Server Error',
+        responseData: {},
+      },
+    })
+    const api = portfolioApiMaker({
+      network: mockNetwork,
+      request: mockRequest,
+    })
+    const mockTokenIdsWithCache: ReadonlyArray<
+      Api.RequestWithCache<Portfolio.Token.Id>
+    > = [['token.id', 'etag-hash']]
+
+    await api.tokenDiscoveries(mockTokenIdsWithCache)
+    await api.tokenInfos(mockTokenIdsWithCache)
+
+    expect(mockRequest).toHaveBeenCalledTimes(2)
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'post',
+      url: apiConfig[Chain.Network.Main].tokenDiscoveries,
+      data: mockTokenIdsWithCache,
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      },
+    })
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'post',
+      url: apiConfig[Chain.Network.Main].tokenInfos,
+      data: mockTokenIdsWithCache,
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      },
+    })
+  })
+})
diff --git a/packages/portfolio/src/adapters/dullahan-api/api-maker.ts b/packages/portfolio/src/adapters/dullahan-api/api-maker.ts
new file mode 100644
index 0000000000..c4524f90af
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/api-maker.ts
@@ -0,0 +1,105 @@
+import {FetchData, fetchData, isLeft} from '@yoroi/common'
+import {Api, Chain, Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {ApiConfig} from '../../types'
+import {toSecondaryTokenInfos} from './transformers'
+import {DullahanApiTokenInfosResponse} from './types'
+
+export const portfolioApiMaker = ({
+  network,
+  request = fetchData,
+}: {
+  network: Chain.Network
+  request?: FetchData
+}): Portfolio.Api.Api => {
+  const config = apiConfig[network]
+  return freeze(
+    {
+      async tokenDiscoveries(idsWithCache) {
+        return request<
+          Portfolio.Api.TokenDiscoveriesResponse,
+          ReadonlyArray<Api.RequestWithCache<Portfolio.Token.Id>>
+        >({
+          method: 'post',
+          url: config.tokenDiscoveries,
+          data: idsWithCache,
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+          },
+        })
+      },
+      async tokenInfos(idsWithCache) {
+        const response = await request<
+          DullahanApiTokenInfosResponse,
+          ReadonlyArray<Api.RequestWithCache<Portfolio.Token.Id>>
+        >({
+          method: 'post',
+          url: config.tokenInfos,
+          data: idsWithCache,
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+          },
+        })
+        if (isLeft(response)) return response
+
+        const transformedResponseData = toSecondaryTokenInfos(
+          response.value.data,
+        )
+
+        const transformedResponse: Api.Response<Portfolio.Api.TokenInfosResponse> =
+          freeze(
+            {
+              tag: 'right',
+              value: {
+                status: response.value.status,
+                data: transformedResponseData,
+              },
+            },
+            true,
+          )
+
+        return transformedResponse
+      },
+    },
+    true,
+  )
+}
+
+export const apiConfig: ApiConfig = freeze(
+  {
+    main: {
+      tokenDiscoveries:
+        'https://add50d9d-76d7-47b7-b17f-e34021f63a02.mock.pstmn.io/v1/token-discoveries',
+      tokenInfos:
+        'https://national-brightly-iguana.ngrok-free.app/v1/token-infos',
+    },
+    preprod: {
+      tokenDiscoveries:
+        'https://add50d9d-76d7-47b7-b17f-e34021f63a02.mock.pstmn.io/v1/token-discoveries',
+      tokenInfos:
+        'https://national-brightly-iguana.ngrok-free.app/v1/token-infos',
+    },
+    preview: {
+      tokenDiscoveries:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/stakekeys/{{STAKE_KEY_HASH}}/state',
+      tokenInfos:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/dreps/{{DREP_ID}}/state',
+    },
+    sancho: {
+      tokenDiscoveries:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/stakekeys/{{STAKE_KEY_HASH}}/state',
+      tokenInfos:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/dreps/{{DREP_ID}}/state',
+    },
+    test: {
+      tokenDiscoveries:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/stakekeys/{{STAKE_KEY_HASH}}/state',
+      tokenInfos:
+        'https://yoroi-backend-zero-mainnet.emurgornd.com/dreps/{{DREP_ID}}/state',
+    },
+  },
+  true,
+)
diff --git a/packages/portfolio/src/adapters/dullahan-api/transformers.test.ts b/packages/portfolio/src/adapters/dullahan-api/transformers.test.ts
new file mode 100644
index 0000000000..a86ea8e514
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/transformers.test.ts
@@ -0,0 +1,86 @@
+import {toSecondaryTokenInfo, toSecondaryTokenInfos} from './transformers'
+import {Portfolio, Api} from '@yoroi/types'
+
+import {tokenMocks} from '../token.mocks'
+
+describe('transformers', () => {
+  describe('toSecondaryTokenInfo', () => {
+    it('should set the nature to Secondary', () => {
+      const tokenInfo: Omit<Portfolio.Token.Info, 'nature'> = {
+        ...tokenMocks.primaryETH.info,
+      }
+
+      const result = toSecondaryTokenInfo(tokenInfo)
+
+      expect(result.nature).toBe(Portfolio.Token.Nature.Secondary)
+    })
+  })
+
+  describe('toSecondaryTokenInfos', () => {
+    it('should return an empty object if apiTokenInfosResponse is empty', () => {
+      const apiTokenInfosResponse: Portfolio.Api.TokenInfosResponse = {}
+
+      const result = toSecondaryTokenInfos(apiTokenInfosResponse)
+
+      expect(result).toEqual({})
+    })
+
+    it('should throw an error if unable to parse the token-info response', () => {
+      const apiTokenInfosResponse: Portfolio.Api.TokenInfosResponse = {
+        [tokenMocks.primaryETH.info.id]: [
+          2000 as any,
+          tokenMocks.primaryETH.info,
+          'etag',
+          0,
+        ],
+      }
+
+      expect(() => {
+        toSecondaryTokenInfos(apiTokenInfosResponse)
+      }).toThrow(Api.Errors.ResponseMalformed)
+    })
+
+    it('should return the updated token info if the status code is not HttpStatusCode.NotModified', () => {
+      const apiTokenInfosResponse: Portfolio.Api.TokenInfosResponse = {
+        [tokenMocks.primaryETH.info.id]: [
+          Api.HttpStatusCode.NotModified,
+          123456,
+        ],
+      }
+
+      const result = toSecondaryTokenInfos(apiTokenInfosResponse)
+
+      expect(result).toEqual(apiTokenInfosResponse)
+    })
+
+    it('should return the original token info if the status code is HttpStatusCode.NotModified', () => {
+      const apiTokenInfosResponse: Portfolio.Api.TokenInfosResponse = {
+        [tokenMocks.rnftWhatever.info.id]: [
+          Api.HttpStatusCode.NotModified,
+          123456,
+        ],
+        [tokenMocks.nftCryptoKitty.info.id]: [
+          Api.HttpStatusCode.Ok,
+          tokenMocks.nftCryptoKitty.info,
+          'etag',
+          0,
+        ],
+      }
+
+      const result = toSecondaryTokenInfos(apiTokenInfosResponse)
+
+      expect(result).toEqual({
+        [tokenMocks.rnftWhatever.info.id]: [
+          Api.HttpStatusCode.NotModified,
+          123456,
+        ],
+        [tokenMocks.nftCryptoKitty.info.id]: [
+          200,
+          toSecondaryTokenInfo(tokenMocks.nftCryptoKitty.info),
+          'etag',
+          0,
+        ],
+      })
+    })
+  })
+})
diff --git a/packages/portfolio/src/adapters/dullahan-api/transformers.ts b/packages/portfolio/src/adapters/dullahan-api/transformers.ts
new file mode 100644
index 0000000000..025f9aeb17
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/transformers.ts
@@ -0,0 +1,49 @@
+import {Api, Portfolio} from '@yoroi/types'
+
+import {parseSecondaryTokenInfoWithCacheRecord} from '../../validators/token-info'
+import {DullahanApiTokenInfosResponse} from './types'
+
+export const toSecondaryTokenInfo = (
+  tokenInfo: Omit<Portfolio.Token.Info, 'nature'>,
+): Portfolio.Token.Info => ({
+  ...tokenInfo,
+  nature: Portfolio.Token.Nature.Secondary,
+})
+
+export const toSecondaryTokenInfos = (
+  apiTokenInfosResponse: DullahanApiTokenInfosResponse,
+) => {
+  const apiCachedTokenInfos: Record<
+    Portfolio.Token.Id,
+    Api.ResponseWithCache<Portfolio.Token.Info>
+  > = {}
+
+  return Object.entries(apiTokenInfosResponse).reduce(
+    (acc, [id, tokenInfoWithCache]) => {
+      const castedId = id as Portfolio.Token.Id
+      const castedTokenInfoWithCache =
+        tokenInfoWithCache as Api.ResponseWithCache<
+          Omit<Portfolio.Token.Info, 'nature'>
+        >
+
+      if (!parseSecondaryTokenInfoWithCacheRecord(castedTokenInfoWithCache))
+        throw new Api.Errors.ResponseMalformed(
+          'Unable to parse the token-info response',
+        )
+
+      const [statusCode] = castedTokenInfoWithCache
+
+      if (statusCode === Api.HttpStatusCode.NotModified) {
+        return {...acc, [castedId]: castedTokenInfoWithCache}
+      }
+
+      const [, tokenInfo, hash, maxAge] = castedTokenInfoWithCache
+      const updatedTokenInfo = toSecondaryTokenInfo(tokenInfo)
+
+      acc[castedId] = [statusCode, updatedTokenInfo, hash, maxAge]
+
+      return acc
+    },
+    apiCachedTokenInfos,
+  )
+}
diff --git a/packages/portfolio/src/adapters/dullahan-api/types.ts b/packages/portfolio/src/adapters/dullahan-api/types.ts
new file mode 100644
index 0000000000..a785302225
--- /dev/null
+++ b/packages/portfolio/src/adapters/dullahan-api/types.ts
@@ -0,0 +1,7 @@
+import {Api, Portfolio} from '@yoroi/types'
+
+export type DullahanApiTokenInfosResponse = Readonly<{
+  [key: Portfolio.Token.Id]: Api.ResponseWithCache<
+    Omit<Portfolio.Token.Info, 'nature'>
+  >
+}>
diff --git a/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.test.ts b/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.test.ts
new file mode 100644
index 0000000000..076b991169
--- /dev/null
+++ b/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.test.ts
@@ -0,0 +1,213 @@
+import {storageSerializer} from '@yoroi/common'
+import {App, Portfolio} from '@yoroi/types'
+
+import {portfolioBalanceStorageMaker} from './balance-storage-maker'
+import {tokenMocks} from '../token.mocks'
+import {deserializers} from '../../transformers/deserializers'
+import {tokenBalanceMocks} from '../token-balance.mocks'
+import {tokenInfoMocks} from '../token-info.mocks'
+
+describe('portfolioBalanceStorageMaker', () => {
+  let balanceStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+  let primaryBreakdownStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+
+  beforeEach(() => {
+    balanceStorage = createMockStorage(
+      'v2/wallets/id/balance/',
+      deserializers.tokenBalance,
+    )
+    primaryBreakdownStorage = createMockStorage(
+      'v2/wallets/id/primary-breakdown/',
+      deserializers.primaryBreakdown,
+    )
+
+    balanceStorage.clear()
+    primaryBreakdownStorage.clear()
+
+    jest.clearAllMocks()
+  })
+
+  it('should instantiate storage', () => {
+    const storage = portfolioBalanceStorageMaker({
+      balanceStorage,
+      primaryBreakdownStorage,
+    })
+
+    expect(storage).toBeDefined()
+    expect(Object.isFrozen(storage)).toBe(true)
+  })
+
+  it('should save balances entries', () => {
+    const {balances} = portfolioBalanceStorageMaker({
+      balanceStorage,
+      primaryBreakdownStorage,
+    })
+
+    balances.save(tokenBalanceMocks.storage.entries1)
+
+    expect(balanceStorage.multiSet).toHaveBeenCalledWith(
+      tokenBalanceMocks.storage.entries1,
+      storageSerializer,
+    )
+  })
+
+  it('should read balances entries', () => {
+    const nftCryptoKitty = tokenMocks.nftCryptoKitty.info
+    const rnftWhatever = tokenMocks.rnftWhatever.info
+
+    const {balances} = portfolioBalanceStorageMaker({
+      balanceStorage,
+      primaryBreakdownStorage,
+    })
+
+    balances.save(tokenBalanceMocks.storage.entries1)
+
+    const keys = [nftCryptoKitty.id, rnftWhatever.id]
+    const result = balances.read(keys)
+
+    expect(result).toEqual([
+      [nftCryptoKitty.id, tokenBalanceMocks.nftCryptoKitty],
+      [rnftWhatever.id, tokenBalanceMocks.rnftWhatever],
+    ])
+    expect(balanceStorage.multiGet).toHaveBeenCalledWith(
+      keys,
+      deserializers.tokenBalance,
+    )
+  })
+
+  it('should clear all portfolio records', () => {
+    const {clear, balances, primaryBalanceBreakdown} =
+      portfolioBalanceStorageMaker({
+        balanceStorage,
+        primaryBreakdownStorage,
+      })
+
+    balances.save(tokenBalanceMocks.storage.entries1)
+    primaryBalanceBreakdown.save(tokenBalanceMocks.primaryETHBreakdown)
+
+    let balanceResult = balances.all()
+    let primaryBreakdownResult = primaryBalanceBreakdown.read(
+      tokenInfoMocks.primaryETH.id,
+    )
+
+    expect(balanceResult).toEqual(tokenBalanceMocks.storage.entries1)
+    expect(primaryBreakdownResult).toEqual(
+      tokenBalanceMocks.primaryETHBreakdown,
+    )
+
+    clear()
+
+    balanceResult = balances.all()
+    primaryBreakdownResult = primaryBalanceBreakdown.read(
+      tokenInfoMocks.primaryETH.id,
+    )
+
+    // keys are gone
+    expect(balanceResult).toEqual([])
+    expect(primaryBreakdownResult).toEqual(null)
+
+    expect(balanceStorage.clear).toHaveBeenCalled()
+    expect(primaryBreakdownStorage.clear).toHaveBeenCalled()
+  })
+
+  it('should return all keys', () => {
+    const {balances, primaryBalanceBreakdown} = portfolioBalanceStorageMaker({
+      balanceStorage,
+      primaryBreakdownStorage,
+    })
+
+    balances.save(tokenBalanceMocks.storage.entries1)
+    primaryBalanceBreakdown.save(tokenBalanceMocks.primaryETHBreakdown)
+
+    let balanceResult = balances.keys()
+
+    expect(balanceResult).toEqual([
+      ...new Map(tokenBalanceMocks.storage.entries1).keys(),
+    ])
+  })
+
+  it('should call clear', () => {
+    const {balances, primaryBalanceBreakdown} = portfolioBalanceStorageMaker({
+      balanceStorage,
+      primaryBreakdownStorage,
+    })
+
+    balances.clear()
+    primaryBalanceBreakdown.clear()
+
+    expect(balanceStorage.clear).toHaveBeenCalled()
+    expect(primaryBreakdownStorage.clear).toHaveBeenCalled()
+  })
+})
+
+function createMockStorage<K extends string = string>(
+  path: App.StorageFolderName = '/',
+  deserializer = JSON.parse,
+  serializer = storageSerializer,
+  storage = new Map(),
+  subscriptions = new Set(),
+): App.ObservableStorage<false, K> {
+  const withPath = (key: string) => `${path}${key}`
+
+  return {
+    join: jest.fn((folderName: App.StorageFolderName) =>
+      createMockStorage(
+        `${path}${folderName}`,
+        deserializer,
+        serializer,
+        storage,
+        subscriptions,
+      ),
+    ),
+    getItem: jest.fn((key, parser = deserializer as any) => {
+      const item = storage.get(withPath(key)) ?? null
+      return parser(item)
+    }),
+    multiGet: jest.fn((keys, parser = deserializer as any) => {
+      return keys.map((key) => [
+        key,
+        parser(storage.get(withPath(key)) ?? null),
+      ])
+    }),
+    setItem: jest.fn((key, value, stringifier = serializer) => {
+      storage.set(withPath(key), stringifier(value))
+    }),
+    multiSet: jest.fn((tuples, stringifier = serializer) => {
+      tuples.forEach(([key, value]) => {
+        storage.set(withPath(key), stringifier(value))
+      })
+    }),
+    removeItem: jest.fn((key) => {
+      storage.delete(withPath(key))
+    }),
+    removeFolder: jest.fn((folderName: App.StorageFolderName) => {
+      const prefix = `${path}${folderName}`
+      const keysToRemove = [...storage.keys()].filter((key) =>
+        key.startsWith(prefix),
+      )
+      keysToRemove.forEach((key) => storage.delete(key))
+    }),
+    multiRemove: jest.fn((keys) => {
+      keys.forEach((key: string) => storage.delete(withPath(key)))
+    }),
+    getAllKeys: jest.fn(() => {
+      const withoutPath = (absolutePath: string) =>
+        absolutePath.slice(path.length)
+      return [...storage.keys()]
+        .filter((key) => key.startsWith(path))
+        .map((key) => withoutPath(key)) as unknown as ReadonlyArray<any>
+    }),
+    clear: jest.fn(() => {
+      storage.clear()
+    }),
+    onChange: jest.fn((_keysToObserve, callback) => {
+      subscriptions.add(callback)
+
+      return {
+        unsubscribe: jest.fn(() => {
+          subscriptions.delete(callback)
+        }),
+      } as any
+    }),
+  }
+}
diff --git a/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.ts b/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.ts
new file mode 100644
index 0000000000..52a3834285
--- /dev/null
+++ b/packages/portfolio/src/adapters/mmkv-storage/balance-storage-maker.ts
@@ -0,0 +1,63 @@
+import {storageSerializer} from '@yoroi/common'
+import {App, Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+import {deserializers} from '../../transformers/deserializers'
+
+export const portfolioBalanceStorageMaker = ({
+  balanceStorage,
+  primaryBreakdownStorage,
+}: {
+  balanceStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+  primaryBreakdownStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+}) => {
+  const balances = {
+    save: (
+      entries: ReadonlyArray<[Portfolio.Token.Id, Portfolio.Token.Balance]>,
+    ) =>
+      balanceStorage.multiSet<Portfolio.Token.Balance>(
+        entries,
+        storageSerializer,
+      ),
+    read: (keys: ReadonlyArray<Portfolio.Token.Id>) =>
+      balanceStorage.multiGet<Portfolio.Token.Balance>(
+        keys,
+        deserializers.tokenBalance,
+      ),
+    all: () =>
+      balanceStorage.multiGet<Portfolio.Token.Balance>(
+        balanceStorage.getAllKeys(),
+        deserializers.tokenBalance,
+      ),
+    keys: () => balanceStorage.getAllKeys(),
+    clear: () => balanceStorage.clear(),
+  }
+
+  const primaryBalanceBreakdown = {
+    save: (breakdown: Readonly<Portfolio.BalancePrimaryBreakdown>) =>
+      primaryBreakdownStorage.setItem(
+        breakdown.info.id,
+        breakdown,
+        storageSerializer,
+      ),
+    read: (key: Portfolio.Token.Id) =>
+      primaryBreakdownStorage.getItem<Portfolio.BalancePrimaryBreakdown>(
+        key,
+        deserializers.primaryBreakdown,
+      ),
+    clear: () => primaryBreakdownStorage.clear(),
+  }
+
+  const clear = () => {
+    balanceStorage.clear()
+    primaryBreakdownStorage.clear()
+  }
+
+  return freeze(
+    {
+      balances,
+      primaryBalanceBreakdown,
+      clear,
+    },
+    true,
+  )
+}
diff --git a/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.test.ts b/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.test.ts
new file mode 100644
index 0000000000..c7fdab757f
--- /dev/null
+++ b/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.test.ts
@@ -0,0 +1,282 @@
+import {cacheRecordMaker, storageSerializer} from '@yoroi/common'
+import {App, Portfolio} from '@yoroi/types'
+
+import {portfolioTokenStorageMaker} from './token-storage-maker' // Adjust the path accordingly
+import {tokenMocks} from '../token.mocks'
+import {deserializers} from '../../transformers/deserializers'
+import {tokenDiscoveryMocks} from '../token-discovery.mocks'
+import {tokenInfoMocks} from '../token-info.mocks'
+
+describe('portfolioTokenStorageMaker', () => {
+  let tokenInfoStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+  let tokenDiscoveryStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+
+  beforeEach(() => {
+    tokenInfoStorage = createMockStorage('v2/mainnet/token-info/')
+    tokenDiscoveryStorage = createMockStorage(
+      'v2/mainnet/token-discovery/',
+      deserializers.tokenDiscoveryWithCache,
+    )
+
+    tokenInfoStorage.clear()
+    tokenDiscoveryStorage.clear()
+
+    jest.clearAllMocks()
+  })
+
+  it('should instantiate storage', () => {
+    const storage = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    expect(storage).toBeDefined()
+    expect(Object.isFrozen(storage)).toBe(true)
+  })
+
+  it('should save token info entries', () => {
+    const nftCryptoKitty = tokenMocks.nftCryptoKitty.info
+    const primaryETH = tokenMocks.primaryETH.info
+
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    const entries: ReadonlyArray<
+      [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+    > = [
+      [
+        nftCryptoKitty.id,
+        cacheRecordMaker({expires: 0, hash: ''}, nftCryptoKitty),
+      ],
+      [primaryETH.id, cacheRecordMaker({expires: 0, hash: ''}, primaryETH)],
+    ] as const
+
+    token.infos.save(entries)
+
+    expect(tokenInfoStorage.multiSet).toHaveBeenCalledWith(
+      entries,
+      storageSerializer,
+    )
+  })
+
+  it('should read token info entries', () => {
+    const nftCryptoKitty = tokenMocks.nftCryptoKitty.info
+    const primaryETH = tokenMocks.primaryETH.info
+
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    const entries: ReadonlyArray<
+      [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+    > = [
+      [
+        nftCryptoKitty.id,
+        cacheRecordMaker({expires: 0, hash: ''}, nftCryptoKitty),
+      ],
+      [primaryETH.id, cacheRecordMaker({expires: 0, hash: ''}, primaryETH)],
+    ] as const
+
+    token.infos.save(entries)
+
+    const keys = [nftCryptoKitty.id, primaryETH.id]
+    const result = token.infos.read(keys)
+
+    expect(result).toEqual(entries)
+    expect(tokenInfoStorage.multiGet).toHaveBeenCalledWith(keys)
+  })
+
+  it('should read token discovery entries', () => {
+    const nftCryptoKitty = tokenMocks.nftCryptoKitty.discovery
+    const primaryETH = tokenMocks.primaryETH.discovery
+
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    const entries: ReadonlyArray<
+      [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Discovery>]
+    > = [
+      [
+        nftCryptoKitty.id,
+        cacheRecordMaker({expires: 0, hash: ''}, nftCryptoKitty),
+      ],
+      [primaryETH.id, cacheRecordMaker({expires: 0, hash: ''}, primaryETH)],
+    ] as const
+
+    token.discoveries.save(entries)
+
+    const keys = [nftCryptoKitty.id, primaryETH.id]
+    const result = token.discoveries.read(keys)
+
+    expect(result).toEqual(entries)
+    expect(tokenDiscoveryStorage.multiGet).toHaveBeenCalledWith(
+      keys,
+      deserializers.tokenDiscoveryWithCache,
+    )
+  })
+
+  it('should save token discovery entries', () => {
+    const nftCryptoKitty = tokenMocks.nftCryptoKitty.discovery
+    const primaryETH = tokenMocks.primaryETH.discovery
+
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    const entries: ReadonlyArray<
+      [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Discovery>]
+    > = [
+      [
+        nftCryptoKitty.id,
+        cacheRecordMaker({expires: 0, hash: ''}, nftCryptoKitty),
+      ],
+      [primaryETH.id, cacheRecordMaker({expires: 0, hash: ''}, primaryETH)],
+    ] as const
+
+    token.discoveries.save(entries)
+
+    expect(tokenDiscoveryStorage.multiSet).toHaveBeenCalledWith(
+      entries,
+      storageSerializer,
+    )
+  })
+
+  it('should clear all portfolio records', () => {
+    const {token, clear} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    token.discoveries.save(tokenDiscoveryMocks.storage.entries1)
+    token.infos.save(tokenInfoMocks.storage.entries1)
+
+    let infoResult = token.infos.all()
+    let dicoveryResult = token.discoveries.all()
+
+    expect(infoResult).toEqual(tokenInfoMocks.storage.entries1)
+    expect(dicoveryResult).toEqual(tokenDiscoveryMocks.storage.entries1)
+
+    clear()
+
+    infoResult = token.infos.all()
+    dicoveryResult = token.discoveries.all()
+
+    // keys are gone
+    expect(infoResult).toEqual([])
+    expect(dicoveryResult).toEqual([])
+
+    expect(tokenDiscoveryStorage.clear).toHaveBeenCalled()
+    expect(tokenInfoStorage.clear).toHaveBeenCalled()
+  })
+
+  it('should return all keys', () => {
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    token.discoveries.save(tokenDiscoveryMocks.storage.entries1)
+    token.infos.save(tokenInfoMocks.storage.entries1)
+
+    let infoResult = token.infos.keys()
+    let dicoveryResult = token.discoveries.keys()
+
+    expect(infoResult).toEqual([
+      ...new Map(tokenInfoMocks.storage.entries1).keys(),
+    ])
+    expect(dicoveryResult).toEqual([
+      ...new Map(tokenDiscoveryMocks.storage.entries1).keys(),
+    ])
+  })
+
+  it('should call clear', () => {
+    const {token} = portfolioTokenStorageMaker({
+      tokenInfoStorage,
+      tokenDiscoveryStorage,
+    })
+
+    token.discoveries.clear()
+    token.infos.clear()
+
+    expect(tokenDiscoveryStorage.clear).toHaveBeenCalled()
+    expect(tokenInfoStorage.clear).toHaveBeenCalled()
+  })
+})
+
+function createMockStorage<K extends string = string>(
+  path: App.StorageFolderName = '/',
+  deserializer = JSON.parse,
+  serializer = storageSerializer,
+  storage = new Map(),
+  subscriptions = new Set(),
+): App.ObservableStorage<false, K> {
+  const withPath = (key: string) => `${path}${key}`
+
+  return {
+    join: jest.fn((folderName: App.StorageFolderName) =>
+      createMockStorage(
+        `${path}${folderName}`,
+        deserializer,
+        serializer,
+        storage,
+        subscriptions,
+      ),
+    ),
+    getItem: jest.fn((key, parser = deserializer as any) => {
+      const item = storage.get(withPath(key)) ?? null
+      return parser(item)
+    }),
+    multiGet: jest.fn((keys, parser = deserializer as any) => {
+      return keys.map((key) => [
+        key,
+        parser(storage.get(withPath(key)) ?? null),
+      ])
+    }),
+    setItem: jest.fn((key, value, stringifier = serializer) => {
+      storage.set(withPath(key), stringifier(value))
+    }),
+    multiSet: jest.fn((tuples, stringifier = serializer) => {
+      tuples.forEach(([key, value]) => {
+        storage.set(withPath(key), stringifier(value))
+      })
+    }),
+    removeItem: jest.fn((key) => {
+      storage.delete(withPath(key))
+    }),
+    removeFolder: jest.fn((folderName: App.StorageFolderName) => {
+      const prefix = `${path}${folderName}`
+      const keysToRemove = [...storage.keys()].filter((key) =>
+        key.startsWith(prefix),
+      )
+      keysToRemove.forEach((key) => storage.delete(key))
+    }),
+    multiRemove: jest.fn((keys) => {
+      keys.forEach((key: string) => storage.delete(withPath(key)))
+    }),
+    getAllKeys: jest.fn(() => {
+      const withoutPath = (absolutePath: string) =>
+        absolutePath.slice(path.length)
+      return [...storage.keys()]
+        .filter((key) => key.startsWith(path))
+        .map((key) => withoutPath(key)) as unknown as ReadonlyArray<any>
+    }),
+    clear: jest.fn(() => {
+      storage.clear()
+    }),
+    onChange: jest.fn((_keysToObserve, callback) => {
+      subscriptions.add(callback)
+
+      return {
+        unsubscribe: jest.fn(() => {
+          subscriptions.delete(callback)
+        }),
+      } as any
+    }),
+  }
+}
diff --git a/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.ts b/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.ts
new file mode 100644
index 0000000000..dbfdc7ae38
--- /dev/null
+++ b/packages/portfolio/src/adapters/mmkv-storage/token-storage-maker.ts
@@ -0,0 +1,70 @@
+import {storageSerializer} from '@yoroi/common'
+import {App, Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {deserializers} from '../../transformers/deserializers'
+
+export const portfolioTokenStorageMaker = ({
+  tokenInfoStorage,
+  tokenDiscoveryStorage,
+}: {
+  tokenInfoStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+  tokenDiscoveryStorage: App.ObservableStorage<false, Portfolio.Token.Id>
+}) => {
+  const infos = {
+    save: (
+      entries: ReadonlyArray<
+        [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+      >,
+    ) =>
+      tokenInfoStorage.multiSet<App.CacheRecord<Portfolio.Token.Info>>(
+        entries,
+        storageSerializer,
+      ),
+    read: (keys: ReadonlyArray<Portfolio.Token.Id>) =>
+      tokenInfoStorage.multiGet<App.CacheRecord<Portfolio.Token.Info>>(keys),
+    all: () =>
+      tokenInfoStorage.multiGet<App.CacheRecord<Portfolio.Token.Info>>(
+        tokenInfoStorage.getAllKeys(),
+      ),
+    keys: () => tokenInfoStorage.getAllKeys(),
+    clear: () => tokenInfoStorage.clear(),
+  }
+
+  const discoveries = {
+    save: (
+      entries: ReadonlyArray<
+        [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Discovery>]
+      >,
+    ) =>
+      tokenDiscoveryStorage.multiSet<
+        App.CacheRecord<Portfolio.Token.Discovery>
+      >(entries, storageSerializer),
+    read: (keys: ReadonlyArray<Portfolio.Token.Id>) =>
+      tokenDiscoveryStorage.multiGet<
+        App.CacheRecord<Portfolio.Token.Discovery>
+      >(keys, deserializers.tokenDiscoveryWithCache),
+    all: () =>
+      tokenDiscoveryStorage.multiGet<
+        App.CacheRecord<Portfolio.Token.Discovery>
+      >(tokenDiscoveryStorage.getAllKeys()),
+    keys: () => tokenDiscoveryStorage.getAllKeys(),
+    clear: () => tokenDiscoveryStorage.clear(),
+  }
+
+  const clear = () => {
+    tokenDiscoveryStorage.clear()
+    tokenInfoStorage.clear()
+  }
+
+  return freeze(
+    {
+      token: {
+        infos,
+        discoveries,
+      },
+      clear,
+    },
+    true,
+  )
+}
diff --git a/packages/portfolio/src/adapters/token-balance.mocks.ts b/packages/portfolio/src/adapters/token-balance.mocks.ts
new file mode 100644
index 0000000000..d1a709b602
--- /dev/null
+++ b/packages/portfolio/src/adapters/token-balance.mocks.ts
@@ -0,0 +1,88 @@
+import {Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {tokenInfoMocks} from './token-info.mocks'
+
+const primaryETH: Portfolio.Token.Balance = {
+  info: tokenInfoMocks.primaryETH,
+  balance: BigInt(1_000_000),
+  lockedInBuiltTxs: BigInt(0),
+}
+
+const primaryETHBreakdown: Portfolio.BalancePrimaryBreakdown = {
+  ...primaryETH,
+  minRequiredByTokens: BigInt(500_000),
+  records: [
+    {
+      quantity: BigInt(1_000_000),
+      redeemableAfter: new Date().getTime(),
+      source: 'rewards',
+    },
+  ],
+}
+
+const missingToken: Portfolio.Token.Balance = {
+  info: {...tokenInfoMocks.ftNameless, id: 'dead.fee'},
+  balance: BigInt(1),
+  lockedInBuiltTxs: BigInt(0),
+}
+
+const nftCryptoKitty: Portfolio.Token.Balance = {
+  info: tokenInfoMocks.nftCryptoKitty,
+  balance: BigInt(1_000_001),
+  lockedInBuiltTxs: BigInt(100_001),
+}
+
+const rnftWhatever: Portfolio.Token.Balance = {
+  info: tokenInfoMocks.rnftWhatever,
+  balance: BigInt(2_000_002),
+  lockedInBuiltTxs: BigInt(200_002),
+}
+
+const ftNoTicker: Portfolio.Token.Balance = {
+  info: tokenInfoMocks.ftNoTicker,
+  balance: BigInt(3_000_003),
+  lockedInBuiltTxs: BigInt(300_003),
+}
+
+const ftNameless: Portfolio.Token.Balance = {
+  info: tokenInfoMocks.ftNameless,
+  balance: BigInt(4_000_004),
+  lockedInBuiltTxs: BigInt(400_004),
+}
+
+const storage: {
+  entries1: ReadonlyArray<[Portfolio.Token.Id, Portfolio.Token.Balance]>
+  entries1WithPrimary: ReadonlyArray<
+    [Portfolio.Token.Id, Portfolio.Token.Balance]
+  >
+  missingInApiResponse: ReadonlyArray<
+    [Portfolio.Token.Id, Portfolio.Token.Balance]
+  >
+} = {
+  entries1: [
+    [nftCryptoKitty.info.id, nftCryptoKitty],
+    [rnftWhatever.info.id, rnftWhatever],
+    [ftNoTicker.info.id, ftNoTicker],
+    [ftNameless.info.id, ftNameless],
+  ],
+  entries1WithPrimary: [
+    [nftCryptoKitty.info.id, nftCryptoKitty],
+    [rnftWhatever.info.id, rnftWhatever],
+    [ftNoTicker.info.id, ftNoTicker],
+    [ftNameless.info.id, ftNameless],
+    [primaryETH.info.id, primaryETH],
+  ],
+  missingInApiResponse: [[missingToken.info.id, missingToken]],
+}
+
+export const tokenBalanceMocks = freeze({
+  primaryETH,
+  primaryETHBreakdown,
+  nftCryptoKitty,
+  rnftWhatever,
+  ftNoTicker,
+  ftNameless,
+
+  storage,
+})
diff --git a/packages/portfolio/src/adapters/token-discovery.mocks.ts b/packages/portfolio/src/adapters/token-discovery.mocks.ts
new file mode 100644
index 0000000000..ef7d08a52a
--- /dev/null
+++ b/packages/portfolio/src/adapters/token-discovery.mocks.ts
@@ -0,0 +1,159 @@
+import {cacheRecordMaker} from '@yoroi/common'
+import {Api, App, Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {tokenInfoMocks} from './token-info.mocks'
+
+const primaryETH: Portfolio.Token.Discovery = {
+  id: '.',
+  counters: {
+    items: 1,
+    totalItems: 1,
+    supply: 45_000_000_000_000n,
+  },
+  originalMetadata: {
+    filteredMintMetadatum: null,
+    referenceDatum: null,
+    tokenRegistry: null,
+  },
+  properties: {},
+  source: {
+    decimals: Portfolio.Token.Source.Metadata,
+    image: Portfolio.Token.Source.Metadata,
+    name: Portfolio.Token.Source.Metadata,
+    symbol: Portfolio.Token.Source.Metadata,
+    ticker: Portfolio.Token.Source.Metadata,
+  },
+}
+
+const nftCryptoKitty: Portfolio.Token.Discovery = {
+  id: tokenInfoMocks.nftCryptoKitty.id,
+  counters: {
+    items: 1,
+    totalItems: 1,
+    supply: 0n,
+  },
+  originalMetadata: {
+    filteredMintMetadatum: null,
+    referenceDatum: null,
+    tokenRegistry: null,
+  },
+  properties: {
+    eyes: {
+      detectedType: Portfolio.Token.PropertyType.String,
+      rarity: 0.9,
+      value: 'green',
+    },
+    hair: {
+      detectedType: Portfolio.Token.PropertyType.String,
+      rarity: 0.001,
+      value: 'black',
+    },
+  },
+  source: {
+    decimals: Portfolio.Token.Source.Metadata,
+    image: Portfolio.Token.Source.Metadata,
+    name: Portfolio.Token.Source.Metadata,
+    symbol: Portfolio.Token.Source.Metadata,
+    ticker: Portfolio.Token.Source.Metadata,
+  },
+}
+
+const rnftWhatever: Portfolio.Token.Discovery = {
+  id: tokenInfoMocks.rnftWhatever.id,
+  counters: {
+    items: 1,
+    totalItems: 1,
+    supply: 0n,
+  },
+  originalMetadata: {
+    filteredMintMetadatum: null,
+    referenceDatum: null,
+    tokenRegistry: null,
+  },
+  properties: {
+    head: {
+      detectedType: Portfolio.Token.PropertyType.String,
+      rarity: 0.9,
+      value: 'alien',
+    },
+    neck: {
+      detectedType: Portfolio.Token.PropertyType.String,
+      rarity: 0.001,
+      value: true,
+    },
+  },
+  source: {
+    decimals: Portfolio.Token.Source.Metadata,
+    image: Portfolio.Token.Source.Metadata,
+    name: Portfolio.Token.Source.Metadata,
+    symbol: Portfolio.Token.Source.Metadata,
+    ticker: Portfolio.Token.Source.Metadata,
+  },
+}
+
+const apiResponseTokenDiscoveries: Portfolio.Api.TokenDiscoveriesResponse =
+  freeze(
+    {
+      [nftCryptoKitty.id]: [200, nftCryptoKitty, 'hash2', 10],
+      [rnftWhatever.id]: [304, 0],
+    },
+    true,
+  )
+
+const apiRequestTokenDiscoveries: ReadonlyArray<
+  Api.RequestWithCache<Portfolio.Token.Id>
+> = [
+  [nftCryptoKitty.id, 'hash2'],
+  [rnftWhatever.id, 'hash3'],
+]
+
+const storage: {
+  entries1: ReadonlyArray<
+    [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Discovery>]
+  >
+} = {
+  entries1: [
+    [
+      primaryETH.id,
+      cacheRecordMaker(
+        {
+          expires: new Date().getTime(),
+          hash: 'hash1',
+        },
+        primaryETH,
+      ),
+    ],
+    [
+      nftCryptoKitty.id,
+      cacheRecordMaker(
+        {
+          expires: new Date().getTime(),
+          hash: 'hash2',
+        },
+        nftCryptoKitty,
+      ),
+    ],
+    [
+      rnftWhatever.id,
+      cacheRecordMaker(
+        {
+          expires: new Date().getTime(),
+          hash: 'hash3',
+        },
+        rnftWhatever,
+      ),
+    ],
+  ],
+}
+
+export const tokenDiscoveryMocks = freeze({
+  primaryETH,
+  nftCryptoKitty,
+  rnftWhatever,
+
+  apiResponseResult: apiResponseTokenDiscoveries,
+  apiRequestArgs: apiRequestTokenDiscoveries,
+
+  storage,
+})
diff --git a/packages/portfolio/src/adapters/token-info.mocks.ts b/packages/portfolio/src/adapters/token-info.mocks.ts
new file mode 100644
index 0000000000..3ee34e6668
--- /dev/null
+++ b/packages/portfolio/src/adapters/token-info.mocks.ts
@@ -0,0 +1,180 @@
+import {Api, App, Portfolio} from '@yoroi/types'
+import {cacheRecordMaker} from '@yoroi/common'
+import {freeze} from 'immer'
+
+const primaryETH: Portfolio.Token.Info = {
+  decimals: 18,
+  ticker: 'ETH',
+  name: 'Ethereum',
+  symbol: 'Ξ',
+  status: Portfolio.Token.Status.Valid,
+  application: Portfolio.Token.Application.General,
+  tag: '',
+  reference: '0x1234567890abcdef.eth',
+  fingerprint: '0x1234567890abcdef',
+  website: 'https://ethereum.org',
+  originalImage: 'https://cdn.example.com/eth-original.png',
+  id: '.',
+  nature: Portfolio.Token.Nature.Primary,
+  type: Portfolio.Token.Type.FT,
+}
+
+const nftCryptoKitty: Portfolio.Token.Info = {
+  decimals: 0,
+  ticker: 'CryptoKitty',
+  name: 'CryptoKitty #1234',
+  symbol: 'CK',
+  status: Portfolio.Token.Status.Valid,
+  application: Portfolio.Token.Application.General,
+  tag: '',
+  reference: '0xabcdef1234567890.cryptokitty1234',
+  website: 'https://www.cryptokitties.co',
+  originalImage: 'https://cdn.example.com/ck-original1234.png',
+  id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.43554259',
+  fingerprint: 'asset1s7nlt45cc82upqewvjtgu7g97l7eg483c6wu75',
+  nature: Portfolio.Token.Nature.Secondary,
+  type: Portfolio.Token.Type.NFT,
+}
+
+const rnftWhatever: Portfolio.Token.Info = {
+  decimals: 0,
+  ticker: 'Whatever',
+  name: 'Whatever #42',
+  symbol: 'WTH',
+  status: Portfolio.Token.Status.Valid,
+  application: Portfolio.Token.Application.Music,
+  tag: '222',
+  reference: 'transactionId#1',
+  website: 'https://www.whaha.co',
+  originalImage: 'https://cdn.whatha.com/ck-original1234.png',
+  id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3031',
+  fingerprint: 'asset1s7nlt45cc82upqewvjtgu7g97l7eg483c6wu75',
+  nature: Portfolio.Token.Nature.Secondary,
+  type: Portfolio.Token.Type.NFT,
+}
+
+const ftNoTicker: Portfolio.Token.Info = {
+  decimals: 0,
+  ticker: '',
+  name: 'ZZZZZ',
+  symbol: 'WTH',
+  status: Portfolio.Token.Status.Valid,
+  application: Portfolio.Token.Application.Music,
+  tag: '222',
+  reference: 'transactionId#1',
+  website: 'https://www.whaha.co',
+  originalImage: 'https://cdn.whatha.com/ck-original1234.png',
+  id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3032',
+  fingerprint: 'asset1s7nlt45cc82upqewvjtgu7g97l7eg483c6wu75',
+  nature: Portfolio.Token.Nature.Secondary,
+  type: Portfolio.Token.Type.FT,
+}
+
+const ftNameless: Portfolio.Token.Info = {
+  decimals: 0,
+  ticker: 'zz',
+  name: '',
+  symbol: 'WTH',
+  status: Portfolio.Token.Status.Valid,
+  application: Portfolio.Token.Application.Music,
+  tag: '222',
+  reference: 'transactionId#1',
+  website: 'https://www.whaha.co',
+  originalImage: 'https://cdn.whatha.com/ck-original1234.png',
+  id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.3033',
+  fingerprint: 'asset1s7nlt45cc82upqewvjtgu7g97l7eg483c6wu75',
+  nature: Portfolio.Token.Nature.Secondary,
+  type: Portfolio.Token.Type.FT,
+}
+
+// NOTE: If you marked a record as not modified 304, remember to add to the intiial state
+// otherwise the tests will throw cuz it will be expected the record to exist in the cache
+const apiResponseTokenInfos: Portfolio.Api.TokenInfosResponse = {
+  [nftCryptoKitty.id]: [Api.HttpStatusCode.Ok, nftCryptoKitty, 'hash2-1', 3600],
+  [rnftWhatever.id]: [Api.HttpStatusCode.NotModified, 3600],
+  [ftNoTicker.id]: [Api.HttpStatusCode.Ok, ftNoTicker, 'hash4-1', 3600],
+  [ftNameless.id]: [Api.HttpStatusCode.Ok, ftNameless, 'hash5', 3600],
+}
+
+const apiRequestTokenInfos: ReadonlyArray<
+  Api.RequestWithCache<Portfolio.Token.Id>
+> = [
+  [nftCryptoKitty.id, 'hash2'],
+  [rnftWhatever.id, 'hash3'],
+  [ftNoTicker.id, 'hash4'],
+  [ftNameless.id, 'hash5'],
+]
+
+const storage: {
+  entries1: ReadonlyArray<
+    [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+  >
+  notModified: ReadonlyArray<
+    [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+  >
+  cached: ReadonlyArray<
+    [Portfolio.Token.Id, App.CacheRecord<Portfolio.Token.Info>]
+  >
+} = {
+  notModified: [
+    [
+      rnftWhatever.id,
+      cacheRecordMaker(
+        {expires: Date.now() - 3_600_000, hash: 'hash3'},
+        rnftWhatever,
+      ),
+    ],
+  ],
+  cached: [
+    [
+      rnftWhatever.id,
+      cacheRecordMaker(
+        {expires: Date.now() + 3_600_000, hash: 'hash3'},
+        rnftWhatever,
+      ),
+    ],
+  ],
+  entries1: [
+    [
+      nftCryptoKitty.id,
+      cacheRecordMaker(
+        {expires: Date.now() - 3_600_000, hash: 'hash2'},
+        nftCryptoKitty,
+      ),
+    ],
+    [
+      rnftWhatever.id,
+      cacheRecordMaker(
+        {expires: Date.now() + 3_600_000, hash: 'hash3'},
+        rnftWhatever,
+      ),
+    ],
+    [
+      ftNoTicker.id,
+      cacheRecordMaker(
+        {expires: Date.now() - 3_600_000, hash: 'hash4'},
+        ftNoTicker,
+      ),
+    ],
+    [
+      ftNameless.id,
+      cacheRecordMaker(
+        {expires: Date.now() + 3_600_000, hash: 'hash5'},
+        ftNameless,
+      ),
+    ],
+  ],
+}
+
+export const tokenInfoMocks = freeze({
+  primaryETH,
+  nftCryptoKitty,
+  rnftWhatever,
+  ftNoTicker,
+  ftNameless,
+
+  storage,
+
+  apiResponseResult: apiResponseTokenInfos,
+  apiRequestArgs: apiRequestTokenInfos,
+})
diff --git a/packages/portfolio/src/adapters/token.mocks.ts b/packages/portfolio/src/adapters/token.mocks.ts
new file mode 100644
index 0000000000..95357a16eb
--- /dev/null
+++ b/packages/portfolio/src/adapters/token.mocks.ts
@@ -0,0 +1,44 @@
+import {freeze} from 'immer'
+
+import * as infos from './token-info.mocks'
+import * as discoveries from './token-discovery.mocks'
+import * as balances from './token-balance.mocks'
+import {TokenInfoAndDiscovery} from '../types'
+
+const primaryToken: Readonly<TokenInfoAndDiscovery> = freeze({
+  info: infos.tokenInfoMocks.primaryETH,
+  discovery: discoveries.tokenDiscoveryMocks.primaryETH,
+})
+
+export const tokenMocks = freeze(
+  {
+    nftCryptoKitty: {
+      info: infos.tokenInfoMocks.nftCryptoKitty,
+      discovery: discoveries.tokenDiscoveryMocks.nftCryptoKitty,
+      balance: balances.tokenBalanceMocks.nftCryptoKitty,
+    },
+    primaryETH: {
+      info: infos.tokenInfoMocks.primaryETH,
+      discovery: discoveries.tokenDiscoveryMocks.primaryETH,
+      balance: balances.tokenBalanceMocks.primaryETH,
+      primaryBalanceBreakdown: balances.tokenBalanceMocks.primaryETHBreakdown,
+    },
+    rnftWhatever: {
+      info: infos.tokenInfoMocks.rnftWhatever,
+      discovery: discoveries.tokenDiscoveryMocks.rnftWhatever,
+      balance: balances.tokenBalanceMocks.rnftWhatever,
+    },
+    apiResponse: {
+      tokenInfos: infos.tokenInfoMocks.apiResponseResult,
+      tokenDiscoveries: discoveries.tokenDiscoveryMocks.apiResponseResult,
+    },
+    apiRequest: {
+      tokenInfos: infos.tokenInfoMocks.apiRequestArgs,
+      tokenDiscoveries: discoveries.tokenDiscoveryMocks.apiRequestArgs,
+    },
+    managerMaker: {
+      primaryToken,
+    },
+  },
+  true,
+)
diff --git a/packages/portfolio/src/balance-manager.test.ts b/packages/portfolio/src/balance-manager.test.ts
new file mode 100644
index 0000000000..9c8d87cab1
--- /dev/null
+++ b/packages/portfolio/src/balance-manager.test.ts
@@ -0,0 +1,488 @@
+import {Portfolio} from '@yoroi/types'
+import {BehaviorSubject} from 'rxjs'
+import {mountMMKVStorage, observableStorageMaker} from '@yoroi/common'
+
+import {portfolioBalanceManagerMaker} from './balance-manager'
+import {tokenBalanceMocks} from './adapters/token-balance.mocks'
+import {sortTokenBalances} from './helpers/sorting'
+import {tokenMocks} from './adapters/token.mocks'
+import {portfolioBalanceStorageMaker} from './adapters/mmkv-storage/balance-storage-maker'
+import {tokenInfoMocks} from './adapters/token-info.mocks'
+import {isFt} from './helpers/is-ft'
+import {isNft} from './helpers/is-nft'
+
+const tokenInfoStorage = observableStorageMaker(
+  mountMMKVStorage<Portfolio.Token.Id>({
+    path: `/test/token-info/`,
+  }),
+)
+const sourceId = 'sourceId'
+
+describe('portfolioBalanceManagerMaker', () => {
+  const balanceStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/balance/',
+      id: 'balance',
+    }),
+  )
+  const primaryBreakdownStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/primary-balance-breakdown/',
+      id: 'primary-balance-breakdown',
+    }),
+  )
+  const storage: Portfolio.Storage.Balance = portfolioBalanceStorageMaker({
+    balanceStorage,
+    primaryBreakdownStorage,
+  })
+  const tokenManager: Portfolio.Manager.Token = {
+    destroy: jest.fn(),
+    hydrate: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    observable: new BehaviorSubject({} as any).asObservable(),
+    sync: jest.fn().mockResolvedValue(new Map()),
+  }
+
+  it('should be instantiated', () => {
+    const manager = portfolioBalanceManagerMaker({
+      tokenManager,
+      storage,
+      primaryToken: tokenMocks.managerMaker.primaryToken,
+      sourceId,
+    })
+
+    expect(manager).toBeDefined()
+  })
+})
+
+describe('hydrate', () => {
+  const balanceStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/balance/',
+      id: 'balance',
+    }),
+  )
+  const primaryBreakdownStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/primary-balance-breakdown/',
+      id: 'primary-balance-breakdown',
+    }),
+  )
+  const storage: Portfolio.Storage.Balance = portfolioBalanceStorageMaker({
+    balanceStorage,
+    primaryBreakdownStorage,
+  })
+  const tokenManager: Portfolio.Manager.Token = {
+    destroy: jest.fn(),
+    hydrate: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    observable: new BehaviorSubject({} as any).asObservable(),
+    sync: jest.fn().mockResolvedValue(new Map()),
+  }
+
+  afterEach(() => {
+    storage.clear()
+    tokenInfoStorage.clear()
+  })
+
+  const primaryBalance: Readonly<Portfolio.BalancePrimaryBreakdown> = {
+    info: tokenMocks.managerMaker.primaryToken.info,
+    balance: BigInt(1000000),
+    lockedInBuiltTxs: BigInt(0),
+    minRequiredByTokens: BigInt(0),
+    records: [],
+  }
+
+  storage.primaryBalanceBreakdown.save(primaryBalance)
+  storage.balances.save(tokenBalanceMocks.storage.entries1)
+
+  it('should hydrate data', async () => {
+    tokenInfoStorage.multiSet(tokenInfoMocks.storage.entries1)
+    const manager = portfolioBalanceManagerMaker({
+      tokenManager,
+      storage,
+      primaryToken: tokenMocks.managerMaker.primaryToken,
+      sourceId,
+    })
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+    const sorted = sortTokenBalances({
+      primaryTokenInfo: tokenMocks.managerMaker.primaryToken.info,
+      tokenBalances: [
+        ...new Map(tokenBalanceMocks.storage.entries1WithPrimary).values(),
+      ],
+    })
+    const sortedBalances = {
+      all: sorted,
+      fts: sorted.filter(({info}) => isFt(info)),
+      nfts: sorted.filter(({info}) => isNft(info)),
+    }
+
+    manager.hydrate()
+
+    expect(manager.getPrimaryBreakdown()).toEqual(primaryBalance)
+    expect(manager.getBalances()).toEqual(sortedBalances)
+
+    expect(subscriber).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('destroy', () => {
+  const balanceStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/balance/',
+      id: 'balance',
+    }),
+  )
+  const primaryBreakdownStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/primary-balance-breakdown/',
+      id: 'primary-balance-breakdown',
+    }),
+  )
+  const storage: Portfolio.Storage.Balance = portfolioBalanceStorageMaker({
+    balanceStorage,
+    primaryBreakdownStorage,
+  })
+  const tokenManagerObservable = new BehaviorSubject({} as any).asObservable()
+  const tokenManager: jest.Mocked<Portfolio.Manager.Token> = {
+    destroy: jest.fn(),
+    hydrate: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    observable: tokenManagerObservable,
+    sync: jest.fn().mockResolvedValue(new Map()),
+  }
+  const queueDestroy = jest.fn()
+  const observerDestroy = jest.fn()
+
+  afterEach(() => {
+    storage.clear()
+    tokenInfoStorage.clear()
+  })
+
+  it('should tear down observers', async () => {
+    tokenManager.sync.mockResolvedValue(
+      new Map(tokenInfoMocks.storage.entries1),
+    )
+
+    const tasks: any = []
+    const enqueueMock = jest.fn((task) => tasks.push(task))
+    const mockedNotify = jest.fn()
+
+    const manager = portfolioBalanceManagerMaker(
+      {
+        tokenManager,
+        storage,
+        primaryToken: tokenMocks.managerMaker.primaryToken,
+        sourceId,
+      },
+      {
+        observer: {
+          destroy: observerDestroy,
+          notify: mockedNotify,
+          subscribe: jest.fn(),
+          unsubscribe: jest.fn(),
+          observable: new BehaviorSubject({} as any).asObservable(),
+        },
+        queue: {
+          enqueue: enqueueMock,
+          destroy: queueDestroy,
+          observable: new BehaviorSubject({}).asObservable(),
+        } as any,
+      },
+    )
+
+    manager.destroy()
+
+    expect(observerDestroy).toHaveBeenCalled()
+    expect(queueDestroy).toHaveBeenCalled()
+    expect(tokenManager.unsubscribe).toHaveBeenCalled()
+  })
+})
+
+describe('sync & refresh', () => {
+  const balanceStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/balance/',
+      id: 'balance',
+    }),
+  )
+  const primaryBreakdownStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: '/tmp/primary-balance-breakdown/',
+      id: 'primary-balance-breakdown',
+    }),
+  )
+  const storage: Portfolio.Storage.Balance = portfolioBalanceStorageMaker({
+    balanceStorage,
+    primaryBreakdownStorage,
+  })
+  const tokenManagerObservable = new BehaviorSubject({} as any)
+  const tokenManager: jest.Mocked<Portfolio.Manager.Token> = {
+    destroy: jest.fn(),
+    hydrate: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    observable: tokenManagerObservable.asObservable(),
+    sync: jest.fn().mockResolvedValue(new Map()),
+  }
+
+  afterEach(() => {
+    storage.clear()
+    tokenInfoStorage.clear()
+  })
+
+  const primaryBalance: Readonly<Portfolio.BalancePrimaryBreakdown> = {
+    info: tokenMocks.managerMaker.primaryToken.info,
+    balance: BigInt(1000000),
+    lockedInBuiltTxs: BigInt(0),
+    minRequiredByTokens: BigInt(0),
+    records: [],
+  }
+
+  it('should sync (+hydrate)', async () => {
+    tokenManager.sync.mockResolvedValue(
+      new Map(tokenInfoMocks.storage.entries1),
+    )
+
+    const tasks: any = []
+    const enqueueMock = jest.fn((task) => tasks.push(task))
+    const mockedNotify = jest.fn()
+
+    const manager = portfolioBalanceManagerMaker(
+      {
+        tokenManager,
+        storage,
+        primaryToken: tokenMocks.managerMaker.primaryToken,
+        sourceId,
+      },
+      {
+        observer: {
+          destroy: jest.fn(),
+          notify: mockedNotify,
+          subscribe: jest.fn(),
+          unsubscribe: jest.fn(),
+          observable: new BehaviorSubject({} as any).asObservable(),
+        },
+        queue: {
+          enqueue: enqueueMock,
+          destroy: jest.fn(),
+          observable: new BehaviorSubject({}).asObservable(),
+        } as any,
+      },
+    )
+
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+
+    const secondaryBalances = new Map(
+      tokenBalanceMocks.storage.entries1.slice(0, -1),
+    )
+
+    manager.sync({
+      primaryBalance,
+      secondaryBalances,
+    })
+
+    expect(enqueueMock).toHaveBeenCalled()
+    expect(tasks.length).toBe(1)
+
+    for (const task of tasks) {
+      await task()
+    }
+
+    tasks.length = 0
+
+    expect(manager.getPrimaryBreakdown()).toEqual(expect.anything())
+    expect(manager.getBalances()).toEqual(expect.anything())
+
+    expect(mockedNotify).toHaveBeenCalledTimes(2) // Hydrate + Sync
+
+    tokenManager.sync.mockResolvedValue(
+      new Map(tokenInfoMocks.storage.entries1.slice(0, 1)),
+    )
+
+    // simulate an update coming from another sync on token manager
+    tokenManagerObservable.next({
+      on: Portfolio.Event.ManagerOn.Sync,
+      sourceId: 'another-source',
+      ids: [tokenInfoMocks.nftCryptoKitty.id, tokenInfoMocks.rnftWhatever.id],
+    })
+
+    expect(tasks.length).toBeGreaterThan(0)
+
+    for (const task of tasks) {
+      await task()
+    }
+  })
+
+  it('should refresh', async () => {
+    tokenManager.sync.mockResolvedValue(
+      new Map(tokenInfoMocks.storage.entries1),
+    )
+
+    const tasks: any = []
+    const enqueueMock = jest.fn((task) => tasks.push(task))
+    const mockedNotify = jest.fn()
+
+    const manager = portfolioBalanceManagerMaker(
+      {
+        tokenManager,
+        storage,
+        primaryToken: tokenMocks.managerMaker.primaryToken,
+        sourceId,
+      },
+      {
+        observer: {
+          destroy: jest.fn(),
+          notify: mockedNotify,
+          subscribe: jest.fn(),
+          unsubscribe: jest.fn(),
+          observable: new BehaviorSubject({} as any).asObservable(),
+        },
+        queue: {
+          enqueue: enqueueMock,
+          destroy: jest.fn(),
+          observable: new BehaviorSubject({}).asObservable(),
+        } as any,
+      },
+    )
+
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+
+    const secondaryBalances = new Map(
+      tokenBalanceMocks.storage.entries1.slice(0, -1),
+    )
+
+    manager.sync({
+      primaryBalance,
+      secondaryBalances,
+    })
+
+    manager.refresh()
+
+    expect(enqueueMock).toHaveBeenCalled()
+    expect(tasks.length).toBe(2)
+
+    for (const task of tasks) {
+      await task()
+    }
+
+    tasks.length = 0
+
+    expect(manager.getPrimaryBreakdown()).toEqual(expect.anything())
+    expect(manager.getBalances()).toEqual(expect.anything())
+
+    expect(mockedNotify).toHaveBeenCalledTimes(3) // Hydrate + Sync
+  })
+
+  it('should sync', async () => {
+    tokenManager.sync.mockResolvedValue(
+      new Map(tokenInfoMocks.storage.entries1),
+    )
+
+    const tasks: any = []
+    const enqueueMock = jest.fn((task) => tasks.push(task))
+    const mockedNotify = jest.fn()
+
+    const manager = portfolioBalanceManagerMaker(
+      {
+        tokenManager,
+        storage,
+        primaryToken: tokenMocks.managerMaker.primaryToken,
+        sourceId,
+      },
+      {
+        observer: {
+          destroy: jest.fn(),
+          notify: mockedNotify,
+          subscribe: jest.fn(),
+          unsubscribe: jest.fn(),
+          observable: new BehaviorSubject({} as any).asObservable(),
+        },
+        queue: {
+          enqueue: enqueueMock,
+          destroy: jest.fn(),
+          observable: new BehaviorSubject({}).asObservable(),
+        } as any,
+      },
+    )
+
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+
+    const secondaryBalances = new Map(
+      tokenBalanceMocks.storage.entries1.slice(0, -1),
+    )
+
+    manager.hydrate()
+
+    manager.sync({
+      primaryBalance,
+      secondaryBalances,
+    })
+
+    expect(enqueueMock).toHaveBeenCalled()
+    expect(tasks.length).toBeGreaterThan(0)
+
+    for (const task of tasks) {
+      await task()
+    }
+
+    expect(manager.getPrimaryBreakdown()).toEqual(expect.anything())
+    expect(manager.getBalances()).toEqual(expect.anything())
+
+    expect(mockedNotify).toHaveBeenCalledTimes(2) // Hydrate + Sync
+  })
+
+  it('should throw error if token manager miss a token', async () => {
+    // empty map, should never happen
+    tokenManager.sync.mockResolvedValue(new Map())
+    const tasks: any = []
+    const enqueueMock = jest.fn((task) => tasks.push(task))
+    const mockedNotify = jest.fn()
+
+    const manager = portfolioBalanceManagerMaker(
+      {
+        tokenManager,
+        storage,
+        primaryToken: tokenMocks.managerMaker.primaryToken,
+        sourceId,
+      },
+      {
+        observer: {
+          destroy: jest.fn(),
+          notify: mockedNotify,
+          subscribe: jest.fn(),
+          unsubscribe: jest.fn(),
+          observable: new BehaviorSubject({} as any).asObservable(),
+        },
+        queue: {
+          enqueue: enqueueMock,
+          destroy: jest.fn(),
+          observable: new BehaviorSubject({}).asObservable(),
+        } as any,
+      },
+    )
+
+    const secondaryBalances: Readonly<
+      Map<Portfolio.Token.Id, Portfolio.Token.Balance>
+    > = new Map(tokenBalanceMocks.storage.entries1)
+
+    manager.sync({
+      primaryBalance,
+      secondaryBalances,
+    })
+
+    expect(enqueueMock).toHaveBeenCalled()
+    expect(tasks.length).toBeGreaterThan(0)
+
+    for (const task of tasks) {
+      await expect(() => task()).rejects.toThrow()
+    }
+  })
+})
diff --git a/packages/portfolio/src/balance-manager.ts b/packages/portfolio/src/balance-manager.ts
new file mode 100644
index 0000000000..cdae599144
--- /dev/null
+++ b/packages/portfolio/src/balance-manager.ts
@@ -0,0 +1,331 @@
+import {App, Portfolio} from '@yoroi/types'
+import {
+  hasEntryValue,
+  hasValue,
+  observerMaker,
+  queueTaskMaker,
+} from '@yoroi/common'
+import {freeze} from 'immer'
+import {filter} from 'rxjs'
+
+import {sortTokenBalances} from './helpers/sorting'
+import {TokenInfoAndDiscovery} from './types'
+import {isEventTokenManagerSync} from './validators/token-manager-event-sync'
+import {isFt} from './helpers/is-ft'
+import {isNft} from './helpers/is-nft'
+
+export const portfolioBalanceManagerMaker = (
+  {
+    tokenManager,
+    primaryToken,
+    storage,
+    sourceId,
+  }: {
+    tokenManager: Portfolio.Manager.Token
+    storage: Portfolio.Storage.Balance
+    primaryToken: TokenInfoAndDiscovery
+  } & Portfolio.Event.SourceId,
+  {
+    observer = observerMaker<Portfolio.Event.BalanceManager>(),
+    queue = queueTaskMaker(),
+  }: {
+    observer?: App.ObserverManager<Portfolio.Event.BalanceManager>
+    queue?: App.QueueTaskManager
+  } = {},
+): Portfolio.Manager.Balance => {
+  let isHydrated = false
+  let secondaries: Readonly<Map<Portfolio.Token.Id, Portfolio.Token.Balance>> =
+    freeze(new Map())
+  let sortedBalances: Readonly<{
+    all: ReadonlyArray<Portfolio.Token.Balance>
+    nfts: ReadonlyArray<Portfolio.Token.Balance>
+    fts: ReadonlyArray<Portfolio.Token.Balance>
+  }> = freeze({
+    all: [],
+    nfts: [],
+    fts: [],
+  })
+  let primaryBreakdown: Readonly<Portfolio.BalancePrimaryBreakdown> = freeze(
+    {
+      info: primaryToken.info,
+      balance: 0n,
+      lockedInBuiltTxs: 0n,
+      minRequiredByTokens: 0n,
+      records: [],
+    },
+    true,
+  )
+
+  const sort = sortTokenBalancesWrapper({
+    primaryTokenInfo: primaryToken.info,
+  })
+  const updatePrimary = primaryTokenUpdaterWrapper({
+    primaryTokenInfo: primaryToken.info,
+    storagePrimaryBalanceBreakdown: storage.primaryBalanceBreakdown,
+  })
+
+  const subscription = tokenManager.observable
+    .pipe(
+      filter(() => isHydrated),
+      filter((dtoEvent) => isNotTriggeredBySelf(sourceId)(dtoEvent)),
+      filter(
+        (dtoEvent) =>
+          isEventTokenManagerSync(dtoEvent) &&
+          hasStaleTokenInfo(secondaries)(dtoEvent),
+      ),
+    )
+    .subscribe(() => {
+      queue.enqueue(
+        () =>
+          new Promise<void>((resolve) => {
+            const asyncExecutor = async () => {
+              secondaries = await refreshTokenInfos({
+                tokenManager,
+                secondaries,
+                sourceId,
+              })
+
+              resolve()
+            }
+            asyncExecutor()
+          }),
+      )
+    })
+
+  const hydrate = () => {
+    const cachedPrimaryBreakdown = freeze(
+      storage.primaryBalanceBreakdown.read(primaryToken.info.id),
+      true,
+    )
+    if (cachedPrimaryBreakdown) {
+      primaryBreakdown = cachedPrimaryBreakdown
+    }
+    const primaryTokenBalance: Readonly<Portfolio.Token.Balance> = freeze(
+      {
+        balance: primaryBreakdown.balance,
+        lockedInBuiltTxs: primaryBreakdown.lockedInBuiltTxs,
+        info: primaryToken.info,
+      },
+      true,
+    )
+    secondaries = freeze(
+      new Map(storage.balances.all().filter(hasEntryValue)),
+      true,
+    )
+    const sorted = sort({
+      balances: [...secondaries.values(), primaryTokenBalance],
+    })
+    sortedBalances = splitByType(sorted)
+    isHydrated = true
+
+    observer.notify({on: Portfolio.Event.ManagerOn.Hydrate, sourceId})
+  }
+
+  const refresh = async () =>
+    sync({primaryBalance: primaryBreakdown, secondaryBalances: secondaries})
+
+  const sync = ({
+    primaryBalance,
+    secondaryBalances,
+  }: {
+    primaryBalance: Readonly<Omit<Portfolio.BalancePrimaryBreakdown, 'info'>>
+    secondaryBalances: Readonly<
+      | Map<Portfolio.Token.Id, Omit<Portfolio.Token.Balance, 'info'>>
+      | Map<Portfolio.Token.Id, Portfolio.Token.Balance>
+    >
+  }) => {
+    if (!isHydrated) hydrate()
+
+    queue.enqueue(
+      () =>
+        new Promise<void>((resolve, reject) => {
+          const asyncExecutor = async () => {
+            const secondaryTokenIds = [...secondaryBalances.keys()]
+            const tokenInfos = await tokenManager.sync({
+              secondaryTokenIds,
+              sourceId,
+            })
+
+            const newBalances: Map<
+              Portfolio.Token.Id,
+              Portfolio.Token.Balance
+            > = new Map()
+            secondaryBalances.forEach(({balance, lockedInBuiltTxs}, id) => {
+              const cachedTokenInfo = tokenInfos.get(id)
+              if (!cachedTokenInfo)
+                return reject(
+                  new App.Errors.InvalidState(
+                    'Missing token info in cache should never happen',
+                  ),
+                )
+
+              const tokenBalance: Portfolio.Token.Balance = {
+                info: cachedTokenInfo.record,
+                balance,
+                lockedInBuiltTxs,
+              }
+              newBalances.set(id, tokenBalance)
+            })
+
+            // persist
+            storage.balances.clear()
+            storage.balances.save([...newBalances.entries()])
+
+            const {newPrimaryBreakdown, newPrimaryTokenBalance} =
+              updatePrimary(primaryBalance)
+
+            // update state
+            secondaries = freeze(newBalances, true)
+            const sorted = sort({
+              balances: [...secondaries.values(), newPrimaryTokenBalance],
+            })
+            sortedBalances = splitByType(sorted)
+            primaryBreakdown = newPrimaryBreakdown
+
+            observer.notify({on: Portfolio.Event.ManagerOn.Sync, sourceId})
+            resolve()
+          }
+          asyncExecutor()
+        }),
+    )
+  }
+
+  function getPrimaryBreakdown() {
+    return primaryBreakdown
+  }
+
+  function getBalances() {
+    return sortedBalances
+  }
+
+  function destroy() {
+    observer.destroy()
+    queue.destroy()
+    tokenManager.unsubscribe(subscription)
+  }
+
+  return freeze(
+    {
+      hydrate,
+      refresh,
+      sync,
+
+      subscribe: observer.subscribe,
+      unsubscribe: observer.unsubscribe,
+      observable: observer.observable,
+
+      getPrimaryBreakdown,
+      getBalances,
+      destroy,
+    },
+    true,
+  )
+}
+
+const sortTokenBalancesWrapper =
+  ({primaryTokenInfo}: {primaryTokenInfo: Portfolio.Token.Info}) =>
+  ({
+    balances,
+  }: {
+    balances: ReadonlyArray<Portfolio.Token.Balance | null | undefined>
+  }) =>
+    freeze(
+      sortTokenBalances({
+        tokenBalances: balances.filter(hasValue),
+        primaryTokenInfo,
+      }),
+      true,
+    )
+
+const isNotTriggeredBySelf =
+  (sourceId: Portfolio.Event.SourceId['sourceId']) =>
+  (dtoEvent: Portfolio.Event.TokenManager) =>
+    dtoEvent.sourceId !== sourceId
+
+const hasStaleTokenInfo =
+  (
+    secondaries: Readonly<Map<`${string}.${string}`, Portfolio.Token.Balance>>,
+  ) =>
+  (dtoEvent: Portfolio.Event.TokenManagerSync) =>
+    dtoEvent.ids.some((id) => secondaries.has(id))
+
+const refreshTokenInfos = async ({
+  tokenManager,
+  secondaries,
+  sourceId,
+}: {
+  tokenManager: Portfolio.Manager.Token
+  secondaries: Readonly<Map<Portfolio.Token.Id, Portfolio.Token.Balance | null>>
+} & Portfolio.Event.SourceId) => {
+  const tokenInfos = await tokenManager.sync({
+    secondaryTokenIds: [...secondaries.keys()],
+    sourceId,
+  })
+
+  const newBalances: Array<[Portfolio.Token.Id, Portfolio.Token.Balance]> = [
+    ...secondaries.values(),
+  ]
+    .filter(hasValue)
+    .map((balance) => {
+      const newBalance: Portfolio.Token.Balance = {
+        ...balance,
+        info: tokenInfos.get(balance.info.id)?.record ?? balance.info,
+      }
+      return [newBalance.info.id, newBalance]
+    })
+
+  return freeze(new Map(newBalances), true)
+}
+
+const splitByType = (
+  sortedBalances: ReadonlyArray<Portfolio.Token.Balance>,
+) => {
+  return freeze(
+    {
+      all: sortedBalances,
+      fts: sortedBalances.filter(({info}) => isFt(info)),
+      nfts: sortedBalances.filter(({info}) => isNft(info)),
+    },
+    true,
+  )
+}
+
+const primaryTokenUpdaterWrapper =
+  ({
+    storagePrimaryBalanceBreakdown,
+    primaryTokenInfo,
+  }: Readonly<{
+    storagePrimaryBalanceBreakdown: Portfolio.Storage.Balance['primaryBalanceBreakdown']
+    primaryTokenInfo: Portfolio.Token.Info
+  }>) =>
+  (
+    primaryBalance: Readonly<Omit<Portfolio.BalancePrimaryBreakdown, 'info'>>,
+  ) => {
+    const newPrimaryBreakdown: Readonly<Portfolio.BalancePrimaryBreakdown> = {
+      ...primaryBalance,
+      info: primaryTokenInfo,
+    }
+    const newPrimaryTokenBalance: Readonly<Portfolio.Token.Balance> = freeze(
+      {
+        balance: primaryBalance.balance,
+        lockedInBuiltTxs: primaryBalance.lockedInBuiltTxs,
+        info: primaryTokenInfo,
+      },
+      true,
+    )
+    storagePrimaryBalanceBreakdown.clear()
+    storagePrimaryBalanceBreakdown.save(newPrimaryBreakdown)
+    return freeze({newPrimaryBreakdown, newPrimaryTokenBalance}, true)
+  }
+
+// TODO list
+// - [ ] Allow users to specify custom properties
+// - [ ] Allow users to create baskets for tokens
+// - [ ] Allow users to add tokens to baskets
+// - [ ] Allow users to remove tokens from baskets
+// - [ ] Allow users to delete baskets
+// - [ ] - getBaskets + Baskets event
+// - [ ] Allow users to mark tokens as favorite
+// - [ ] Allow users to mark to auto-garbage tokens
+// - [ ] Allow users to ban tokens (mark as scam)
+// - [ ] - override token info + discovery + Event
diff --git a/packages/portfolio/src/helpers/create-cached-unknown-token-info.test.ts b/packages/portfolio/src/helpers/create-cached-unknown-token-info.test.ts
new file mode 100644
index 0000000000..816a61b4c3
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-cached-unknown-token-info.test.ts
@@ -0,0 +1,20 @@
+import {createCachedUnknownTokenInfo} from './create-cached-unknown-token-info'
+import {createUnknownTokenInfo} from './create-unknown-token-info'
+
+describe('createCachedUnknownTokenInfo', () => {
+  it('should create a cached unknown token info', () => {
+    const id = 'token.id'
+    const expectedName = 'Unknown (id)'
+    const expectedUnknownTokenInfo = {
+      record: createUnknownTokenInfo({id, name: expectedName}),
+      expires: 0,
+      hash: '',
+    }
+
+    const cachedUnknownTokenInfo = createCachedUnknownTokenInfo(id)
+
+    expect(cachedUnknownTokenInfo.expires).toBe(0)
+    expect(cachedUnknownTokenInfo.hash).toBe('')
+    expect(cachedUnknownTokenInfo).toEqual(expectedUnknownTokenInfo)
+  })
+})
diff --git a/packages/portfolio/src/helpers/create-cached-unknown-token-info.ts b/packages/portfolio/src/helpers/create-cached-unknown-token-info.ts
new file mode 100644
index 0000000000..e74a24d914
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-cached-unknown-token-info.ts
@@ -0,0 +1,16 @@
+import {App, Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+import {createUnknownTokenInfo} from './create-unknown-token-info'
+
+export const createCachedUnknownTokenInfo = (
+  id: Portfolio.Token.Id,
+): Readonly<App.CacheRecord<Portfolio.Token.Info>> => {
+  const [, assetNameHex] = id.split('.')
+  const name = `Unknown (${assetNameHex})`
+  const unknownTokenInfo = createUnknownTokenInfo({id, name})
+  const cachedUnknownTokenInfo: Readonly<
+    App.CacheRecord<Portfolio.Token.Info>
+  > = freeze({expires: 0, hash: '', record: unknownTokenInfo} as const, true)
+  return cachedUnknownTokenInfo
+}
diff --git a/packages/portfolio/src/helpers/create-primary-token-info.test.ts b/packages/portfolio/src/helpers/create-primary-token-info.test.ts
new file mode 100644
index 0000000000..4a6e81e56a
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-primary-token-info.test.ts
@@ -0,0 +1,35 @@
+import {Portfolio} from '@yoroi/types'
+import {createPrimaryTokenInfo} from './create-primary-token-info'
+
+describe('createPrimaryTokenInfo', () => {
+  it('should create primary token info with additional properties', () => {
+    const cardanoPtMainnet: Omit<
+      Portfolio.Token.Info,
+      'id' | 'nature' | 'type' | 'application' | 'fingerprint' | 'status'
+    > = {
+      name: 'Cardano',
+      symbol: '₳',
+      decimals: 6,
+      originalImage: '',
+      reference: '',
+      tag: '',
+      ticker: 'ADA',
+      website: 'https://cardano.org/',
+    }
+
+    const expectedTokenInfo: Readonly<Portfolio.Token.Info> = {
+      id: '.',
+      nature: Portfolio.Token.Nature.Primary,
+      type: Portfolio.Token.Type.FT,
+      application: Portfolio.Token.Application.Coin,
+      fingerprint: '',
+      status: Portfolio.Token.Status.Valid,
+      ...cardanoPtMainnet,
+    }
+
+    const result = createPrimaryTokenInfo(cardanoPtMainnet)
+
+    expect(result).toEqual(expectedTokenInfo)
+    expect(Object.isFrozen(result)).toBe(true)
+  })
+})
diff --git a/packages/portfolio/src/helpers/create-primary-token-info.ts b/packages/portfolio/src/helpers/create-primary-token-info.ts
new file mode 100644
index 0000000000..11e50a1f9e
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-primary-token-info.ts
@@ -0,0 +1,22 @@
+import {Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+export function createPrimaryTokenInfo(
+  additionalProperties: Omit<
+    Portfolio.Token.Info,
+    'id' | 'nature' | 'type' | 'application' | 'fingerprint' | 'status'
+  >,
+): Readonly<Portfolio.Token.Info> {
+  return freeze(
+    {
+      id: '.', // Enforcing the use of '.' for primary tokens
+      nature: Portfolio.Token.Nature.Primary,
+      type: Portfolio.Token.Type.FT,
+      application: Portfolio.Token.Application.Coin,
+      fingerprint: '',
+      status: Portfolio.Token.Status.Valid,
+      ...additionalProperties,
+    },
+    true,
+  )
+}
diff --git a/packages/portfolio/src/helpers/create-unknown-token-info.test.ts b/packages/portfolio/src/helpers/create-unknown-token-info.test.ts
new file mode 100644
index 0000000000..3347c445ca
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-unknown-token-info.test.ts
@@ -0,0 +1,33 @@
+import {Portfolio} from '@yoroi/types'
+
+import {createUnknownTokenInfo} from './create-unknown-token-info'
+
+describe('createPrimaryTokenInfo', () => {
+  it('should create secondary token info with additional properties', () => {
+    const cardanoUnknownToken: Pick<Portfolio.Token.Info, 'name' | 'id'> = {
+      id: '14696a4676909f4e3cb1f2e60e2e08e5abed70caf5c02699be971139.35',
+      name: '35 (unknown)',
+    }
+
+    const expectedTokenInfo: Readonly<Portfolio.Token.Info> = {
+      nature: Portfolio.Token.Nature.Secondary,
+      type: Portfolio.Token.Type.FT,
+      application: Portfolio.Token.Application.General,
+      status: Portfolio.Token.Status.Unknown,
+      fingerprint: '',
+      symbol: '',
+      decimals: 0,
+      reference: '',
+      tag: '',
+      ticker: '',
+      website: '',
+      originalImage: '',
+      ...cardanoUnknownToken,
+    }
+
+    const result = createUnknownTokenInfo(cardanoUnknownToken)
+
+    expect(result).toEqual(expectedTokenInfo)
+    expect(Object.isFrozen(result)).toBe(true)
+  })
+})
diff --git a/packages/portfolio/src/helpers/create-unknown-token-info.ts b/packages/portfolio/src/helpers/create-unknown-token-info.ts
new file mode 100644
index 0000000000..3ac3468773
--- /dev/null
+++ b/packages/portfolio/src/helpers/create-unknown-token-info.ts
@@ -0,0 +1,25 @@
+import {Portfolio} from '@yoroi/types'
+import {freeze} from 'immer'
+
+export function createUnknownTokenInfo(
+  additionalProperties: Pick<Portfolio.Token.Info, 'id' | 'name'>,
+): Readonly<Portfolio.Token.Info> {
+  return freeze(
+    {
+      reference: '',
+      tag: '',
+      ticker: '',
+      website: '',
+      decimals: 0,
+      symbol: '',
+      fingerprint: '',
+      originalImage: '',
+      nature: Portfolio.Token.Nature.Secondary,
+      type: Portfolio.Token.Type.FT,
+      application: Portfolio.Token.Application.General,
+      status: Portfolio.Token.Status.Unknown,
+      ...additionalProperties,
+    },
+    true,
+  )
+}
diff --git a/packages/portfolio/src/helpers/is-ft.test.ts b/packages/portfolio/src/helpers/is-ft.test.ts
new file mode 100644
index 0000000000..51fc91c6aa
--- /dev/null
+++ b/packages/portfolio/src/helpers/is-ft.test.ts
@@ -0,0 +1,16 @@
+import {tokenMocks} from '../adapters/token.mocks'
+import {isFt} from './is-ft'
+
+describe('isFt', () => {
+  it('should return true for FT token', () => {
+    const result = isFt(tokenMocks.primaryETH.info)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for non-FT token', () => {
+    const result = isFt(tokenMocks.nftCryptoKitty.info)
+
+    expect(result).toBe(false)
+  })
+})
diff --git a/packages/portfolio/src/helpers/is-ft.ts b/packages/portfolio/src/helpers/is-ft.ts
new file mode 100644
index 0000000000..ba1f745b17
--- /dev/null
+++ b/packages/portfolio/src/helpers/is-ft.ts
@@ -0,0 +1,4 @@
+import {Portfolio} from '@yoroi/types'
+
+export const isFt = (tokenInfo: Portfolio.Token.Info): boolean =>
+  tokenInfo.type === Portfolio.Token.Type.FT
diff --git a/packages/portfolio/src/helpers/is-nft.test.ts b/packages/portfolio/src/helpers/is-nft.test.ts
new file mode 100644
index 0000000000..4885047c2a
--- /dev/null
+++ b/packages/portfolio/src/helpers/is-nft.test.ts
@@ -0,0 +1,16 @@
+import {tokenMocks} from '../adapters/token.mocks'
+import {isNft} from './is-nft'
+
+describe('isNft', () => {
+  it('should return true for NFT token', () => {
+    const result = isNft(tokenMocks.nftCryptoKitty.info)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for non-NFT token', () => {
+    const result = isNft(tokenMocks.primaryETH.info)
+
+    expect(result).toBe(false)
+  })
+})
diff --git a/packages/portfolio/src/helpers/is-nft.ts b/packages/portfolio/src/helpers/is-nft.ts
new file mode 100644
index 0000000000..42db8134d0
--- /dev/null
+++ b/packages/portfolio/src/helpers/is-nft.ts
@@ -0,0 +1,4 @@
+import {Portfolio} from '@yoroi/types'
+
+export const isNft = (tokenInfo: Portfolio.Token.Info): boolean =>
+  tokenInfo.type === Portfolio.Token.Type.NFT
diff --git a/packages/portfolio/src/helpers/sorting.test.ts b/packages/portfolio/src/helpers/sorting.test.ts
new file mode 100644
index 0000000000..9151c669cb
--- /dev/null
+++ b/packages/portfolio/src/helpers/sorting.test.ts
@@ -0,0 +1,160 @@
+import {Portfolio} from '@yoroi/types'
+import {storageSerializer} from '@yoroi/common'
+
+import {tokenBalanceMocks} from '../adapters/token-balance.mocks'
+import {tokenInfoMocks} from '../adapters/token-info.mocks'
+import {
+  alpha,
+  sortTokenBalances,
+  sortTokenInfos,
+  toEnd,
+  toStart,
+} from './sorting'
+
+describe('sorting', () => {
+  it('sorts alphabetically', () => {
+    const sortedItems = [...items].sort(
+      alpha((name) => name.toLocaleLowerCase()),
+    )
+    // prettier-ignore
+    expect(sortedItems).toEqual([
+      '', 
+      'a', 
+      'a', 
+      'b', 
+      'c'
+    ])
+  })
+
+  it('moves items to the start', () => {
+    const sortedItems = [...items].sort(toStart((name) => name === 'c'))
+    // prettier-ignore
+    expect(sortedItems).toEqual([
+      'c', 
+      'a', 
+      '', 
+      'b', 
+      'a'
+    ])
+  })
+
+  it('moves items to the end', () => {
+    const sortedItems = [...items].sort(toEnd((name) => name === 'c'))
+    // prettier-ignore
+    expect(sortedItems).toEqual([
+      'a', 
+      '', 
+      'b', 
+      'a', 
+      'c'
+    ])
+  })
+
+  it('sort token infos', () => {
+    const primaryTokenInfo = tokenInfoMocks.primaryETH
+    const secondaryTokenInfos = [
+      tokenInfoMocks.ftNoTicker,
+      tokenInfoMocks.ftNameless,
+      tokenInfoMocks.nftCryptoKitty,
+      tokenInfoMocks.rnftWhatever,
+      primaryTokenInfo,
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Unknown},
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Invalid},
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Scam},
+    ]
+
+    const sortedTokenInfos = sortTokenInfos({
+      primaryTokenInfo,
+      secondaryTokenInfos,
+    })
+
+    expect(sortedTokenInfos).toEqual([
+      primaryTokenInfo,
+      tokenInfoMocks.nftCryptoKitty,
+      tokenInfoMocks.rnftWhatever,
+      tokenInfoMocks.ftNameless,
+      tokenInfoMocks.ftNoTicker,
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Unknown},
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Invalid},
+      {...tokenInfoMocks.ftNoTicker, status: Portfolio.Token.Status.Scam},
+    ])
+  })
+
+  it('sort token balances', () => {
+    const primaryTokenInfo = tokenInfoMocks.primaryETH
+    const tokenBalances = [
+      tokenBalanceMocks.ftNoTicker,
+      tokenBalanceMocks.nftCryptoKitty,
+      tokenBalanceMocks.ftNameless,
+      tokenBalanceMocks.rnftWhatever,
+      tokenBalanceMocks.primaryETH,
+      {
+        ...tokenBalanceMocks.ftNoTicker,
+        info: {
+          ...tokenBalanceMocks.ftNoTicker.info,
+          status: Portfolio.Token.Status.Unknown,
+        },
+      },
+      {
+        ...tokenBalanceMocks.ftNoTicker,
+        info: {
+          ...tokenBalanceMocks.ftNoTicker.info,
+          status: Portfolio.Token.Status.Invalid,
+        },
+      },
+      {
+        ...tokenBalanceMocks.ftNoTicker,
+        info: {
+          ...tokenBalanceMocks.ftNoTicker.info,
+          status: Portfolio.Token.Status.Scam,
+        },
+      },
+    ]
+
+    const sortedTokenBalances = sortTokenBalances({
+      primaryTokenInfo,
+      tokenBalances,
+    })
+
+    const serialized = sortedTokenBalances.map(storageSerializer)
+    expect(serialized).toEqual(
+      [
+        tokenBalanceMocks.primaryETH,
+        tokenBalanceMocks.nftCryptoKitty,
+        tokenBalanceMocks.rnftWhatever,
+        tokenBalanceMocks.ftNameless,
+        tokenBalanceMocks.ftNoTicker,
+        {
+          ...tokenBalanceMocks.ftNoTicker,
+          info: {
+            ...tokenBalanceMocks.ftNoTicker.info,
+            status: Portfolio.Token.Status.Unknown,
+          },
+        },
+        {
+          ...tokenBalanceMocks.ftNoTicker,
+          info: {
+            ...tokenBalanceMocks.ftNoTicker.info,
+            status: Portfolio.Token.Status.Invalid,
+          },
+        },
+        {
+          ...tokenBalanceMocks.ftNoTicker,
+          info: {
+            ...tokenBalanceMocks.ftNoTicker.info,
+            status: Portfolio.Token.Status.Scam,
+          },
+        },
+      ].map(storageSerializer),
+    )
+  })
+})
+
+// prettier-ignore
+const items = [
+  'a', 
+  '', 
+  'c', 
+  'b', 
+  'a'
+]
diff --git a/packages/portfolio/src/helpers/sorting.ts b/packages/portfolio/src/helpers/sorting.ts
new file mode 100644
index 0000000000..260d941894
--- /dev/null
+++ b/packages/portfolio/src/helpers/sorting.ts
@@ -0,0 +1,104 @@
+import {Portfolio} from '@yoroi/types'
+
+export const alpha =
+  <T>(transform: Transform<T>) =>
+  (a: T, b: T) =>
+    transform(a).localeCompare(transform(b))
+
+export const toEnd =
+  <T>(predicate: (a: T) => boolean) =>
+  (a: T, b: T) =>
+    predicate(a) ? 1 : predicate(b) ? -1 : 0
+
+export const toStart =
+  <T>(predicate: (a: T) => boolean) =>
+  (a: T, b: T) =>
+    predicate(a) ? -1 : predicate(b) ? 1 : 0
+
+export const sortTokenInfos = ({
+  primaryTokenInfo,
+  secondaryTokenInfos,
+}: {
+  primaryTokenInfo: Readonly<Portfolio.Token.Info>
+  secondaryTokenInfos: ReadonlyArray<Portfolio.Token.Info>
+}): ReadonlyArray<Portfolio.Token.Info> =>
+  [...secondaryTokenInfos]
+    .sort(
+      alpha<Portfolio.Token.Info>((tokenInfo) => {
+        switch (tokenInfo.type) {
+          case Portfolio.Token.Type.FT: {
+            if (tokenInfo.ticker !== '')
+              return tokenInfo.ticker.toLocaleLowerCase()
+            return tokenInfo.name.toLocaleLowerCase()
+          }
+          case Portfolio.Token.Type.NFT:
+            return tokenInfo.name.toLocaleLowerCase()
+        }
+      }),
+    )
+    .sort(
+      toEnd<Portfolio.Token.Info>((tokenInfo) => {
+        switch (tokenInfo.status) {
+          case Portfolio.Token.Status.Unknown:
+            return true
+          case Portfolio.Token.Status.Invalid:
+            return true
+          case Portfolio.Token.Status.Scam:
+            return true
+        }
+
+        switch (tokenInfo.type) {
+          case Portfolio.Token.Type.FT:
+            return !tokenInfo.ticker && !tokenInfo.name
+          case Portfolio.Token.Type.NFT:
+            return !tokenInfo.name
+        }
+      }),
+    )
+    .sort(toStart((tokenInfo) => tokenInfo.id === primaryTokenInfo.id))
+
+export const sortTokenBalances = ({
+  primaryTokenInfo,
+  tokenBalances,
+}: {
+  primaryTokenInfo: Readonly<Portfolio.Token.Info>
+  tokenBalances: ReadonlyArray<Portfolio.Token.Balance>
+}): ReadonlyArray<Portfolio.Token.Balance> =>
+  [...tokenBalances]
+    .sort(
+      alpha<Portfolio.Token.Balance>((tokenBalance) => {
+        switch (tokenBalance.info.type) {
+          case Portfolio.Token.Type.FT: {
+            if (tokenBalance.info.ticker !== '')
+              return tokenBalance.info.ticker.toLocaleLowerCase()
+            return tokenBalance.info.name.toLocaleLowerCase()
+          }
+          case Portfolio.Token.Type.NFT:
+            return tokenBalance.info.name.toLocaleLowerCase()
+        }
+      }),
+    )
+    .sort(
+      toEnd<Portfolio.Token.Balance>((tokenBalance) => {
+        switch (tokenBalance.info.status) {
+          case Portfolio.Token.Status.Unknown:
+            return true
+          case Portfolio.Token.Status.Invalid:
+            return true
+          case Portfolio.Token.Status.Scam:
+            return true
+        }
+
+        switch (tokenBalance.info.type) {
+          case Portfolio.Token.Type.FT:
+            return !tokenBalance.info.ticker && !tokenBalance.info.name
+          case Portfolio.Token.Type.NFT:
+            return !tokenBalance.info.name
+        }
+      }),
+    )
+    .sort(
+      toStart((tokenBalance) => tokenBalance.info.id === primaryTokenInfo.id),
+    )
+
+type Transform<T> = (a: T) => string
diff --git a/packages/portfolio/src/index.ts b/packages/portfolio/src/index.ts
new file mode 100644
index 0000000000..99a11f14d7
--- /dev/null
+++ b/packages/portfolio/src/index.ts
@@ -0,0 +1,33 @@
+export * from './helpers/create-primary-token-info'
+export * from './helpers/sorting'
+
+export * from './adapters/amount.mocks'
+export * from './adapters/dullahan-api/api-maker.mocks'
+export * from './adapters/dullahan-api/api-maker'
+export * from './adapters/mmkv-storage/balance-storage-maker'
+export * from './adapters/mmkv-storage/token-storage-maker'
+export * from './adapters/token-balance.mocks'
+export * from './adapters/token-discovery.mocks'
+export * from './adapters/token-info.mocks'
+export * from './adapters/token.mocks'
+
+export * from './transformers/deserializers'
+
+export * from './validators/amount'
+export * from './validators/primary-balance-breakdown'
+export * from './validators/response-record-with-cache-schema-maker'
+export * from './validators/token-application'
+export * from './validators/token-balance'
+export * from './validators/token-discovery'
+export * from './validators/token-id'
+export * from './validators/token-info'
+export * from './validators/token-nature'
+export * from './validators/token-property-type'
+export * from './validators/token-source'
+export * from './validators/token-status'
+export * from './validators/token-type'
+
+export * from './balance-manager'
+export * from './token-manager'
+
+export * from './types'
diff --git a/packages/portfolio/src/token-manager.test.ts b/packages/portfolio/src/token-manager.test.ts
new file mode 100644
index 0000000000..5538431d13
--- /dev/null
+++ b/packages/portfolio/src/token-manager.test.ts
@@ -0,0 +1,185 @@
+import {mountMMKVStorage, observableStorageMaker} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+
+import {portfolioTokenManagerMaker} from './token-manager'
+import {portfolioTokenStorageMaker} from './adapters/mmkv-storage/token-storage-maker'
+import {portfolioApiMock} from './adapters/dullahan-api/api-maker.mocks'
+import {tokenInfoMocks} from './adapters/token-info.mocks'
+import {createCachedUnknownTokenInfo} from './helpers/create-cached-unknown-token-info'
+
+describe('portfolioTokenManagerMaker', () => {
+  const tokenInfoStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: `/test/token-info/`,
+    }),
+  )
+  const tokenDiscoveryStorage = observableStorageMaker(
+    mountMMKVStorage<Portfolio.Token.Id>({
+      path: `/test/token-discovery/`,
+    }),
+  )
+  const storage = portfolioTokenStorageMaker({
+    tokenInfoStorage,
+    tokenDiscoveryStorage,
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+    storage.clear()
+  })
+
+  it('should hydrate the cache', () => {
+    const api = portfolioApiMock.success
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+
+    manager.hydrate({sourceId: 'sourceId'})
+
+    expect(subscriber).toHaveBeenCalledTimes(1)
+    expect(subscriber).toHaveBeenCalledWith({
+      on: Portfolio.Event.ManagerOn.Hydrate,
+      sourceId: 'sourceId',
+    })
+  })
+
+  it('should sync token infos with unknowns', async () => {
+    storage.token.infos.save(tokenInfoMocks.storage.notModified)
+    const api = portfolioApiMock.success
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const unknownTokenId: Portfolio.Token.Id = 'unknown.id'
+    const secondaryTokenIds = [
+      tokenInfoMocks.rnftWhatever.id,
+      tokenInfoMocks.nftCryptoKitty.id,
+      unknownTokenId,
+    ]
+    manager.hydrate({sourceId: 'sourceId'})
+    const subscriber = jest.fn()
+    manager.subscribe(subscriber)
+    const unknownCachedTokenInfo = createCachedUnknownTokenInfo(unknownTokenId)
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(subscriber).toHaveBeenCalledTimes(1)
+    expect(subscriber).toHaveBeenCalledWith({
+      on: Portfolio.Event.ManagerOn.Sync,
+      ids: expect.arrayContaining(secondaryTokenIds.slice(1)),
+      sourceId: 'sourceId',
+    })
+
+    expect(result.size).toBe(3)
+
+    // should update the stale cache records with api data and refresh cache info
+    const resultNftCryptoKitty = result.get(tokenInfoMocks.nftCryptoKitty.id)
+    if (!resultNftCryptoKitty) fail()
+    expect(resultNftCryptoKitty.expires).toBeGreaterThan(Date.now())
+    expect(resultNftCryptoKitty.hash).toBe('hash2-1')
+    expect(resultNftCryptoKitty.record).toEqual(tokenInfoMocks.nftCryptoKitty)
+
+    // should create unknown token info when api doesn't return it
+    // creates expired so it will always hit the api when syncing
+    const resultUnknownToken = result.get(unknownTokenId)
+    if (!resultUnknownToken) fail()
+    expect(resultUnknownToken.expires).toBe(0)
+    expect(resultUnknownToken.hash).toBe('')
+    expect(resultUnknownToken.record).toEqual(unknownCachedTokenInfo.record)
+
+    // should return the cached record when api returns NotModified
+    // yet, should update the expires but not the hash
+    const resultRnftWhatever = result.get(tokenInfoMocks.rnftWhatever.id)
+    if (!resultRnftWhatever) fail()
+    expect(resultRnftWhatever.expires).toBeGreaterThan(Date.now())
+    expect(resultRnftWhatever.hash).toBe('hash3')
+    expect(resultRnftWhatever.record).toEqual(tokenInfoMocks.rnftWhatever)
+  })
+
+  it('should read all from cache', async () => {
+    storage.token.infos.save(tokenInfoMocks.storage.cached)
+    const api = portfolioApiMock.success
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const secondaryTokenIds = [tokenInfoMocks.rnftWhatever.id]
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(result.size).toBe(1)
+
+    // should return the cached record and not hit the api
+    const resultRnftWhatever = result.get(tokenInfoMocks.rnftWhatever.id)
+    if (!resultRnftWhatever) fail()
+    expect(resultRnftWhatever.expires).toBeGreaterThan(Date.now())
+    expect(resultRnftWhatever.hash).toBe('hash3')
+    expect(resultRnftWhatever.record).toEqual(tokenInfoMocks.rnftWhatever)
+  })
+
+  it('should create as unknwon when api error', async () => {
+    const api = portfolioApiMock.error
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const secondaryTokenIds = [tokenInfoMocks.rnftWhatever.id]
+    const unknownCachedTokenInfo = createCachedUnknownTokenInfo(
+      tokenInfoMocks.rnftWhatever.id,
+    )
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(result.size).toBe(1)
+
+    // should return the unknown record
+    const resultRnftWhatever = result.get(tokenInfoMocks.rnftWhatever.id)
+    if (!resultRnftWhatever) fail()
+    expect(resultRnftWhatever).toEqual(unknownCachedTokenInfo)
+  })
+
+  it('should call destroy (coverage) observer is not exposed', () => {
+    const api = portfolioApiMock.success
+    const manager = portfolioTokenManagerMaker({api, storage})
+
+    manager.destroy()
+  })
+
+  it('should revalidate cache', async () => {
+    const api = portfolioApiMock.success
+    storage.token.infos.save(tokenInfoMocks.storage.notModified)
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const secondaryTokenIds = [tokenInfoMocks.rnftWhatever.id]
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(result.size).toBe(1)
+
+    // should return the unknown record
+    const resultRnftWhatever = result.get(tokenInfoMocks.rnftWhatever.id)
+    if (!resultRnftWhatever) fail()
+    expect(resultRnftWhatever.expires).toBeGreaterThan(Date.now())
+    expect(resultRnftWhatever.hash).toBe('hash3')
+    expect(resultRnftWhatever.record).toEqual(tokenInfoMocks.rnftWhatever)
+  })
+
+  it('should sync empty', async () => {
+    const api = portfolioApiMock.success
+    storage.token.infos.save(tokenInfoMocks.storage.notModified)
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const secondaryTokenIds: Portfolio.Token.Id[] = []
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(result.size).toBe(0)
+  })
+
+  it('should sync empty to revalidate', async () => {
+    const api = portfolioApiMock.success
+    const manager = portfolioTokenManagerMaker({api, storage})
+    const secondaryTokenIds: Portfolio.Token.Id[] = [
+      tokenInfoMocks.rnftWhatever.id,
+    ]
+    const unknownCachedTokenInfo = createCachedUnknownTokenInfo(
+      tokenInfoMocks.rnftWhatever.id,
+    )
+
+    const result = await manager.sync({secondaryTokenIds, sourceId: 'sourceId'})
+
+    expect(result.size).toBe(1)
+    const resultRnftWhatever = result.get(tokenInfoMocks.rnftWhatever.id)
+    if (!resultRnftWhatever) fail()
+    expect(resultRnftWhatever).toEqual(unknownCachedTokenInfo)
+  })
+})
diff --git a/packages/portfolio/src/token-manager.ts b/packages/portfolio/src/token-manager.ts
new file mode 100644
index 0000000000..9a1981f631
--- /dev/null
+++ b/packages/portfolio/src/token-manager.ts
@@ -0,0 +1,98 @@
+import {App, Portfolio} from '@yoroi/types'
+import {
+  cacheManageMultiRequest,
+  extractEntryCacheInfo,
+  hasEntryValue,
+  observerMaker,
+} from '@yoroi/common'
+import {freeze} from 'immer'
+
+import {createCachedUnknownTokenInfo} from './helpers/create-cached-unknown-token-info'
+
+export const portfolioTokenManagerMaker = (
+  {
+    api,
+    storage,
+  }: {
+    api: Portfolio.Api.Api
+    storage: Portfolio.Storage.Token
+  },
+  {
+    observer = observerMaker<Portfolio.Event.TokenManager>(),
+  }: {observer?: App.ObserverManager<Portfolio.Event.TokenManager>} = {},
+) => {
+  let isHydrated = false
+  const cachedInfosWithoutRecord: Readonly<
+    Map<Portfolio.Token.Id, App.CacheInfo>
+  > = new Map()
+
+  const hydrate = ({sourceId}: Portfolio.Event.SourceId) => {
+    // load only the cache info, drop the record
+    storage.token.infos
+      .all()
+      .map(extractEntryCacheInfo)
+      .filter(hasEntryValue)
+      .forEach(([id, value]) => cachedInfosWithoutRecord.set(id, freeze(value)))
+
+    isHydrated = true
+    observer.notify({on: Portfolio.Event.ManagerOn.Hydrate, sourceId})
+  }
+
+  const sync = async ({
+    secondaryTokenIds,
+    sourceId,
+  }: {
+    secondaryTokenIds: ReadonlyArray<Portfolio.Token.Id>
+  } & Portfolio.Event.SourceId) => {
+    if (!isHydrated) hydrate({sourceId})
+
+    const {records, unknownIds, updatedIds, isInvalidated} =
+      await cacheManageMultiRequest<Portfolio.Token.Id, Portfolio.Token.Info>({
+        request: async (ids) => api.tokenInfos(ids),
+        cachedInfosWithoutRecord: freeze(new Map(cachedInfosWithoutRecord)),
+        ids: secondaryTokenIds,
+        unknownRecordFactory: createCachedUnknownTokenInfo,
+        persistance: freeze({
+          save: storage.token.infos.save,
+          read: storage.token.infos.read,
+        }),
+      })
+
+    const recordsEntries = [...records.entries()]
+    recordsEntries
+      .map(extractEntryCacheInfo)
+      .filter(hasEntryValue)
+      .forEach(([id, record]) =>
+        cachedInfosWithoutRecord.set(id, freeze(record)),
+      )
+
+    // if the cache was invalidated, notify
+    if (isInvalidated)
+      observer.notify({
+        on: Portfolio.Event.ManagerOn.Sync,
+        ids: [...updatedIds, ...unknownIds],
+        sourceId,
+      })
+
+    // when using subscriptions, or streams, read from storage base on callback args, not from this return
+    return records
+  }
+
+  function destroy() {
+    observer.destroy()
+  }
+
+  return freeze(
+    {
+      hydrate,
+      sync,
+
+      subscribe: observer.subscribe,
+      unsubscribe: observer.unsubscribe,
+      observable: observer.observable,
+
+      destroy,
+    },
+    true,
+  )
+}
diff --git a/packages/portfolio/src/transformers/deserializer.test.ts b/packages/portfolio/src/transformers/deserializer.test.ts
new file mode 100644
index 0000000000..1af1167167
--- /dev/null
+++ b/packages/portfolio/src/transformers/deserializer.test.ts
@@ -0,0 +1,73 @@
+import {cacheRecordMaker, storageSerializer} from '@yoroi/common'
+
+import {deserializers} from './deserializers'
+import {tokenDiscoveryMocks} from '../adapters/token-discovery.mocks'
+import {tokenBalanceMocks} from '../adapters/token-balance.mocks'
+
+describe('deserializers', () => {
+  describe('tokenDiscovery', () => {
+    it('should deserialize valid JSON string', () => {
+      const record = cacheRecordMaker(
+        {expires: 1, hash: 'hash'},
+        tokenDiscoveryMocks.primaryETH,
+      )
+      const jsonString = storageSerializer(record)
+      const result = deserializers.tokenDiscoveryWithCache(jsonString)
+      expect(result).toEqual(record)
+    })
+
+    it('should return null for null input', () => {
+      const jsonString = null
+      const result = deserializers.tokenDiscoveryWithCache(jsonString)
+      expect(result).toBeNull()
+    })
+
+    it('should return null for invalid JSON string', () => {
+      const jsonString = 'invalid-json'
+      const result = deserializers.tokenDiscoveryWithCache(jsonString)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('tokenBalance', () => {
+    it('should deserialize valid JSON string', () => {
+      const jsonString = storageSerializer(tokenBalanceMocks.primaryETH)
+      const result = deserializers.tokenBalance(jsonString)
+      expect(result).toEqual(tokenBalanceMocks.primaryETH)
+    })
+
+    it('should return null for null input', () => {
+      const jsonString = null
+      const result = deserializers.tokenBalance(jsonString)
+      expect(result).toBeNull()
+    })
+
+    it('should return null for invalid JSON string', () => {
+      const jsonString = 'invalid-json'
+      const result = deserializers.tokenBalance(jsonString)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('primaryBreakdown', () => {
+    it('should deserialize valid JSON string', () => {
+      const jsonString = storageSerializer(
+        tokenBalanceMocks.primaryETHBreakdown,
+      )
+      const result = deserializers.primaryBreakdown(jsonString)
+      expect(result).toEqual(tokenBalanceMocks.primaryETHBreakdown)
+    })
+
+    it('should return null for null input', () => {
+      const jsonString = null
+      const result = deserializers.primaryBreakdown(jsonString)
+      expect(result).toBeNull()
+    })
+
+    it('should return null for invalid JSON string', () => {
+      const jsonString = 'invalid-json'
+      const result = deserializers.primaryBreakdown(jsonString)
+      expect(result).toBeNull()
+    })
+  })
+})
diff --git a/packages/portfolio/src/transformers/deserializers.ts b/packages/portfolio/src/transformers/deserializers.ts
new file mode 100644
index 0000000000..8c4f9078b4
--- /dev/null
+++ b/packages/portfolio/src/transformers/deserializers.ts
@@ -0,0 +1,62 @@
+import {
+  StorageReviverMapping,
+  StorageReviverType,
+  storageDeserializerMaker,
+} from '@yoroi/common'
+import {freeze} from 'immer'
+
+import {parseTokenBalance} from '../validators/token-balance'
+import {parseTokenDiscoveryWithCacheRecord} from '../validators/token-discovery'
+import {parsePrimaryBalanceBreakdown} from '../validators/primary-balance-breakdown'
+
+export const tokenDiscoveryReviverMapping: StorageReviverMapping = {
+  supply: StorageReviverType.AsBigInt,
+}
+
+export const tokenBalanceReviverMapping: StorageReviverMapping = {
+  balance: StorageReviverType.AsBigInt,
+  lockedInBuiltTxs: StorageReviverType.AsBigInt,
+}
+
+export const primaryBalanceBreakdownReviverMapping: StorageReviverMapping = {
+  balance: StorageReviverType.AsBigInt,
+  lockedInBuiltTxs: StorageReviverType.AsBigInt,
+  minRequiredByTokens: StorageReviverType.AsBigInt,
+  quantity: StorageReviverType.AsBigInt,
+}
+
+const tokenBalanceDeserializer = (jsonString: string | null) => {
+  if (jsonString == null) return null
+  const record = storageDeserializerMaker(tokenBalanceReviverMapping)(
+    jsonString,
+  )
+  const parsed = parseTokenBalance(record)
+  return parsed ?? null
+}
+
+const tokenDiscoveryWithCacheDeserializer = (jsonString: string | null) => {
+  if (jsonString == null) return null
+  const record = storageDeserializerMaker(tokenDiscoveryReviverMapping)(
+    jsonString,
+  )
+  const parsed = parseTokenDiscoveryWithCacheRecord(record)
+  return parsed ?? null
+}
+
+const primaryBalanceBreakdownDeserializer = (jsonString: string | null) => {
+  if (jsonString == null) return null
+  const record = storageDeserializerMaker(
+    primaryBalanceBreakdownReviverMapping,
+  )(jsonString)
+  const parsed = parsePrimaryBalanceBreakdown(record)
+  return parsed ?? null
+}
+
+export const deserializers = freeze(
+  {
+    tokenDiscoveryWithCache: tokenDiscoveryWithCacheDeserializer,
+    tokenBalance: tokenBalanceDeserializer,
+    primaryBreakdown: primaryBalanceBreakdownDeserializer,
+  },
+  true,
+)
diff --git a/packages/portfolio/src/types.ts b/packages/portfolio/src/types.ts
new file mode 100644
index 0000000000..225e114f45
--- /dev/null
+++ b/packages/portfolio/src/types.ts
@@ -0,0 +1,14 @@
+import {Chain, Portfolio} from '@yoroi/types'
+
+type ApiEndpoints = Readonly<{
+  [K in keyof Portfolio.Api.Api]: string
+}>
+
+export type ApiConfig = Readonly<{
+  [K in Chain.Network]: ApiEndpoints
+}>
+
+export type TokenInfoAndDiscovery = Readonly<{
+  info: Portfolio.Token.Info
+  discovery: Portfolio.Token.Discovery
+}>
diff --git a/packages/portfolio/src/validators/amount.test.ts b/packages/portfolio/src/validators/amount.test.ts
new file mode 100644
index 0000000000..6e34516a78
--- /dev/null
+++ b/packages/portfolio/src/validators/amount.test.ts
@@ -0,0 +1,51 @@
+import {Portfolio} from '@yoroi/types'
+import {isAmount, parseAmount} from './amount'
+
+describe('isAmount', () => {
+  it('should return true for valid amount', () => {
+    const amount: Portfolio.Amount = {
+      id: 'dead.',
+      quantity: BigInt(100),
+    }
+
+    const result = isAmount(amount)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid amount', () => {
+    const amount = {
+      id: 'dead.',
+      quantity: '100',
+    }
+
+    const result = isAmount(amount)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseAmount', () => {
+  it('should return parsed amount for valid data', () => {
+    const data = {
+      id: 'dead.',
+      quantity: BigInt(100),
+    }
+
+    const result = parseAmount(data)
+
+    expect(result?.id).toBe(data.id)
+    expect(result?.quantity).toBe(data.quantity)
+  })
+
+  it('should return undefined for invalid data', () => {
+    const data = {
+      id: 'dead.',
+      quantity: '100',
+    }
+
+    const result = parseAmount(data)
+
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/amount.ts b/packages/portfolio/src/validators/amount.ts
new file mode 100644
index 0000000000..1418c53786
--- /dev/null
+++ b/packages/portfolio/src/validators/amount.ts
@@ -0,0 +1,17 @@
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+import {TokenIdSchema} from './token-id'
+
+export const AmountSchema = z.object({
+  id: TokenIdSchema,
+  quantity: z.bigint(),
+})
+
+export const isAmount = (data: unknown): data is Portfolio.Amount => {
+  return AmountSchema.safeParse(data).success
+}
+
+export const parseAmount = (data: unknown): Portfolio.Amount | undefined => {
+  return isAmount(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/primary-balance-breakdown.test.ts b/packages/portfolio/src/validators/primary-balance-breakdown.test.ts
new file mode 100644
index 0000000000..095bc002bf
--- /dev/null
+++ b/packages/portfolio/src/validators/primary-balance-breakdown.test.ts
@@ -0,0 +1,50 @@
+import {
+  isPrimaryBalanceBreakdown,
+  parsePrimaryBalanceBreakdown,
+} from './primary-balance-breakdown'
+import {tokenBalanceMocks} from '../adapters/token-balance.mocks'
+import {Portfolio} from '@yoroi/types'
+
+describe('isPrimaryBalanceBreakdown', () => {
+  it('should return true for a valid primary balance breakdown', () => {
+    const validPrimaryBalanceBreakdown: Portfolio.BalancePrimaryBreakdown =
+      tokenBalanceMocks.primaryETHBreakdown
+
+    const result = isPrimaryBalanceBreakdown(validPrimaryBalanceBreakdown)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid primary balance breakdown', () => {
+    const invalidPrimaryBalanceBreakdown = {
+      ...tokenBalanceMocks.primaryETHBreakdown,
+      minRequiredByTokens: 'invalid',
+    }
+
+    const result = isPrimaryBalanceBreakdown(invalidPrimaryBalanceBreakdown)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parsePrimaryBalanceBreakdown', () => {
+  it('should return a valid primary balance breakdown', () => {
+    const validPrimaryBalanceBreakdown: Portfolio.BalancePrimaryBreakdown =
+      tokenBalanceMocks.primaryETHBreakdown
+
+    const result = parsePrimaryBalanceBreakdown(validPrimaryBalanceBreakdown)
+
+    expect(result).toEqual(validPrimaryBalanceBreakdown)
+  })
+
+  it('should return undefined for an invalid primary balance breakdown', () => {
+    const invalidPrimaryBalanceBreakdown = {
+      ...tokenBalanceMocks.primaryETHBreakdown,
+      minRequiredByTokens: 'invalid',
+    }
+
+    const result = parsePrimaryBalanceBreakdown(invalidPrimaryBalanceBreakdown)
+
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/primary-balance-breakdown.ts b/packages/portfolio/src/validators/primary-balance-breakdown.ts
new file mode 100644
index 0000000000..f86ddb3aee
--- /dev/null
+++ b/packages/portfolio/src/validators/primary-balance-breakdown.ts
@@ -0,0 +1,26 @@
+import {z} from 'zod'
+import {Portfolio} from '@yoroi/types'
+
+import {TokenBalanceSchema} from './token-balance'
+
+export const PrimaryBalanceBreakdownSchema = TokenBalanceSchema.extend({
+  minRequiredByTokens: z.bigint(),
+  records: z.array(
+    z.object({
+      quantity: z.bigint(),
+      redeemableAfter: z.number(),
+      source: z.string(),
+    }),
+  ),
+})
+
+export const isPrimaryBalanceBreakdown = (
+  data: unknown,
+): data is Portfolio.BalancePrimaryBreakdown =>
+  PrimaryBalanceBreakdownSchema.safeParse(data).success
+
+export const parsePrimaryBalanceBreakdown = (
+  data: unknown,
+): Portfolio.BalancePrimaryBreakdown | undefined => {
+  return isPrimaryBalanceBreakdown(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/response-record-with-cache-schema-maker.test.ts b/packages/portfolio/src/validators/response-record-with-cache-schema-maker.test.ts
new file mode 100644
index 0000000000..979657a757
--- /dev/null
+++ b/packages/portfolio/src/validators/response-record-with-cache-schema-maker.test.ts
@@ -0,0 +1,54 @@
+import {Api} from '@yoroi/types'
+import {z} from 'zod'
+
+import {responseRecordWithCacheSchemaMaker} from './response-record-with-cache-schema-maker'
+
+describe('responseRecordWithCacheSchemaMaker', () => {
+  it('should return the correct schema for HttpStatusCode.Ok', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+    const schema = responseRecordWithCacheSchemaMaker(recordSchema)
+
+    const validData = [
+      Api.HttpStatusCode.Ok,
+      {
+        id: '1',
+        name: 'John Doe',
+      },
+      'cacheKey',
+      1000,
+    ]
+
+    expect(schema.safeParse(validData).success).toBe(true)
+  })
+
+  it('should return the correct schema for HttpStatusCode.NotModified', () => {
+    const schema = responseRecordWithCacheSchemaMaker(z.number())
+
+    const validData = [Api.HttpStatusCode.NotModified, 123]
+
+    expect(schema.safeParse(validData).success).toBe(true)
+  })
+
+  it('should return an error for invalid data', () => {
+    const recordSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+    const schema = responseRecordWithCacheSchemaMaker(recordSchema)
+
+    const invalidData = [
+      Api.HttpStatusCode.Ok,
+      {
+        id: 1,
+        name: 'John Doe',
+      },
+      'cacheKey',
+      -1000,
+    ]
+
+    expect(schema.safeParse(invalidData).success).toBe(false)
+  })
+})
diff --git a/packages/portfolio/src/validators/response-record-with-cache-schema-maker.ts b/packages/portfolio/src/validators/response-record-with-cache-schema-maker.ts
new file mode 100644
index 0000000000..dc6b27fc83
--- /dev/null
+++ b/packages/portfolio/src/validators/response-record-with-cache-schema-maker.ts
@@ -0,0 +1,20 @@
+import {Api} from '@yoroi/types'
+
+import z, {ZodType} from 'zod'
+
+export const responseRecordWithCacheSchemaMaker = <T>(
+  recordSchema: ZodType<T>,
+): ZodType<Api.ResponseWithCache<T>> => {
+  return z.union([
+    z.tuple([
+      z.literal(Api.HttpStatusCode.Ok),
+      recordSchema,
+      z.string(),
+      z.number().nonnegative(),
+    ]),
+    z.tuple([
+      z.literal(Api.HttpStatusCode.NotModified),
+      z.number().nonnegative(),
+    ]),
+  ])
+}
diff --git a/packages/portfolio/src/validators/token-application.test.ts b/packages/portfolio/src/validators/token-application.test.ts
new file mode 100644
index 0000000000..ce6fde4822
--- /dev/null
+++ b/packages/portfolio/src/validators/token-application.test.ts
@@ -0,0 +1,32 @@
+import {Portfolio} from '@yoroi/types'
+import {isTokenApplicaton, parseTokenApplication} from './token-application'
+
+describe('isTokenApplicaton', () => {
+  it('should return true for valid token application', () => {
+    const validTokenApplication: Portfolio.Token.Application =
+      Portfolio.Token.Application.General
+    const result = isTokenApplicaton(validTokenApplication)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid token application', () => {
+    const invalidTokenApplication: any = 'invalid'
+    const result = isTokenApplicaton(invalidTokenApplication)
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenApplication', () => {
+  it('should return valid token application', () => {
+    const validTokenApplication: Portfolio.Token.Application =
+      Portfolio.Token.Application.General
+    const result = parseTokenApplication(validTokenApplication)
+    expect(result).toBe(validTokenApplication)
+  })
+
+  it('should return undefined for invalid token application', () => {
+    const invalidTokenApplication: any = 'invalid'
+    const result = parseTokenApplication(invalidTokenApplication)
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-application.ts b/packages/portfolio/src/validators/token-application.ts
new file mode 100644
index 0000000000..a2a2baadc1
--- /dev/null
+++ b/packages/portfolio/src/validators/token-application.ts
@@ -0,0 +1,15 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenApplicationSchema = z.nativeEnum(Portfolio.Token.Application)
+
+export const isTokenApplicaton = createTypeGuardFromSchema(
+  TokenApplicationSchema,
+)
+
+export const parseTokenApplication = (
+  data: unknown,
+): Portfolio.Token.Application | undefined => {
+  return isTokenApplicaton(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-balance.test.ts b/packages/portfolio/src/validators/token-balance.test.ts
new file mode 100644
index 0000000000..5fe6c80443
--- /dev/null
+++ b/packages/portfolio/src/validators/token-balance.test.ts
@@ -0,0 +1,94 @@
+import {Portfolio} from '@yoroi/types'
+
+import {
+  TokenBalanceSchema,
+  isTokenBalance,
+  parseTokenBalance,
+} from './token-balance'
+import {tokenInfoMocks} from '../adapters/token-info.mocks'
+
+describe('TokenBalanceSchema', () => {
+  it('should validate a valid token balance', () => {
+    const validTokenBalance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: BigInt(10000000000),
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = TokenBalanceSchema.safeParse(validTokenBalance)
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should not validate an invalid token balance', () => {
+    const invalidTokenBalance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: '10000000000',
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = TokenBalanceSchema.safeParse(invalidTokenBalance)
+
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('isTokenBalance', () => {
+  it('should return true for a valid token balance', () => {
+    const validTokenBalance: Portfolio.Token.Balance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: BigInt(10000000000),
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = isTokenBalance(validTokenBalance)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid token balance', () => {
+    const invalidTokenBalance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: '10000000000',
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = isTokenBalance(invalidTokenBalance)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenBalance', () => {
+  it('should return a valid token balance', () => {
+    const validTokenBalance: Portfolio.Token.Balance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: BigInt(10000000000),
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = parseTokenBalance(validTokenBalance)
+
+    expect(result).toEqual(validTokenBalance)
+  })
+
+  it('should return undefined for an invalid token balance', () => {
+    const invalidTokenBalance = {
+      info: tokenInfoMocks.ftNoTicker,
+      balance: '10000000000',
+      lockedInBuiltTxs: BigInt(0),
+    }
+
+    const result = parseTokenBalance(invalidTokenBalance)
+
+    expect(result).toBeUndefined()
+  })
+
+  it('should return undefined for an unknown data type', () => {
+    const unknownData = 'unknown'
+
+    const result = parseTokenBalance(unknownData)
+
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-balance.ts b/packages/portfolio/src/validators/token-balance.ts
new file mode 100644
index 0000000000..36036ece92
--- /dev/null
+++ b/packages/portfolio/src/validators/token-balance.ts
@@ -0,0 +1,22 @@
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+import {TokenInfoSchema} from './token-info'
+
+export const TokenBalanceSchema = z.object({
+  info: TokenInfoSchema,
+  balance: z.bigint(),
+  lockedInBuiltTxs: z.bigint(),
+})
+
+export const isTokenBalance = (
+  data: unknown,
+): data is Portfolio.Token.Balance => {
+  return TokenBalanceSchema.safeParse(data).success
+}
+
+export const parseTokenBalance = (
+  data: unknown,
+): Portfolio.Token.Balance | undefined => {
+  return isTokenBalance(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-discovery.test.ts b/packages/portfolio/src/validators/token-discovery.test.ts
new file mode 100644
index 0000000000..3eb71cab6a
--- /dev/null
+++ b/packages/portfolio/src/validators/token-discovery.test.ts
@@ -0,0 +1,205 @@
+import {Api, App, Portfolio} from '@yoroi/types'
+
+import {
+  isTokenDiscovery,
+  parseTokenDiscovery,
+  TokenDiscoveryResponseWithCacheRecordSchema,
+  isTokenDiscoveryResponseWithCacheRecord,
+  parseTokenDiscoveryResponseWithCacheRecord,
+  parseTokenDiscoveryWithCacheRecord,
+  isTokenDiscoveryWithCacheRecord,
+} from './token-discovery'
+import {tokenDiscoveryMocks} from '../adapters/token-discovery.mocks'
+
+describe('isTokenDiscovery', () => {
+  it('should return true for a valid token discovery', () => {
+    const validTokenDiscovery: Portfolio.Token.Discovery =
+      tokenDiscoveryMocks.nftCryptoKitty
+
+    const result = isTokenDiscovery(validTokenDiscovery)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid token discovery', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+
+    const result = isTokenDiscovery(invalidTokenDiscovery)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenDiscovery', () => {
+  it('should return a valid token discovery', () => {
+    const validTokenDiscovery: Portfolio.Token.Discovery =
+      tokenDiscoveryMocks.nftCryptoKitty
+
+    const result = parseTokenDiscovery(validTokenDiscovery)
+
+    expect(result).toEqual(validTokenDiscovery)
+  })
+
+  it('should return undefined for an invalid token discovery', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+
+    const result = parseTokenDiscovery(invalidTokenDiscovery)
+
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('TokenDiscoveryResponseWithCacheRecordSchema', () => {
+  it('should validate a valid token discovery response with cache record', () => {
+    const validResponse: Api.ResponseWithCache<Portfolio.Token.Discovery> = [
+      200,
+      tokenDiscoveryMocks.nftCryptoKitty,
+      'hash',
+      100,
+    ]
+
+    const result =
+      TokenDiscoveryResponseWithCacheRecordSchema.safeParse(validResponse)
+
+    expect(result.success).toBe(true)
+  })
+
+  it('should not validate an invalid token discovery response with cache record', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100]
+
+    const result =
+      TokenDiscoveryResponseWithCacheRecordSchema.safeParse(invalidResponse)
+
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('isTokenDiscoveryResponseWithCacheRecord', () => {
+  it('should return true for a valid token discovery response with cache record', () => {
+    const validResponse: Api.ResponseWithCache<Portfolio.Token.Discovery> = [
+      200,
+      tokenDiscoveryMocks.nftCryptoKitty,
+      'hash',
+      100,
+    ]
+
+    const result = isTokenDiscoveryResponseWithCacheRecord(validResponse)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid token discovery response with cache record', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+
+    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100]
+
+    const result = isTokenDiscoveryResponseWithCacheRecord(invalidResponse)
+
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenDiscoveryResponseWithCacheRecord', () => {
+  it('should return a valid token discovery response with cache record', () => {
+    const validResponse: Api.ResponseWithCache<Portfolio.Token.Discovery> = [
+      200,
+      tokenDiscoveryMocks.nftCryptoKitty,
+      'hash',
+      100,
+    ]
+
+    const result = parseTokenDiscoveryResponseWithCacheRecord(validResponse)
+
+    expect(result).toEqual(validResponse)
+  })
+
+  it('should return undefined for an invalid token discovery response with cache record', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+
+    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100]
+
+    const result = parseTokenDiscoveryResponseWithCacheRecord(invalidResponse)
+
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('parseTokenDiscoveryWithCacheRecord', () => {
+  it('should return a valid token discovery with cache record', () => {
+    const validTokenDiscovery: Portfolio.Token.Discovery =
+      tokenDiscoveryMocks.nftCryptoKitty
+    const validCache: App.CacheRecord<Portfolio.Token.Discovery> = {
+      hash: 'hash',
+      expires: 100,
+      record: validTokenDiscovery,
+    }
+
+    const result = parseTokenDiscoveryWithCacheRecord(validCache)
+
+    expect(result).toBe(validCache)
+  })
+
+  it('should return undefined for an invalid token discovery with cache record', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+    const invalidCache: App.CacheRecord<Portfolio.Token.Discovery> = {
+      hash: 'hash',
+      expires: 100,
+      record: invalidTokenDiscovery as any,
+    }
+
+    const result = parseTokenDiscoveryWithCacheRecord(invalidCache)
+
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('isTokenDiscoveryWithCacheRecord', () => {
+  it('should return true for a valid token discovery with cache record', () => {
+    const validTokenDiscovery: Portfolio.Token.Discovery =
+      tokenDiscoveryMocks.nftCryptoKitty
+    const validCache: App.CacheRecord<Portfolio.Token.Discovery> = {
+      hash: 'hash',
+      expires: 100,
+      record: validTokenDiscovery,
+    }
+
+    const result = isTokenDiscoveryWithCacheRecord(validCache)
+
+    expect(result).toBe(true)
+  })
+
+  it('should return false for an invalid token discovery with cache record', () => {
+    const invalidTokenDiscovery = {
+      ...tokenDiscoveryMocks.primaryETH,
+      id: 'invalid',
+    }
+    const invalidCache: App.CacheRecord<Portfolio.Token.Discovery> = {
+      hash: 'hash',
+      expires: 100,
+      record: invalidTokenDiscovery as any,
+    }
+
+    const result = isTokenDiscoveryWithCacheRecord(invalidCache)
+
+    expect(result).toBe(false)
+  })
+})
diff --git a/packages/portfolio/src/validators/token-discovery.ts b/packages/portfolio/src/validators/token-discovery.ts
new file mode 100644
index 0000000000..3fa980a926
--- /dev/null
+++ b/packages/portfolio/src/validators/token-discovery.ts
@@ -0,0 +1,85 @@
+import {Api, App, Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+import {responseRecordWithCacheSchemaMaker} from './response-record-with-cache-schema-maker'
+import {TokenSourceSchema} from './token-source'
+import {TokenPropertyTypeSchema} from './token-property-type'
+import {TokenIdSchema} from './token-id'
+import {cacheRecordSchemaMaker} from '@yoroi/common'
+
+const DiscoverySourceSchema = z.object({
+  name: TokenSourceSchema,
+  decimals: TokenSourceSchema,
+  ticker: TokenSourceSchema,
+  symbol: TokenSourceSchema,
+  image: TokenSourceSchema,
+})
+
+const DiscoveryOriginalMetadataSchema = z.object({
+  filteredMintMetadatum: z.record(z.unknown()).nullable(),
+  referenceDatum: z.record(z.unknown()).nullable(),
+  tokenRegistry: z.record(z.unknown()).nullable(),
+})
+
+const DiscoveryCountersSchema = z.object({
+  supply: z.bigint(),
+  items: z.number(),
+  totalItems: z.number(),
+})
+
+const DiscoveryPropertiesSchema = z.record(
+  z.union([
+    z.object({
+      rarity: z.number(),
+      detectedType: TokenPropertyTypeSchema,
+      value: z.unknown(),
+    }),
+    z.object({}),
+  ]),
+)
+
+export const TokenDiscoverySchema = z.object({
+  id: TokenIdSchema,
+  source: DiscoverySourceSchema,
+  originalMetadata: DiscoveryOriginalMetadataSchema,
+  counters: DiscoveryCountersSchema,
+  properties: DiscoveryPropertiesSchema,
+})
+
+export const isTokenDiscovery = (data: unknown): data is Portfolio.Token.Info =>
+  TokenDiscoverySchema.safeParse(data).success
+
+export const parseTokenDiscovery = (
+  data: unknown,
+): Portfolio.Token.Info | undefined => {
+  return isTokenDiscovery(data) ? data : undefined
+}
+
+export const TokenDiscoveryResponseWithCacheRecordSchema =
+  responseRecordWithCacheSchemaMaker(TokenDiscoverySchema)
+
+export const isTokenDiscoveryResponseWithCacheRecord = (
+  data: unknown,
+): data is Api.ResponseWithCache<Portfolio.Token.Discovery> =>
+  TokenDiscoveryResponseWithCacheRecordSchema.safeParse(data).success
+
+export const parseTokenDiscoveryResponseWithCacheRecord = (
+  data: unknown,
+): Api.ResponseWithCache<Portfolio.Token.Discovery> | undefined => {
+  return isTokenDiscoveryResponseWithCacheRecord(data) ? data : undefined
+}
+
+export const TokenDiscoveryWithCacheRecordSchema =
+  // zod doesn't work with string templates yet, check TokenIdSchema for more info
+  cacheRecordSchemaMaker<Portfolio.Token.Discovery>(TokenDiscoverySchema as any)
+
+export const isTokenDiscoveryWithCacheRecord = (
+  data: unknown,
+): data is App.CacheRecord<Portfolio.Token.Discovery> =>
+  TokenDiscoveryWithCacheRecordSchema.safeParse(data).success
+
+export const parseTokenDiscoveryWithCacheRecord = (
+  data: unknown,
+): App.CacheRecord<Portfolio.Token.Discovery> | undefined => {
+  return isTokenDiscoveryWithCacheRecord(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-id.test.ts b/packages/portfolio/src/validators/token-id.test.ts
new file mode 100644
index 0000000000..f4efb7c8d4
--- /dev/null
+++ b/packages/portfolio/src/validators/token-id.test.ts
@@ -0,0 +1,37 @@
+import {Portfolio} from '@yoroi/types'
+
+import {isTokenId, parseTokenId} from './token-id'
+
+describe('isTokenId', () => {
+  it('should return true for valid token id', () => {
+    const tokenId: Portfolio.Token.Id = 'dead.'
+    expect(isTokenId(tokenId)).toBe(true)
+  })
+
+  it('should return false for invalid token id', () => {
+    const tokenId: Portfolio.Token.Id = 'invalid_token_id' as any
+    expect(isTokenId(tokenId)).toBe(false)
+  })
+
+  it('should return false for non-string input', () => {
+    const tokenId: unknown = 123
+    expect(isTokenId(tokenId)).toBe(false)
+  })
+})
+
+describe('parseTokenId', () => {
+  it('should return token id for valid input', () => {
+    const tokenId: unknown = 'dead.'
+    expect(parseTokenId(tokenId)).toBe(tokenId)
+  })
+
+  it('should return undefined for invalid input', () => {
+    const tokenId: unknown = 'invalid_token_id'
+    expect(parseTokenId(tokenId)).toBeUndefined()
+  })
+
+  it('should return undefined for non-string input', () => {
+    const tokenId: unknown = 123
+    expect(parseTokenId(tokenId)).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-id.ts b/packages/portfolio/src/validators/token-id.ts
new file mode 100644
index 0000000000..b309036fdc
--- /dev/null
+++ b/packages/portfolio/src/validators/token-id.ts
@@ -0,0 +1,14 @@
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+const regexId = /^(?:[a-fA-F0-9]+\.?[a-fA-F0-9]*|\.)$/
+// TODO: https://github.com/colinhacks/zod/pull/1786 this needs to be migrated to .templateLiterals
+export const TokenIdSchema = z.string().regex(regexId)
+
+export const isTokenId = (data: unknown): data is Portfolio.Token.Id => {
+  return TokenIdSchema.safeParse(data).success
+}
+
+export const parseTokenId = (data: unknown): Portfolio.Token.Id | undefined => {
+  return isTokenId(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-info.test.ts b/packages/portfolio/src/validators/token-info.test.ts
new file mode 100644
index 0000000000..70d34a1b94
--- /dev/null
+++ b/packages/portfolio/src/validators/token-info.test.ts
@@ -0,0 +1,151 @@
+import {App, Portfolio} from '@yoroi/types'
+import {tokenInfoMocks} from '../adapters/token-info.mocks'
+import {
+  isPrimaryTokenInfo,
+  isSecondaryTokenInfo,
+  isSecondaryTokenInfoWithCacheRecord,
+  isTokenInfo,
+  isTokenInfoWithCacheRecord,
+  parseSecondaryTokenInfoWithCacheRecord,
+  parseTokenInfo,
+  parseTokenInfoWithCacheRecord,
+} from './token-info'
+
+describe('isPrimaryTokenInfo', () => {
+  it('should return true for valid primary token info', () => {
+    const result = isPrimaryTokenInfo(tokenInfoMocks.primaryETH)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid primary token info', () => {
+    const result = isPrimaryTokenInfo(tokenInfoMocks.nftCryptoKitty)
+    expect(result).toBe(false)
+  })
+})
+
+describe('isSecondaryTokenInfo', () => {
+  it('should return true for valid secondary token info', () => {
+    const result = isSecondaryTokenInfo(tokenInfoMocks.nftCryptoKitty)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid secondary token info', () => {
+    const result = isSecondaryTokenInfo(tokenInfoMocks.primaryETH)
+    expect(result).toBe(false)
+  })
+})
+
+describe('isTokenInfo', () => {
+  it('should return true for valid token info', () => {
+    const primaryTokenInfo = tokenInfoMocks.primaryETH
+    const secondaryTokenInfo = tokenInfoMocks.nftCryptoKitty
+    const result1 = isTokenInfo(primaryTokenInfo)
+    const result2 = isTokenInfo(secondaryTokenInfo)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+  })
+
+  it('should return false for invalid token info', () => {
+    const invalidTokenInfo = {foo: 'bar'}
+    const result = isTokenInfo(invalidTokenInfo)
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenInfo', () => {
+  it('should return token info for valid input', () => {
+    const primaryTokenInfo = tokenInfoMocks.primaryETH
+    const secondaryTokenInfo = tokenInfoMocks.nftCryptoKitty
+    const result1 = parseTokenInfo(primaryTokenInfo)
+    const result2 = parseTokenInfo(secondaryTokenInfo)
+    expect(result1).toEqual(primaryTokenInfo)
+    expect(result2).toEqual(secondaryTokenInfo)
+  })
+
+  it('should return undefined for invalid input', () => {
+    const invalidTokenInfo = {foo: 'bar'}
+    const result = parseTokenInfo(invalidTokenInfo)
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('isSecondaryTokenInfoWithCacheRecord', () => {
+  it('should return true for valid token info response with cache record', () => {
+    const validResponse = [200, tokenInfoMocks.nftCryptoKitty, 'hash', 100]
+    const result = isSecondaryTokenInfoWithCacheRecord(validResponse)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid token info response with cache record', () => {
+    const invalidResponse = {
+      data: {foo: 'bar'},
+      cache: 'some-cache-value',
+    }
+    const result = isSecondaryTokenInfoWithCacheRecord(invalidResponse)
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenInfoResponseWithCacheRecord', () => {
+  it('should return token info for valid token info response with cache record', () => {
+    const validResponse = [200, tokenInfoMocks.nftCryptoKitty, 'hash', 100]
+    const result = parseSecondaryTokenInfoWithCacheRecord(validResponse)
+    expect(result).toEqual(validResponse)
+  })
+
+  it('should return undefined for invalid token info response with cache record', () => {
+    const invalidResponse = {
+      data: {foo: 'bar'},
+      cache: 'some-cache-value',
+    }
+    const result = parseSecondaryTokenInfoWithCacheRecord(invalidResponse)
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('isTokenInfoWithCacheRecord', () => {
+  it('should return true for valid token info with cache record', () => {
+    const validRecord: App.CacheRecord<Portfolio.Token.Info> = {
+      record: tokenInfoMocks.nftCryptoKitty,
+      expires: 100,
+      hash: 'hash',
+    }
+    const result = isTokenInfoWithCacheRecord(validRecord)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid token info with cache record', () => {
+    const invalidRecord: App.CacheRecord<Portfolio.Token.Info> = {
+      record: tokenInfoMocks.nftCryptoKitty,
+      expires: -100,
+      hash: 'hash',
+    }
+
+    const result = isTokenInfoWithCacheRecord(invalidRecord)
+    expect(result).toBe(false)
+  })
+})
+
+describe('parseTokenInfoWithCacheRecord', () => {
+  it('should return token info for valid token info with cache record', () => {
+    const validRecord: App.CacheRecord<Portfolio.Token.Info> = {
+      record: tokenInfoMocks.nftCryptoKitty,
+      expires: 100,
+      hash: 'hash',
+    }
+
+    const result = parseTokenInfoWithCacheRecord(validRecord)
+    expect(result).toEqual(validRecord)
+  })
+
+  it('should return undefined for invalid token info with cache record', () => {
+    const invalidRecord: App.CacheRecord<Portfolio.Token.Info> = {
+      record: tokenInfoMocks.nftCryptoKitty,
+      expires: -100,
+      hash: 'hash',
+    }
+
+    const result = parseTokenInfoWithCacheRecord(invalidRecord)
+    expect(result).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-info.ts b/packages/portfolio/src/validators/token-info.ts
new file mode 100644
index 0000000000..bb5390565f
--- /dev/null
+++ b/packages/portfolio/src/validators/token-info.ts
@@ -0,0 +1,101 @@
+import {Api, App, Portfolio} from '@yoroi/types'
+import {cacheRecordSchemaMaker} from '@yoroi/common'
+import {z} from 'zod'
+
+import {TokenStatusSchema} from './token-status'
+import {TokenApplicationSchema} from './token-application'
+import {TokenIdSchema} from './token-id'
+import {TokenTypeSchema} from './token-type'
+import {responseRecordWithCacheSchemaMaker} from './response-record-with-cache-schema-maker'
+
+export const CommonTokenInfoSchema = z.object({
+  decimals: z.number().nonnegative(),
+  ticker: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  status: TokenStatusSchema,
+  application: TokenApplicationSchema,
+  tag: z.string(),
+  reference: z.string(),
+  fingerprint: z.string(),
+  website: z.string(),
+  originalImage: z.string(),
+})
+
+export const PrimaryTokenInfoSchema = CommonTokenInfoSchema.merge(
+  z.object({
+    id: z.literal<Portfolio.Token.Id>('.'),
+    nature: z.literal(Portfolio.Token.Nature.Primary),
+    type: z.literal(Portfolio.Token.Type.FT),
+  }),
+)
+
+export const SecondaryTokenInfoSchema = CommonTokenInfoSchema.merge(
+  z.object({
+    id: TokenIdSchema,
+    nature: z.literal(Portfolio.Token.Nature.Secondary),
+    type: TokenTypeSchema,
+  }),
+)
+
+export const SecondaryTokenInfoApiResponseSchema = CommonTokenInfoSchema.merge(
+  z.object({
+    id: TokenIdSchema,
+    nature: z.literal(Portfolio.Token.Nature.Secondary).optional(),
+    type: TokenTypeSchema,
+  }),
+)
+
+export const TokenInfoSchema = z.union([
+  PrimaryTokenInfoSchema,
+  SecondaryTokenInfoSchema,
+])
+
+export const isPrimaryTokenInfo = (
+  data: unknown,
+): data is Portfolio.Token.Info =>
+  PrimaryTokenInfoSchema.safeParse(data).success
+
+export const isSecondaryTokenInfo = (
+  data: unknown,
+): data is Portfolio.Token.Info =>
+  SecondaryTokenInfoSchema.safeParse(data).success
+
+export const isTokenInfo = (data: unknown): data is Portfolio.Token.Info =>
+  isPrimaryTokenInfo(data) || isSecondaryTokenInfo(data)
+
+export const parseTokenInfo = (
+  data: unknown,
+): Portfolio.Token.Info | undefined => {
+  return isTokenInfo(data) ? data : undefined
+}
+
+export const SecondaryTokenInfoApiResponseWithCacheRecordSchema =
+  responseRecordWithCacheSchemaMaker(SecondaryTokenInfoApiResponseSchema)
+
+// NOTE: the difference is the 'nature' field, that is added on fly by the manager
+// everything that comes from the API is secondary, primary is offline and is injected in the manager
+export const isSecondaryTokenInfoWithCacheRecord = (
+  data: unknown,
+): data is Api.ResponseWithCache<Omit<Portfolio.Token.Info, 'nature'>> =>
+  SecondaryTokenInfoApiResponseWithCacheRecordSchema.safeParse(data).success
+
+export const parseSecondaryTokenInfoWithCacheRecord = (
+  data: unknown,
+): Api.ResponseWithCache<Omit<Portfolio.Token.Info, 'nature'>> | undefined => {
+  return isSecondaryTokenInfoWithCacheRecord(data) ? data : undefined
+}
+
+export const TokenInfoWithCacheRecordSchema =
+  cacheRecordSchemaMaker(TokenInfoSchema)
+
+export const isTokenInfoWithCacheRecord = (
+  data: unknown,
+): data is App.CacheRecord<Portfolio.Token.Info> =>
+  TokenInfoWithCacheRecordSchema.safeParse(data).success
+
+export const parseTokenInfoWithCacheRecord = (
+  data: unknown,
+): App.CacheRecord<Portfolio.Token.Info> | undefined => {
+  return isTokenInfoWithCacheRecord(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-manager-event-sync.test.ts b/packages/portfolio/src/validators/token-manager-event-sync.test.ts
new file mode 100644
index 0000000000..a4eb8f271d
--- /dev/null
+++ b/packages/portfolio/src/validators/token-manager-event-sync.test.ts
@@ -0,0 +1,38 @@
+import {isEventTokenManagerSync} from './token-manager-event-sync'
+import {Portfolio} from '@yoroi/types'
+
+describe('isEventTokenManagerSync', () => {
+  it('should return true for valid TokenManagerSync event', () => {
+    const data: Portfolio.Event.TokenManagerSync = {
+      ids: ['token.1', 'token.2'],
+      on: Portfolio.Event.ManagerOn.Sync,
+      sourceId: 'sourceId',
+    }
+    const result = isEventTokenManagerSync(data)
+    expect(result).toBe(true)
+  })
+
+  it('should return false for invalid TokenManagerSync event', () => {
+    const data = {
+      ids: ['token1', 'token2'],
+      on: Portfolio.Event.ManagerOn.Hydrate,
+      sourceId: 'sourceId',
+    }
+    const result = isEventTokenManagerSync(data)
+    expect(result).toBe(false)
+  })
+
+  it('should return false for non-object input', () => {
+    expect(isEventTokenManagerSync('invalid')).toBe(false)
+    expect(isEventTokenManagerSync(null)).toBe(false)
+  })
+
+  it('should return false for missing properties', () => {
+    const data = {
+      ids: ['token1', 'token2'],
+      on: Portfolio.Event.ManagerOn.Sync,
+    }
+    const result = isEventTokenManagerSync(data)
+    expect(result).toBe(false)
+  })
+})
diff --git a/packages/portfolio/src/validators/token-manager-event-sync.ts b/packages/portfolio/src/validators/token-manager-event-sync.ts
new file mode 100644
index 0000000000..41cfc6cb9d
--- /dev/null
+++ b/packages/portfolio/src/validators/token-manager-event-sync.ts
@@ -0,0 +1,9 @@
+import {Portfolio} from '@yoroi/types'
+
+export const isEventTokenManagerSync = (
+  data: unknown,
+): data is Portfolio.Event.TokenManagerSync => {
+  if (!data || typeof data !== 'object') return false
+  if (!('ids' in data) || !('on' in data) || !('sourceId' in data)) return false
+  return data.on === Portfolio.Event.ManagerOn.Sync
+}
diff --git a/packages/portfolio/src/validators/token-nature.test.ts b/packages/portfolio/src/validators/token-nature.test.ts
new file mode 100644
index 0000000000..49331bd306
--- /dev/null
+++ b/packages/portfolio/src/validators/token-nature.test.ts
@@ -0,0 +1,39 @@
+import {Portfolio} from '@yoroi/types'
+
+import {isTokenNature, parseTokenNature} from './token-nature'
+
+describe('isTokenNature', () => {
+  it('should return true for valid token nature', () => {
+    const validTokenNature: Portfolio.Token.Nature =
+      Portfolio.Token.Nature.Primary
+    expect(isTokenNature(validTokenNature)).toBe(true)
+  })
+
+  it('should return false for invalid token nature', () => {
+    const invalidTokenNature: string = 'InvalidTokenNature'
+    expect(isTokenNature(invalidTokenNature)).toBe(false)
+  })
+
+  it('should return false for undefined', () => {
+    const undefinedTokenNature: undefined = undefined
+    expect(isTokenNature(undefinedTokenNature)).toBe(false)
+  })
+})
+
+describe('parseTokenNature', () => {
+  it('should return valid token nature', () => {
+    const validTokenNature: Portfolio.Token.Nature =
+      Portfolio.Token.Nature.Primary
+    expect(parseTokenNature(validTokenNature)).toBe(validTokenNature)
+  })
+
+  it('should return undefined for invalid token nature', () => {
+    const invalidTokenNature: string = 'InvalidTokenNature'
+    expect(parseTokenNature(invalidTokenNature)).toBeUndefined()
+  })
+
+  it('should return undefined for undefined', () => {
+    const undefinedTokenNature: undefined = undefined
+    expect(parseTokenNature(undefinedTokenNature)).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-nature.ts b/packages/portfolio/src/validators/token-nature.ts
new file mode 100644
index 0000000000..0e76a0eebe
--- /dev/null
+++ b/packages/portfolio/src/validators/token-nature.ts
@@ -0,0 +1,13 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenNatureSchema = z.nativeEnum(Portfolio.Token.Nature)
+
+export const isTokenNature = createTypeGuardFromSchema(TokenNatureSchema)
+
+export const parseTokenNature = (
+  data: unknown,
+): Portfolio.Token.Nature | undefined => {
+  return isTokenNature(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-property-type.test.ts b/packages/portfolio/src/validators/token-property-type.test.ts
new file mode 100644
index 0000000000..5e859ce2ae
--- /dev/null
+++ b/packages/portfolio/src/validators/token-property-type.test.ts
@@ -0,0 +1,42 @@
+import {Portfolio} from '@yoroi/types'
+
+import {
+  isTokenPropertyType,
+  parseTokenPropertyType,
+} from './token-property-type'
+
+describe('isTokenPropertyType', () => {
+  it('should return true for valid token property type', () => {
+    const validTokenPropertyType: Portfolio.Token.PropertyType =
+      Portfolio.Token.PropertyType.File
+    expect(isTokenPropertyType(validTokenPropertyType)).toBe(true)
+  })
+
+  it('should return false for invalid token property type', () => {
+    const invalidTokenPropertyType: string = 'invalid'
+    expect(isTokenPropertyType(invalidTokenPropertyType)).toBe(false)
+  })
+
+  it('should return false for undefined', () => {
+    expect(isTokenPropertyType(undefined)).toBe(false)
+  })
+})
+
+describe('parseTokenPropertyType', () => {
+  it('should return valid token property type', () => {
+    const validTokenPropertyType: Portfolio.Token.PropertyType =
+      Portfolio.Token.PropertyType.File
+    expect(parseTokenPropertyType(validTokenPropertyType)).toBe(
+      validTokenPropertyType,
+    )
+  })
+
+  it('should return undefined for invalid token property type', () => {
+    const invalidTokenPropertyType: string = 'invalid'
+    expect(parseTokenPropertyType(invalidTokenPropertyType)).toBe(undefined)
+  })
+
+  it('should return undefined for undefined', () => {
+    expect(parseTokenPropertyType(undefined)).toBe(undefined)
+  })
+})
diff --git a/packages/portfolio/src/validators/token-property-type.ts b/packages/portfolio/src/validators/token-property-type.ts
new file mode 100644
index 0000000000..59e3e28d4e
--- /dev/null
+++ b/packages/portfolio/src/validators/token-property-type.ts
@@ -0,0 +1,17 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenPropertyTypeSchema = z.nativeEnum(
+  Portfolio.Token.PropertyType,
+)
+
+export const isTokenPropertyType = createTypeGuardFromSchema(
+  TokenPropertyTypeSchema,
+)
+
+export const parseTokenPropertyType = (
+  data: unknown,
+): Portfolio.Token.PropertyType | undefined => {
+  return isTokenPropertyType(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-source.test.ts b/packages/portfolio/src/validators/token-source.test.ts
new file mode 100644
index 0000000000..60731a3078
--- /dev/null
+++ b/packages/portfolio/src/validators/token-source.test.ts
@@ -0,0 +1,29 @@
+import {Portfolio} from '@yoroi/types'
+
+import {isTokenSource, parseTokenSource} from './token-source'
+
+describe('isTokenSource', () => {
+  it('should return true for valid token source', () => {
+    const validTokenSource: Portfolio.Token.Source =
+      Portfolio.Token.Source.Datum
+    expect(isTokenSource(validTokenSource)).toBe(true)
+  })
+
+  it('should return false for invalid token source', () => {
+    const invalidTokenSource: any = 'invalid'
+    expect(isTokenSource(invalidTokenSource)).toBe(false)
+  })
+})
+
+describe('parseTokenSource', () => {
+  it('should return valid token source', () => {
+    const validTokenSource: Portfolio.Token.Source =
+      Portfolio.Token.Source.Datum
+    expect(parseTokenSource(validTokenSource)).toBe(validTokenSource)
+  })
+
+  it('should return undefined for invalid token source', () => {
+    const invalidTokenSource: any = 'INVALID'
+    expect(parseTokenSource(invalidTokenSource)).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-source.ts b/packages/portfolio/src/validators/token-source.ts
new file mode 100644
index 0000000000..a98be01f78
--- /dev/null
+++ b/packages/portfolio/src/validators/token-source.ts
@@ -0,0 +1,13 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenSourceSchema = z.nativeEnum(Portfolio.Token.Source)
+
+export const isTokenSource = createTypeGuardFromSchema(TokenSourceSchema)
+
+export const parseTokenSource = (
+  data: unknown,
+): Portfolio.Token.Source | undefined => {
+  return isTokenSource(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-status.test.ts b/packages/portfolio/src/validators/token-status.test.ts
new file mode 100644
index 0000000000..0ba1dde2e4
--- /dev/null
+++ b/packages/portfolio/src/validators/token-status.test.ts
@@ -0,0 +1,69 @@
+import {Portfolio} from '@yoroi/types'
+
+import {isTokenStatus, parseTokenStatus} from './token-status'
+
+describe('isTokenStatus', () => {
+  it('should return true for valid token status', () => {
+    const validStatuses: Portfolio.Token.Status[] = [
+      Portfolio.Token.Status.Accredited,
+      Portfolio.Token.Status.Invalid,
+      Portfolio.Token.Status.Valid,
+      Portfolio.Token.Status.Scam,
+      Portfolio.Token.Status.Unknown,
+    ]
+
+    validStatuses.forEach((status) => {
+      expect(isTokenStatus(status)).toBe(true)
+    })
+  })
+
+  it('should return false for invalid token status', () => {
+    const invalidStatuses: unknown[] = [
+      'Confirmed',
+      'Pending',
+      'Failed',
+      123,
+      null,
+      undefined,
+      {},
+      [],
+    ]
+
+    invalidStatuses.forEach((status) => {
+      expect(isTokenStatus(status)).toBe(false)
+    })
+  })
+})
+
+describe('parseTokenStatus', () => {
+  it('should return valid token status', () => {
+    const validStatuses: Portfolio.Token.Status[] = [
+      Portfolio.Token.Status.Accredited,
+      Portfolio.Token.Status.Invalid,
+      Portfolio.Token.Status.Valid,
+      Portfolio.Token.Status.Scam,
+      Portfolio.Token.Status.Unknown,
+    ]
+
+    validStatuses.forEach((status) => {
+      expect(parseTokenStatus(status)).toBe(status)
+    })
+  })
+
+  it('should return undefined for invalid token status', () => {
+    const invalidStatuses: unknown[] = [
+      'Confirmed',
+      'Pending',
+      'Failed',
+      123,
+      null,
+      undefined,
+      {},
+      [],
+    ]
+
+    invalidStatuses.forEach((status) => {
+      expect(parseTokenStatus(status)).toBeUndefined()
+    })
+  })
+})
diff --git a/packages/portfolio/src/validators/token-status.ts b/packages/portfolio/src/validators/token-status.ts
new file mode 100644
index 0000000000..6540be5640
--- /dev/null
+++ b/packages/portfolio/src/validators/token-status.ts
@@ -0,0 +1,13 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenStatusSchema = z.nativeEnum(Portfolio.Token.Status)
+
+export const isTokenStatus = createTypeGuardFromSchema(TokenStatusSchema)
+
+export const parseTokenStatus = (
+  data: unknown,
+): Portfolio.Token.Status | undefined => {
+  return isTokenStatus(data) ? data : undefined
+}
diff --git a/packages/portfolio/src/validators/token-type.test.ts b/packages/portfolio/src/validators/token-type.test.ts
new file mode 100644
index 0000000000..44f17ad478
--- /dev/null
+++ b/packages/portfolio/src/validators/token-type.test.ts
@@ -0,0 +1,31 @@
+import {Portfolio} from '@yoroi/types'
+
+import {isTokenType, parseTokenType} from './token-type'
+
+describe('isTokenType', () => {
+  it('should return true for valid token types', () => {
+    expect(isTokenType(Portfolio.Token.Type.FT)).toBe(true)
+    expect(isTokenType(Portfolio.Token.Type.NFT)).toBe(true)
+  })
+
+  it('should return false for invalid token types', () => {
+    expect(isTokenType('invalid')).toBe(false)
+    expect(isTokenType(123)).toBe(false)
+  })
+})
+
+describe('parseTokenType', () => {
+  it('should return the token type for valid token types', () => {
+    expect(parseTokenType(Portfolio.Token.Type.FT)).toBe(
+      Portfolio.Token.Type.FT,
+    )
+    expect(parseTokenType(Portfolio.Token.Type.FT)).toBe(
+      Portfolio.Token.Type.FT,
+    )
+  })
+
+  it('should return undefined for invalid token types', () => {
+    expect(parseTokenType('invalid')).toBeUndefined()
+    expect(parseTokenType(123)).toBeUndefined()
+  })
+})
diff --git a/packages/portfolio/src/validators/token-type.ts b/packages/portfolio/src/validators/token-type.ts
new file mode 100644
index 0000000000..f1cad51eb9
--- /dev/null
+++ b/packages/portfolio/src/validators/token-type.ts
@@ -0,0 +1,13 @@
+import {createTypeGuardFromSchema} from '@yoroi/common'
+import {Portfolio} from '@yoroi/types'
+import {z} from 'zod'
+
+export const TokenTypeSchema = z.nativeEnum(Portfolio.Token.Type)
+
+export const isTokenType = createTypeGuardFromSchema(TokenTypeSchema)
+
+export const parseTokenType = (
+  data: unknown,
+): Portfolio.Token.Type | undefined => {
+  return isTokenType(data) ? data : undefined
+}
diff --git a/packages/portfolio/tsconfig.build.json b/packages/portfolio/tsconfig.build.json
new file mode 100644
index 0000000000..1382480b0c
--- /dev/null
+++ b/packages/portfolio/tsconfig.build.json
@@ -0,0 +1,5 @@
+
+{
+  "extends": "./tsconfig",
+  "exclude": ["example", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}
diff --git a/packages/portfolio/tsconfig.json b/packages/portfolio/tsconfig.json
new file mode 100644
index 0000000000..a074f3ce47
--- /dev/null
+++ b/packages/portfolio/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "baseUrl": "./src",
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react",
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "noImplicitUseStrict": false,
+    "noStrictGenericChecks": false,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "esnext"
+  }
+}
diff --git a/packages/staking/src/governance/manager.test.ts b/packages/staking/src/governance/manager.test.ts
index 9d5b331569..fc713c1929 100644
--- a/packages/staking/src/governance/manager.test.ts
+++ b/packages/staking/src/governance/manager.test.ts
@@ -22,7 +22,7 @@ describe('createGovernanceManager', () => {
     walletId: 'walletId',
     networkId,
     cardano,
-    storage: mountAsyncStorage('wallet/'),
+    storage: mountAsyncStorage({path: 'wallet/'}),
     api: governanceApiMaker({networkId, client: fetcher}),
   }
 
diff --git a/packages/types/.gitignore b/packages/types/.gitignore
index 75356714f9..32c6d7db77 100644
--- a/packages/types/.gitignore
+++ b/packages/types/.gitignore
@@ -7,6 +7,7 @@
 
 # VSCode
 .vscode/
+!.vscode/launch.json
 jsconfig.json
 
 # Xcode
diff --git a/packages/types/package.json b/packages/types/package.json
index 8debea0af7..062537c97d 100644
--- a/packages/types/package.json
+++ b/packages/types/package.json
@@ -100,6 +100,7 @@
     "@testing-library/react-hooks": "^8.0.1",
     "@types/jest": "^29.5.12",
     "axios": "^1.5.0",
+    "bignumber.js": "^9.0.1",
     "commitlint": "^17.0.2",
     "del-cli": "^5.0.0",
     "dependency-cruiser": "^13.1.1",
@@ -111,10 +112,13 @@
     "prettier": "^2.0.5",
     "react-native-builder-bob": "^0.23.2",
     "release-it": "^15.0.0",
+    "rxjs": "^7.8.1",
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "axios": "^1.5.0"
+    "axios": "^1.5.0",
+    "bignumber.js": "^9.0.1",
+    "rxjs": "^7.8.1"
   },
   "packageManager": "yarn@1.22.21",
   "engines": {
diff --git a/packages/types/src/api/cache.ts b/packages/types/src/api/cache.ts
new file mode 100644
index 0000000000..a2da1e2d3d
--- /dev/null
+++ b/packages/types/src/api/cache.ts
@@ -0,0 +1,7 @@
+import {ApiHttpStatusCode} from './status-code'
+
+export type ApiResponseRecordWithCache<T> =
+  | [StatusCode: ApiHttpStatusCode.Ok, Record: T, ETag: string, MaxAge: number]
+  | [StatusCode: ApiHttpStatusCode.NotModified, MaxAge: number]
+
+export type ApiRequestRecordWithCache<T> = [Record: T, ETag: string]
diff --git a/packages/types/src/api/status-code.ts b/packages/types/src/api/status-code.ts
new file mode 100644
index 0000000000..64e8b80c68
--- /dev/null
+++ b/packages/types/src/api/status-code.ts
@@ -0,0 +1,13 @@
+export enum ApiHttpStatusCode {
+  Ok = 200,
+  Created = 201,
+  Accepted = 202,
+  NotModified = 304,
+  BadRequest = 400,
+  Unauthorized = 401,
+  Forbidden = 403,
+  NotFound = 404,
+  TooEarly = 425,
+  TooManyRequests = 429,
+  InternalServerError = 500,
+}
diff --git a/packages/types/src/app/errors.ts b/packages/types/src/app/errors.ts
new file mode 100644
index 0000000000..ff40fb1d7e
--- /dev/null
+++ b/packages/types/src/app/errors.ts
@@ -0,0 +1 @@
+export class AppErrorInvalidState extends Error {}
diff --git a/packages/types/src/app/multi-storage.ts b/packages/types/src/app/multi-storage.ts
index 1ebd97b482..58e15843a7 100644
--- a/packages/types/src/app/multi-storage.ts
+++ b/packages/types/src/app/multi-storage.ts
@@ -1,21 +1,29 @@
 import {AppStorage, AppStorageFolderName} from './storage'
-import {MaybePromise, Nullable} from '../helpers/types'
+import {MaybePromise} from '../helpers/types'
 
-export interface AppMultiStorage<T, IsAsync extends boolean = true> {
-  getAllKeys: () => MaybePromise<ReadonlyArray<string>, IsAsync>
+export interface AppMultiStorage<
+  T,
+  IsAsync extends boolean = true,
+  K extends string = string,
+> {
+  getAllKeys: () => MaybePromise<ReadonlyArray<K>, IsAsync>
   clear: () => MaybePromise<void, IsAsync>
   saveMany: (data: ReadonlyArray<NonNullable<T>>) => MaybePromise<void, IsAsync>
-  readAll: () => MaybePromise<ReadonlyArray<[string, Nullable<T>]>, IsAsync>
+  readAll: () => MaybePromise<ReadonlyArray<[K, T | null]>, IsAsync>
   readMany: (
-    keys: ReadonlyArray<string>,
-  ) => MaybePromise<ReadonlyArray<[string, Nullable<T>]>, IsAsync>
-  removeMany: (keys: ReadonlyArray<string>) => MaybePromise<void, IsAsync>
+    keys: ReadonlyArray<K>,
+  ) => MaybePromise<ReadonlyArray<[K, T | null]>, IsAsync>
+  removeMany: (keys: ReadonlyArray<K>) => MaybePromise<void, IsAsync>
 }
 
-export type AppMultiStorageOptions<T, IsAsync extends boolean = true> = {
-  storage: AppStorage<IsAsync>
+export type AppMultiStorageOptions<
+  T,
+  IsAsync extends boolean = true,
+  K extends string = string,
+> = {
+  storage: AppStorage<IsAsync, K>
   dataFolder: AppStorageFolderName
-  keyExtractor: keyof T | ((data: NonNullable<T>) => string)
+  keyExtractor: keyof T | ((data: NonNullable<T>) => K)
   serializer?: (data: NonNullable<T>) => string
-  deserializer?: (data: string | null) => Nullable<T>
+  deserializer?: (data: unknown) => T | null
 }
diff --git a/packages/types/src/app/observable-storage.ts b/packages/types/src/app/observable-storage.ts
index 3811367cac..a8d267ff0b 100644
--- a/packages/types/src/app/observable-storage.ts
+++ b/packages/types/src/app/observable-storage.ts
@@ -1,17 +1,22 @@
+import {Subscription} from 'rxjs'
+
 import {AppMultiStorage} from './multi-storage'
 import {AppStorage} from './storage'
 
-export type AppObservableStorage<IsAsync extends boolean = true> =
-  AppStorage<IsAsync> & {
-    onUpdate: (
-      keysToObserve: ReadonlyArray<string>,
-      callback: (keys: ReadonlyArray<string> | null) => void,
-    ) => () => void
-  }
+export type AppObservableStorage<
+  IsAsync extends boolean = true,
+  K extends string = string,
+> = AppStorage<IsAsync, K> & {
+  onChange: (
+    keysToObserve: ReadonlyArray<K>,
+    callback: (keys: ReadonlyArray<K> | null) => void,
+  ) => Subscription
+}
 
 export type AppObservableMultiStorage<
   T,
   IsAsync extends boolean = true,
-> = AppMultiStorage<T, IsAsync> & {
-  onUpdate: (callback: () => void) => () => void
+  K extends string = string,
+> = AppMultiStorage<T, IsAsync, K> & {
+  onChange: (callback: () => void) => Subscription
 }
diff --git a/packages/types/src/app/observer-manager.ts b/packages/types/src/app/observer-manager.ts
new file mode 100644
index 0000000000..289c2534c8
--- /dev/null
+++ b/packages/types/src/app/observer-manager.ts
@@ -0,0 +1,15 @@
+import {Observable, Observer, Subscription} from 'rxjs'
+
+export type AppSubscriber<T> = Partial<Observer<T>> | ((value: T) => void)
+
+export type AppObserverManager<T> = Readonly<{
+  subscribe: (observerOrNext: AppSubscriber<T>) => Subscription
+  unsubscribe: (subscription: Subscription) => void
+  notify: (value: T) => void
+  destroy: () => void
+  observable: Observable<T>
+}>
+
+export type AppObserverSubscribe<T> = (
+  subscriber: AppSubscriber<T>,
+) => Subscription
diff --git a/packages/types/src/app/queue-task-manager.ts b/packages/types/src/app/queue-task-manager.ts
new file mode 100644
index 0000000000..a17fe32943
--- /dev/null
+++ b/packages/types/src/app/queue-task-manager.ts
@@ -0,0 +1,6 @@
+export type AppQueueTask = () => Promise<void>
+
+export type AppQueueTaskManager = Readonly<{
+  enqueue: (task: AppQueueTask) => void
+  destroy: () => void
+}>
diff --git a/packages/types/src/app/simple-observer.ts b/packages/types/src/app/simple-observer.ts
deleted file mode 100644
index 91088f7bf6..0000000000
--- a/packages/types/src/app/simple-observer.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export type AppSubscriber<T> = (data: T) => void
-
-export type AppObserver<T> = Readonly<{
-  subscribe: (subscriber: AppSubscriber<T>) => () => void
-  unsubscribe: (subscriber: AppSubscriber<T>) => void
-  notify: (data: T) => void
-  destroy: () => void
-}>
diff --git a/packages/types/src/app/storage.ts b/packages/types/src/app/storage.ts
index 4331f39a8d..68639dc228 100644
--- a/packages/types/src/app/storage.ts
+++ b/packages/types/src/app/storage.ts
@@ -2,30 +2,38 @@ import {MaybePromise} from '../helpers/types'
 
 export type AppStorageFolderName = `${string}/`
 
-export interface AppStorage<IsAsync extends boolean = true> {
-  join: (folderName: AppStorageFolderName) => AppStorage<IsAsync>
-  getItem: <T = unknown>(
-    key: string,
-    parse?: (item: string | null) => T,
-  ) => MaybePromise<T, IsAsync>
-  multiGet: <T = unknown>(
-    keys: ReadonlyArray<string>,
-    parse?: (item: string | null) => T,
-  ) => MaybePromise<ReadonlyArray<[string, T]>, IsAsync>
-  setItem: <T = unknown>(
-    key: string,
+export interface AppStorage<
+  IsAsync extends boolean = true,
+  Key extends string = string,
+> {
+  join: (folderName: AppStorageFolderName) => AppStorage<IsAsync, Key>
+  getItem: <T = unknown, K extends string = Key>(
+    key: K,
+    parse?: (item: string | null) => T | null,
+  ) => MaybePromise<T | null, IsAsync>
+  multiGet: <T = unknown, K extends string = Key>(
+    keys: ReadonlyArray<K>,
+    parse?: (item: string | null) => T | null,
+  ) => MaybePromise<ReadonlyArray<[K, T | null]>, IsAsync>
+  setItem: <T = unknown, K extends string = Key>(
+    key: K,
     value: T,
     stringify?: (data: T) => string,
   ) => MaybePromise<void, IsAsync>
-  multiSet: (
-    tuples: ReadonlyArray<[key: string, value: unknown]>,
-    stringify?: (data: unknown) => string,
+  multiSet: <T = unknown, K extends string = Key>(
+    tuples: ReadonlyArray<[key: K, value: T]>,
+    stringify?: (data: T) => string,
   ) => MaybePromise<void, IsAsync>
-  removeItem: (key: string) => MaybePromise<void, IsAsync>
+  removeItem: <K extends string = Key>(key: K) => MaybePromise<void, IsAsync>
   removeFolder: (
     folderName: AppStorageFolderName,
   ) => MaybePromise<void, IsAsync>
-  multiRemove: (keys: ReadonlyArray<string>) => MaybePromise<void, IsAsync>
-  getAllKeys: () => MaybePromise<ReadonlyArray<string>, IsAsync>
+  multiRemove: <K extends string = Key>(
+    keys: ReadonlyArray<K>,
+  ) => MaybePromise<void, IsAsync>
+  getAllKeys: <K extends string = Key>() => MaybePromise<
+    ReadonlyArray<K>,
+    IsAsync
+  >
   clear: () => MaybePromise<void, IsAsync>
 }
diff --git a/packages/types/src/chain/network.ts b/packages/types/src/chain/network.ts
new file mode 100644
index 0000000000..c5e71642e3
--- /dev/null
+++ b/packages/types/src/chain/network.ts
@@ -0,0 +1,7 @@
+export enum ChainNetwork {
+  Main = 'main',
+  Test = 'test',
+  Preview = 'preview',
+  Preprod = 'preprod',
+  Sancho = 'sancho',
+}
diff --git a/packages/types/src/helpers/types.ts b/packages/types/src/helpers/types.ts
index 7b4ea85139..c79e8b8467 100644
--- a/packages/types/src/helpers/types.ts
+++ b/packages/types/src/helpers/types.ts
@@ -1,4 +1,4 @@
-export type Nullable<T> = T | null | undefined
+export type Maybe<T> = T | null | undefined
 export type Writable<T> = {
   -readonly [P in keyof T]: T[P] extends object ? Writable<T[P]> : T[P]
 }
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 6086dcf871..8fcaa19dd8 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -47,6 +47,11 @@ import {
   LinksErrorUnsupportedAuthority,
   LinksErrorUnsupportedVersion,
 } from './links/errors'
+import {
+  ApiRequestRecordWithCache,
+  ApiResponseRecordWithCache,
+} from './api/cache'
+import {ApiHttpStatusCode} from './api/status-code'
 import {ApiResponse, ApiResponseError, ApiResponseSuccess} from './api/response'
 import {
   ApiErrorBadRequest,
@@ -102,7 +107,11 @@ import {
   AppObservableStorage,
 } from './app/observable-storage'
 import {AppCacheInfo, AppCacheRecord, AppCacheRow} from './app/cache'
-import {AppObserver, AppSubscriber} from './app/simple-observer'
+import {
+  AppObserverManager,
+  AppObserverSubscribe,
+  AppSubscriber,
+} from './app/observer-manager'
 import {
   CardanoAddress,
   CardanoMetadata,
@@ -137,26 +146,93 @@ import {
   LinksYoroiUriConfig,
   LinksYoroiModule,
 } from './links/yoroi'
+import {
+  PortfolioTokenId,
+  PortfolioTokenType,
+  PortfolioTokenPropertyType,
+  PortfolioTokenApplication,
+  PortfolioTokenSource,
+  PortfolioTokenNature,
+  PortfolioTokenStatus,
+} from './portfolio/token'
+import {PortfolioTokenDiscovery} from './portfolio/discovery'
+import {PortfolioTokenInfo} from './portfolio/info'
+import {
+  PortfolioAmount,
+  PortfolioAmounts,
+  PortfolioBalancePrimaryBreakdown,
+  PortfolioBalancePrimaryRecord,
+  PortfolioTokenBalance,
+} from './portfolio/balance'
+import {PortfolioTokenPrice} from './portfolio/price'
+import {ChainNetwork} from './chain/network'
+import {NumbersErrorInvalidAtomicValue} from './numbers/errors'
+import {NumbersAtomicValue} from './numbers/atomic-value'
+import {AppErrorInvalidState} from './app/errors'
+import {
+  PortfolioApi,
+  PortfolioApiTokenDiscoveriesResponse,
+  PortfolioApiTokenInfosResponse,
+} from './portfolio/api'
+import {
+  PortfolioEventBalanceManager,
+  PortfolioEventSourceId,
+  PortfolioEventManagerOn,
+  PortfolioEventTokenManager,
+  PortfolioEventTokenManagerSync,
+  PortfolioEventTokenManagerHydrate,
+  PortfolioEventBalanceManagerHydrate,
+  PortfolioEventBalanceManagerRefresh,
+  PortfolioEventBalanceManagerSync,
+} from './portfolio/event'
+import {
+  PortfolioStorageBalance,
+  PortfolioStorageToken,
+} from './portfolio/storage'
+import {
+  PortfolioManagerBalance,
+  PortfolioManagerToken,
+} from './portfolio/manager'
+import {AppQueueTask, AppQueueTaskManager} from './app/queue-task-manager'
 
 export namespace App {
-  export interface Storage<IsAsync extends boolean = true>
-    extends AppStorage<IsAsync> {}
+  export namespace Errors {
+    export class InvalidState extends AppErrorInvalidState {}
+  }
+
+  export interface Storage<
+    IsAsync extends boolean = true,
+    K extends string = string,
+  > extends AppStorage<IsAsync, K> {}
   export type StorageFolderName = AppStorageFolderName
-  export interface MultiStorage<T, IsAsync extends boolean = true>
-    extends AppMultiStorage<T, IsAsync> {}
+  export interface MultiStorage<
+    T,
+    IsAsync extends boolean = true,
+    K extends string = string,
+  > extends AppMultiStorage<T, IsAsync, K> {}
 
-  export interface ObservableStorage<IsAsync extends boolean = true>
-    extends AppObservableStorage<IsAsync> {}
-  export interface ObservableMultiStorage<T, IsAsync extends boolean = true>
-    extends AppObservableMultiStorage<T, IsAsync> {}
+  export interface ObservableStorage<
+    IsAsync extends boolean = true,
+    K extends string = string,
+  > extends AppObservableStorage<IsAsync, K> {}
+  export interface ObservableMultiStorage<
+    T,
+    IsAsync extends boolean = true,
+    K extends string = string,
+  > extends AppObservableMultiStorage<T, IsAsync, K> {}
 
   export type MultiStorageOptions<
     T,
     IsAsync extends boolean = true,
-  > = AppMultiStorageOptions<T, IsAsync>
+    K extends string = string,
+  > = AppMultiStorageOptions<T, IsAsync, K>
 
-  export type Observer<T> = AppObserver<T>
+  export type ObserverManager<T> = AppObserverManager<T>
   export type Subscriber<T> = AppSubscriber<T>
+  export type ObserverSubscribe<T> = AppObserverSubscribe<T>
+
+  export type QueueTask = AppQueueTask
+  export type QueueTaskManager = AppQueueTaskManager
 
   export type CacheInfo = AppCacheInfo
   export interface CacheRecord<T> extends AppCacheRecord<T> {}
@@ -245,6 +321,11 @@ export namespace Api {
   export type ResponseSuccess<T> = ApiResponseSuccess<T>
   export type Response<T> = ApiResponse<T>
 
+  export type ResponseWithCache<T> = ApiResponseRecordWithCache<T>
+  export type RequestWithCache<T> = ApiRequestRecordWithCache<T>
+  export type HttpStatusCode = ApiHttpStatusCode
+  export const HttpStatusCode = ApiHttpStatusCode
+
   export namespace Errors {
     export class BadRequest extends ApiErrorBadRequest {}
     export class NotFound extends ApiErrorNotFound {}
@@ -302,6 +383,11 @@ export namespace Api {
 
 export namespace Numbers {
   export type Locale = NumberLocale
+  export type AtomicValue = NumbersAtomicValue
+
+  export namespace Errors {
+    export class InvalidAtomicValue extends NumbersErrorInvalidAtomicValue {}
+  }
 }
 
 export namespace Resolver {
@@ -335,7 +421,76 @@ export namespace Transfer {
   export type Targets = TransferTargets
 }
 
+export namespace Portfolio {
+  export type Amount = PortfolioAmount
+  export type Amounts = PortfolioAmounts
+  export type BalancePrimaryRecord = PortfolioBalancePrimaryRecord
+  export type BalancePrimaryBreakdown = PortfolioBalancePrimaryBreakdown
+
+  export namespace Event {
+    export type SourceId = PortfolioEventSourceId
+    export type TokenManager = PortfolioEventTokenManager
+    export type BalanceManager = PortfolioEventBalanceManager
+    export type ManagerOn = PortfolioEventManagerOn
+    export const ManagerOn = PortfolioEventManagerOn
+
+    export type TokenManagerSync = PortfolioEventTokenManagerSync
+    export type TokenManagerHydrate = PortfolioEventTokenManagerHydrate
+
+    export type BalanceManagerSync = PortfolioEventBalanceManagerSync
+    export type BalanceManagerHydrate = PortfolioEventBalanceManagerHydrate
+    export type BalanceManagerRefresh = PortfolioEventBalanceManagerRefresh
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  export namespace Api {
+    export type TokenInfosResponse = PortfolioApiTokenInfosResponse
+    export type TokenDiscoveriesResponse = PortfolioApiTokenDiscoveriesResponse
+    export type Api = PortfolioApi
+  }
+
+  export namespace Storage {
+    export type Token = PortfolioStorageToken
+    export type Balance = PortfolioStorageBalance
+  }
+
+  export namespace Manager {
+    export type Token = PortfolioManagerToken
+    export type Balance = PortfolioManagerBalance
+  }
+
+  export namespace Token {
+    export type Id = PortfolioTokenId
+
+    export type Type = PortfolioTokenType
+    export const Type = PortfolioTokenType
+
+    export type PropertyType = PortfolioTokenPropertyType
+    export const PropertyType = PortfolioTokenPropertyType
+
+    export type Application = PortfolioTokenApplication
+    export const Application = PortfolioTokenApplication
+
+    export type Source = PortfolioTokenSource
+    export const Source = PortfolioTokenSource
+
+    export type Nature = PortfolioTokenNature
+    export const Nature = PortfolioTokenNature
+
+    export type Status = PortfolioTokenStatus
+    export const Status = PortfolioTokenStatus
+
+    export type Info = PortfolioTokenInfo
+    export type Discovery = PortfolioTokenDiscovery
+    export type Balance = PortfolioTokenBalance
+    export type Price = PortfolioTokenPrice
+  }
+}
+
 export namespace Chain {
+  export type Network = ChainNetwork
+  export const Network = ChainNetwork
+
   export namespace Cardano {
     export type UnsignedTx = CardanoUnsignedTx
     export type SignedTx = CardanoSignedTx
diff --git a/packages/types/src/numbers/atomic-value.ts b/packages/types/src/numbers/atomic-value.ts
new file mode 100644
index 0000000000..19b1e52d49
--- /dev/null
+++ b/packages/types/src/numbers/atomic-value.ts
@@ -0,0 +1 @@
+export type NumbersAtomicValue = `${number}`
diff --git a/packages/types/src/numbers/errors.ts b/packages/types/src/numbers/errors.ts
new file mode 100644
index 0000000000..f1a6f7c9e2
--- /dev/null
+++ b/packages/types/src/numbers/errors.ts
@@ -0,0 +1 @@
+export class NumbersErrorInvalidAtomicValue extends Error {}
diff --git a/packages/types/src/portfolio/api.ts b/packages/types/src/portfolio/api.ts
new file mode 100644
index 0000000000..3a6dbf8200
--- /dev/null
+++ b/packages/types/src/portfolio/api.ts
@@ -0,0 +1,25 @@
+import {
+  ApiRequestRecordWithCache,
+  ApiResponseRecordWithCache,
+} from '../api/cache'
+import {ApiResponse} from '../api/response'
+import {PortfolioTokenDiscovery} from './discovery'
+import {PortfolioTokenInfo} from './info'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioApiTokenDiscoveriesResponse = {
+  [key: PortfolioTokenId]: ApiResponseRecordWithCache<PortfolioTokenDiscovery>
+}
+
+export type PortfolioApiTokenInfosResponse = {
+  [key: PortfolioTokenId]: ApiResponseRecordWithCache<PortfolioTokenInfo>
+}
+
+export type PortfolioApi = Readonly<{
+  tokenInfos(
+    idsWithETag: ReadonlyArray<ApiRequestRecordWithCache<PortfolioTokenId>>,
+  ): Promise<Readonly<ApiResponse<PortfolioApiTokenInfosResponse>>>
+  tokenDiscoveries(
+    idsWithETag: ReadonlyArray<ApiRequestRecordWithCache<PortfolioTokenId>>,
+  ): Promise<Readonly<ApiResponse<PortfolioApiTokenDiscoveriesResponse>>>
+}>
diff --git a/packages/types/src/portfolio/balance.ts b/packages/types/src/portfolio/balance.ts
new file mode 100644
index 0000000000..c807d6e1a7
--- /dev/null
+++ b/packages/types/src/portfolio/balance.ts
@@ -0,0 +1,32 @@
+import {PortfolioTokenInfo} from './info'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioAmounts = {
+  [key: PortfolioTokenId]: BigInt
+}
+
+export type PortfolioAmount = {
+  id: PortfolioTokenId
+  quantity: BigInt
+}
+
+export type PortfolioTokenBalance = {
+  info: PortfolioTokenInfo
+  // remote
+  balance: BigInt
+  // local - dynamic per transactions
+  lockedInBuiltTxs: BigInt // built txs - not submitted/confirmed
+}
+
+export type PortfolioBalancePrimaryRecord = {
+  source: 'rewards' | 'deposit'
+  quantity: BigInt
+  redeemableAfter: number // 0 means anytime with withdrawal, epoch or infinity means anytime with reverse tx
+}
+
+export type PortfolioBalancePrimaryBreakdown = PortfolioTokenBalance & {
+  // local - dynamic per epoch
+  minRequiredByTokens: BigInt // required on utxos to keep tokens (storage cost)
+  // remote - dynamic per epoch
+  records: ReadonlyArray<PortfolioBalancePrimaryRecord>
+}
diff --git a/packages/types/src/portfolio/discovery.ts b/packages/types/src/portfolio/discovery.ts
new file mode 100644
index 0000000000..91dc1e02de
--- /dev/null
+++ b/packages/types/src/portfolio/discovery.ts
@@ -0,0 +1,39 @@
+import {
+  PortfolioTokenId,
+  PortfolioTokenPropertyType,
+  PortfolioTokenSource,
+} from './token'
+
+export type PortfolioTokenDiscovery = {
+  id: PortfolioTokenId
+
+  source: {
+    name: PortfolioTokenSource
+    decimals: PortfolioTokenSource
+    ticker: PortfolioTokenSource
+    symbol: PortfolioTokenSource
+    image: PortfolioTokenSource
+  }
+
+  originalMetadata: {
+    filteredMintMetadatum: null | Record<string, unknown>
+    referenceDatum: null | Record<string, unknown>
+    tokenRegistry: null | Record<string, unknown>
+  }
+
+  counters: {
+    supply: BigInt
+    items: number
+    totalItems: number
+  }
+
+  properties:
+    | {
+        [property: string]: {
+          rarity: number
+          detectedType: PortfolioTokenPropertyType
+          value: any
+        }
+      }
+    | {}
+}
diff --git a/packages/types/src/portfolio/event.ts b/packages/types/src/portfolio/event.ts
new file mode 100644
index 0000000000..5a4bdabb2f
--- /dev/null
+++ b/packages/types/src/portfolio/event.ts
@@ -0,0 +1,46 @@
+import {PortfolioTokenId} from './token'
+
+export type PortfolioEventSourceId = Readonly<{
+  sourceId: string
+}>
+
+export enum PortfolioEventManagerOn {
+  Sync = 'sync',
+  Hydrate = 'hydrate',
+  Refresh = 'refresh',
+}
+
+export type PortfolioEventTokenManager =
+  | PortfolioEventTokenManagerSync
+  | PortfolioEventTokenManagerHydrate
+
+export type PortfolioEventTokenManagerSync = PortfolioEventSourceId &
+  Readonly<{
+    on: PortfolioEventManagerOn.Sync
+    ids: ReadonlyArray<PortfolioTokenId>
+  }>
+
+export type PortfolioEventTokenManagerHydrate = PortfolioEventSourceId &
+  Readonly<{
+    on: PortfolioEventManagerOn.Hydrate
+  }>
+
+export type PortfolioEventBalanceManager =
+  | PortfolioEventBalanceManagerSync
+  | PortfolioEventBalanceManagerHydrate
+  | PortfolioEventBalanceManagerRefresh
+
+export type PortfolioEventBalanceManagerSync = PortfolioEventSourceId &
+  Readonly<{
+    on: PortfolioEventManagerOn.Sync
+  }>
+
+export type PortfolioEventBalanceManagerHydrate = PortfolioEventSourceId &
+  Readonly<{
+    on: PortfolioEventManagerOn.Hydrate
+  }>
+
+export type PortfolioEventBalanceManagerRefresh = PortfolioEventSourceId &
+  Readonly<{
+    on: PortfolioEventManagerOn.Refresh
+  }>
diff --git a/packages/types/src/portfolio/info.ts b/packages/types/src/portfolio/info.ts
new file mode 100644
index 0000000000..13ad83268a
--- /dev/null
+++ b/packages/types/src/portfolio/info.ts
@@ -0,0 +1,41 @@
+import {
+  PortfolioTokenApplication,
+  PortfolioTokenId,
+  PortfolioTokenNature,
+  PortfolioTokenStatus,
+  PortfolioTokenType,
+} from './token'
+
+type CommonTokenInfo = {
+  decimals: number
+  ticker: string // Shorthand as token e.g., ADA
+
+  name: string
+  symbol: string // Shorthand as monetary i.e., Ω
+
+  status: PortfolioTokenStatus // Backend meta (needs logic / starts as normal)
+  application: PortfolioTokenApplication // Backend meta (based on policyId)
+
+  tag: string
+  reference: string // output
+  fingerprint: string
+
+  website: string // Full link with protocol URI
+
+  originalImage: string // Base link to image or base64 - fullsize
+}
+
+type PrimaryTokenInfo = {
+  id: '.'
+  nature: PortfolioTokenNature.Primary
+  type: PortfolioTokenType.FT
+}
+
+type SecondaryTokenInfo = {
+  id: PortfolioTokenId
+  nature: PortfolioTokenNature.Secondary
+  type: PortfolioTokenType
+}
+
+export type PortfolioTokenInfo = CommonTokenInfo &
+  (PrimaryTokenInfo | SecondaryTokenInfo)
diff --git a/packages/types/src/portfolio/manager.ts b/packages/types/src/portfolio/manager.ts
new file mode 100644
index 0000000000..1a3a8f1924
--- /dev/null
+++ b/packages/types/src/portfolio/manager.ts
@@ -0,0 +1,57 @@
+import {Observable, Subscription} from 'rxjs'
+
+import {AppCacheRecord} from '../app/cache'
+import {AppObserverSubscribe} from '../app/observer-manager'
+import {
+  PortfolioBalancePrimaryBreakdown,
+  PortfolioTokenBalance,
+} from './balance'
+import {
+  PortfolioEventBalanceManager,
+  PortfolioEventSourceId,
+  PortfolioEventTokenManager,
+} from './event'
+import {PortfolioTokenInfo} from './info'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioManagerToken = Readonly<{
+  hydrate: (params: PortfolioEventSourceId) => void
+  sync: (
+    params: Readonly<{
+      secondaryTokenIds: ReadonlyArray<PortfolioTokenId>
+    }> &
+      PortfolioEventSourceId,
+  ) => Promise<Map<PortfolioTokenId, AppCacheRecord<PortfolioTokenInfo> | null>>
+
+  subscribe: AppObserverSubscribe<PortfolioEventTokenManager>
+  unsubscribe: (sub: Subscription) => void
+  observable: Observable<PortfolioEventTokenManager>
+
+  destroy: () => void
+}>
+
+export type PortfolioManagerBalance = Readonly<{
+  hydrate: () => void
+  refresh: () => void
+  sync: (
+    params: Readonly<{
+      primaryBalance: Readonly<Omit<PortfolioBalancePrimaryBreakdown, 'info'>>
+      secondaryBalances: Readonly<
+        | Map<PortfolioTokenId, Omit<PortfolioTokenBalance, 'info'>>
+        | Map<PortfolioTokenId, PortfolioTokenBalance>
+      >
+    }>,
+  ) => void
+
+  subscribe: AppObserverSubscribe<PortfolioEventBalanceManager>
+  unsubscribe: (sub: Subscription) => void
+  observable: Observable<PortfolioEventBalanceManager>
+
+  getPrimaryBreakdown: () => Readonly<PortfolioBalancePrimaryBreakdown>
+  getBalances: () => Readonly<{
+    all: ReadonlyArray<PortfolioTokenBalance>
+    fts: ReadonlyArray<PortfolioTokenBalance>
+    nfts: ReadonlyArray<PortfolioTokenBalance>
+  }>
+  destroy: () => void
+}>
diff --git a/packages/types/src/portfolio/price.ts b/packages/types/src/portfolio/price.ts
new file mode 100644
index 0000000000..5644fb6b30
--- /dev/null
+++ b/packages/types/src/portfolio/price.ts
@@ -0,0 +1,9 @@
+import BigNumber from 'bignumber.js'
+
+import {Maybe} from '../helpers/types'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioTokenPrice = {
+  id: PortfolioTokenId
+  price: Maybe<BigNumber> // in primary token terms
+}
diff --git a/packages/types/src/portfolio/storage.ts b/packages/types/src/portfolio/storage.ts
new file mode 100644
index 0000000000..1142f20d33
--- /dev/null
+++ b/packages/types/src/portfolio/storage.ts
@@ -0,0 +1,68 @@
+import {AppCacheRecord} from '../app/cache'
+import {
+  PortfolioBalancePrimaryBreakdown,
+  PortfolioTokenBalance,
+} from './balance'
+import {PortfolioTokenDiscovery} from './discovery'
+import {PortfolioTokenInfo} from './info'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioStorageBalance = Readonly<{
+  primaryBalanceBreakdown: {
+    save: (entry: PortfolioBalancePrimaryBreakdown) => void
+    read: (key: PortfolioTokenId) => PortfolioBalancePrimaryBreakdown | null
+    clear: () => void
+  }
+  balances: {
+    save: (
+      entries: ReadonlyArray<[PortfolioTokenId, PortfolioTokenBalance]>,
+    ) => void
+    read: (
+      keys: ReadonlyArray<PortfolioTokenId>,
+    ) => ReadonlyArray<[PortfolioTokenId, PortfolioTokenBalance | null]>
+    all: () => ReadonlyArray<[PortfolioTokenId, PortfolioTokenBalance | null]>
+    keys: () => ReadonlyArray<PortfolioTokenId>
+    clear: () => void
+  }
+  clear: () => void
+}>
+
+export type PortfolioStorageToken = Readonly<{
+  token: {
+    infos: {
+      save: (
+        entries: ReadonlyArray<
+          [PortfolioTokenId, AppCacheRecord<PortfolioTokenInfo>]
+        >,
+      ) => void
+      read: (
+        keys: ReadonlyArray<PortfolioTokenId>,
+      ) => ReadonlyArray<
+        [PortfolioTokenId, AppCacheRecord<PortfolioTokenInfo> | null]
+      >
+      all: () => ReadonlyArray<
+        [PortfolioTokenId, AppCacheRecord<PortfolioTokenInfo> | null]
+      >
+      keys: () => ReadonlyArray<PortfolioTokenId>
+      clear: () => void
+    }
+    discoveries: {
+      save: (
+        entries: ReadonlyArray<
+          [PortfolioTokenId, AppCacheRecord<PortfolioTokenDiscovery>]
+        >,
+      ) => void
+      read: (
+        keys: ReadonlyArray<PortfolioTokenId>,
+      ) => ReadonlyArray<
+        [PortfolioTokenId, AppCacheRecord<PortfolioTokenDiscovery> | null]
+      >
+      all: () => ReadonlyArray<
+        [PortfolioTokenId, AppCacheRecord<PortfolioTokenDiscovery> | null]
+      >
+      keys: () => ReadonlyArray<PortfolioTokenId>
+      clear: () => void
+    }
+  }
+  clear: () => void
+}>
diff --git a/packages/types/src/portfolio/token.ts b/packages/types/src/portfolio/token.ts
new file mode 100644
index 0000000000..a80d4c75e9
--- /dev/null
+++ b/packages/types/src/portfolio/token.ts
@@ -0,0 +1,52 @@
+export type PortfolioTokenId = `${string}.${string}`
+
+export enum PortfolioTokenType {
+  FT = 'ft',
+  NFT = 'nft',
+}
+
+export enum PortfolioTokenPropertyType {
+  Number = 'number',
+  Social = 'social',
+  Document = 'document',
+  File = 'file',
+  Image = 'image',
+  Link = 'link',
+  Boolean = 'boolean',
+  Base64 = 'base64',
+  List = 'list',
+  String = 'string',
+  Record = 'record',
+  Audio = 'audio',
+  Video = 'video',
+}
+
+export enum PortfolioTokenApplication {
+  Domain = 'domain',
+  Music = 'music',
+  Stablecoin = 'stablecoin',
+  General = 'general',
+  Coin = 'coin',
+  Lp = 'lp',
+}
+
+export enum PortfolioTokenSource {
+  Registry = 'registry',
+  Metadata = 'metadata',
+  Datum = 'datum',
+  ID = 'id',
+  None = 'none',
+}
+
+export enum PortfolioTokenNature {
+  Primary = 'primary',
+  Secondary = 'secondary',
+}
+
+export enum PortfolioTokenStatus {
+  Accredited = 'accredited',
+  Scam = 'scam',
+  Invalid = 'invalid',
+  Valid = 'valid',
+  Unknown = 'unknown',
+}
diff --git a/scripts/install-pkgs.sh b/scripts/install-pkgs.sh
index 4504f811cd..54fe180fe0 100644
--- a/scripts/install-pkgs.sh
+++ b/scripts/install-pkgs.sh
@@ -19,6 +19,10 @@ yarn workspace @yoroi/common add -D @yoroi/types@"$1"
 yarn workspace @yoroi/api add -D @yoroi/types@"$1"
 yarn workspace @yoroi/api add @yoroi/common@"$1"
 
+# portfolio 
+yarn workspace @yoroi/portfolio add -D @yoroi/types@"$1"
+yarn workspace @yoroi/portfolio add @yoroi/common@"$1"
+
 # swap
 yarn workspace @yoroi/swap add -D @yoroi/types@"$1"
 yarn workspace @yoroi/swap add @yoroi/api@"$1"
@@ -55,4 +59,4 @@ yarn workspace @yoroi/wallet-mobile add @yoroi/staking@"$1"
 yarn workspace @yoroi/wallet-mobile add @yoroi/resolver@"$1"
 yarn workspace @yoroi/wallet-mobile add @yoroi/theme@"$1"
 
-echo "Using new packages..."
\ No newline at end of file
+echo "Using new packages..."
diff --git a/yarn.lock b/yarn.lock
index 2ff7ee7a97..976205c957 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -13616,6 +13616,11 @@ immer@^10.0.2:
   resolved "https://registry.yarnpkg.com/immer/-/immer-10.0.2.tgz#11636c5b77acf529e059582d76faf338beb56141"
   integrity sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==
 
+immer@^10.0.3:
+  version "10.0.4"
+  resolved "https://registry.yarnpkg.com/immer/-/immer-10.0.4.tgz#09af41477236b99449f9d705369a4daaf780362b"
+  integrity sha512-cuBuGK40P/sk5IzWa9QPUaAdvPHjkk1c+xYsd9oZw+YQQEV+10G0P5uMpGctZZKnyQ+ibRO08bD25nWLmYi2pw==
+
 import-fresh@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-2.0.0.tgz#d81355c15612d386c61f9ddd3922d4304822a546"
@@ -21715,7 +21720,16 @@ string-natural-compare@^3.0.1:
   resolved "https://registry.yarnpkg.com/string-natural-compare/-/string-natural-compare-3.0.1.tgz#7a42d58474454963759e8e8b7ae63d71c1e7fdf4"
   integrity sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==
 
-"string-width-cjs@npm:string-width@^4.2.0", "string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
+"string-width-cjs@npm:string-width@^4.2.0":
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+"string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
   version "4.2.3"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -21828,7 +21842,7 @@ string_decoder@~1.1.1:
   dependencies:
     safe-buffer "~5.1.0"
 
-"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1":
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
@@ -21856,6 +21870,13 @@ strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0:
   dependencies:
     ansi-regex "^4.1.0"
 
+strip-ansi@^6.0.0, strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
 strip-ansi@^7.0.1:
   version "7.1.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
@@ -23486,7 +23507,7 @@ workerpool@6.2.1:
   resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.1.tgz#46fc150c17d826b86a008e5a4508656777e9c343"
   integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==
 
-"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
@@ -23522,6 +23543,15 @@ wrap-ansi@^6.0.1, wrap-ansi@^6.2.0:
     string-width "^4.1.0"
     strip-ansi "^6.0.0"
 
+wrap-ansi@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
 wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
diff --git a/yoroi.code-workspace b/yoroi.code-workspace
index fb8820d889..d428eac8a3 100644
--- a/yoroi.code-workspace
+++ b/yoroi.code-workspace
@@ -48,6 +48,10 @@
       "name": "@yoroi/staking",
       "path": "./packages/staking"
     },
+    {
+      "name": "@yoroi/portfolio",
+      "path": "./packages/portfolio"
+    },
     {
       "name": "@yoroi/wallet-mobile",
       "path": "./apps/wallet-mobile"
@@ -57,9 +61,10 @@
       "path": "./e2e/wallet-mobile"
     }
   ],
-
   "settings": {
-    "jest.disabledWorkspaceFolders": ["root"],
+    "jest.disabledWorkspaceFolders": [
+      "root"
+    ],
     "jest.pathToJest": "node_modules/.bin/jest",
     "jest.pathToConfig": "./jest.config.js",
     "java.compile.nullAnalysis.mode": "automatic",
@@ -68,6 +73,6 @@
     "typescript.tsserver.maxTsServerMemory": 12072,
     "typescript.tsdk": "root/node_modules/typescript/lib",
     "javascript.preferences.importModuleSpecifier": "relative",
-    "typescript.preferences.importModuleSpecifier": "relative",
+    "typescript.preferences.importModuleSpecifier": "relative"
   }
-}
+}
\ No newline at end of file