@unisat/wallet-state 1.0.5 → 1.2.0

package/src/hooks/global.ts

@@ -2,12 +2,11 @@ import { useCallback } from 'react'
 
 import { AddressType } from '@unisat/wallet-types'
 
-import { AppState } from '..'
-import { useAppDispatch, useAppSelector } from './base'
-import { globalActions } from '../reducers/global'
+import { AppState, useApproval, useNavigation } from '..'
 import { useWallet } from '../context/WalletContext'
-import { useApproval } from './approval'
+import { globalActions } from '../reducers/global'
 import { TabOption } from '../types'
+import { useAppDispatch, useAppSelector } from './base'
 
 export function useGlobalState(): AppState['global'] {
   return useAppSelector(state => state.global)
@@ -18,6 +17,25 @@ export function useTab() {
   return globalState.tab
 }
 
+export function useScreenState() {
+  const globalState = useGlobalState()
+  return globalState.screenState
+}
+
+export function useUpdateScreenStateCallback() {
+  const dispatch = useAppDispatch()
+  return useCallback(
+    (screenState: Partial<AppState['global']['screenState']>) => {
+      dispatch(
+        globalActions['updateScreenState']!({
+          screenState,
+        })
+      )
+    },
+    [dispatch]
+  )
+}
+
 export function useSetTabCallback() {
   const dispatch = useAppDispatch()
   return useCallback(
@@ -47,10 +65,153 @@ export function useIsReady() {
   return globalState.isReady
 }
 
+export function useIsRefresh() {
+  const globalState = useGlobalState()
+  return globalState.isRefresh
+}
+
+export function useBackRefresh() {
+  const globalState = useGlobalState()
+  return globalState.backRefresh
+}
+
+export function useWallRefresh() {
+  const globalState = useGlobalState()
+  return globalState.wallRefresh
+}
+
+export function useWallTabRefresh() {
+  const globalState = useGlobalState()
+  return globalState.wallTabRefresh
+}
+
+export function useWallTabFocusRefresh() {
+  const globalState = useGlobalState()
+  return globalState.wallTabFocusRefresh
+}
+
+export function useGoBackRefresh() {
+  const globalState = useGlobalState()
+  return globalState.goBackRefresh
+}
+
+export function useLayerState() {
+  const globalState = useGlobalState()
+  return globalState.layerState
+}
+
+export function useUnlockRefresh() {
+  const globalState = useGlobalState()
+  return globalState.unlockRefres
+}
+
+export function useUnlockRead() {
+  const globalState = useGlobalState()
+  return globalState.unlockRead
+}
+export function useIsUnlockTimeRefres() {
+  const globalState = useGlobalState()
+  return globalState.isUnlockTimeRefres
+}
+
+export function useInfiniteListScrollOffset() {
+  const globalState = useGlobalState()
+  return globalState.infiniteListScrollOffset
+}
+
+export function useInfiniteListScrollState() {
+  const globalState = useGlobalState()
+  return {
+    offset: globalState.infiniteListScrollOffset,
+    direction: globalState.infiniteListScrollDirection,
+    activeTime: globalState.infiniteListScrollActiveTime,
+  }
+}
+
+export function useIsScrollViewTop() {
+  const globalState = useGlobalState()
+  return globalState.isScrollViewTop
+}
+
+export function useIsScrollViewBot() {
+  const globalState = useGlobalState()
+  return globalState.isScrollViewBot
+}
+
+export function useIsBiometricsSupported() {
+  const globalState = useGlobalState()
+  return globalState.isBiometricsSupported
+}
+
+export function useHasBiometricsKey() {
+  const globalState = useGlobalState()
+  return globalState.hasBiometricsKey
+}
+
+export function useSwitchChainModalVisible() {
+  const globalState = useGlobalState()
+  return globalState.switchChainModalVisible
+}
+
+export function useSetLockedOverlayVisibleCallback() {
+  const dispatch = useAppDispatch()
+  return useCallback(
+    (visible: boolean) => {
+      dispatch(
+        globalActions['update']!({
+          isLockedOverlayVisible: visible,
+        })
+      )
+    },
+    [dispatch]
+  )
+}
+
+export function useLockedOverlayVisible() {
+  const globalState = useGlobalState()
+  return globalState.isLockedOverlayVisible
+}
+
+export function useLockCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  const navigation = useNavigation()
+  return useCallback(async () => {
+    dispatch(globalActions.update({ isLockedOverlayVisible: true }))
+    await wallet.lockWallet()
+    const isBooted = await wallet.isBooted()
+    const isUnlocked = await wallet.isUnlocked()
+    dispatch(globalActions.update({ isUnlocked: false }))
+
+    setTimeout(() => {
+      dispatch(globalActions.update({ isLockedOverlayVisible: false }))
+    }, 300)
+
+    if (!isBooted) {
+      navigation.navToWelcome()
+      return
+    }
+
+    if (!isUnlocked && !isBooted) {
+      navigation.navToWelcome()
+      return
+    }
+
+    if (!isUnlocked && isBooted) {
+      navigation.navToLock({ autoUnlockByFace: false })
+      return
+    }
+    const currentAccount = await wallet.getCurrentAccount()
+    if (!currentAccount) {
+      navigation.navToWelcome()
+    }
+  }, [dispatch, wallet])
+}
+
 export function useUnlockCallback() {
   const dispatch = useAppDispatch()
   const wallet = useWallet()
-  const [, resolveApproval] = useApproval()
+  const { resolveApproval } = useApproval()
   return useCallback(
     async (password: string) => {
       await wallet.unlock(password)
@@ -70,14 +231,16 @@ export function useCreateAccountCallback() {
       hdPath: string,
       passphrase: string,
       addressType: AddressType,
-      accountCount: number
+      accountCount: number,
+      accountIndexDerivation = false
     ) => {
       await wallet.createKeyringWithMnemonics(
         mnemonics,
         hdPath,
         passphrase,
         addressType,
-        accountCount
+        accountCount,
+        accountIndexDerivation
       )
       dispatch(globalActions.update({ isUnlocked: true }))
     },

package/src/hooks/index.ts

@@ -1,10 +1,9 @@
 export * from './accounts'
-export * from './approval'
 export * from './base'
 export * from './discovery'
 export * from './global'
-export * from './i18n'
 export * from './keyrings'
 export * from './settings'
 export * from './transactions'
 export * from './ui'
+export * from './browser'

package/src/hooks/settings.ts

@@ -1,18 +1,17 @@
 import compareVersions from 'compare-versions'
 import { useCallback } from 'react'
 
-import { CHAINS_MAP, CAT_VERSION, VERSION } from '@unisat/wallet-shared'
+import { BABYLON_CONFIG_MAP } from '@unisat/babylon-service/types'
+import { CAT_VERSION, CHAINS_MAP, PlatformEnv } from '@unisat/wallet-shared'
 import { AddressType, ChainType, NetworkType } from '@unisat/wallet-types'
 import { useWallet } from '../context/WalletContext'
 import { getAddressType } from '../utils/bitcoin-utils'
-import i18n, { addResourceBundle } from '../utils/i18n'
-import { BABYLON_CONFIG_MAP } from '@unisat/babylon-service/types'
-import { t } from '@unisat/i18n'
 
+import { useI18n } from 'src/context/I18nContext'
 import { AppState } from '..'
 import { useCurrentAccount } from '../hooks/accounts'
-import { useAppDispatch, useAppSelector } from './base'
 import { settingsActions } from '../reducers/settings'
+import { useAppDispatch, useAppSelector } from './base'
 
 export function useSettingsState(): AppState['settings'] {
   return useAppSelector(state => state.settings)
@@ -26,11 +25,12 @@ export function useLocale() {
 export function useChangeLocaleCallback() {
   const dispatch = useAppDispatch()
   const wallet = useWallet()
+  const i18n = useI18n()
   return useCallback(
     async (locale: string) => {
       await wallet.setLocale(locale)
-      await addResourceBundle(locale)
-      i18n.changeLanguage(locale)
+      await i18n.addResourceBundle(locale)
+      i18n.changeLocale(locale)
       dispatch(
         (settingsActions as any).updateSettings({
           locale,
@@ -94,12 +94,12 @@ export function useChangeChainTypeCallback() {
   const wallet = useWallet()
   return useCallback(
     async (type: ChainType) => {
+      await wallet.setChainType(type)
       dispatch(
         (settingsActions as any).updateSettings({
           chainType: type,
         })
       )
-      await wallet.setChainType(type)
     },
     [dispatch]
   )
@@ -157,11 +157,31 @@ export function useCAT20TokenInfoExplorerUrl(version: CAT_VERSION, tokenId: stri
   }
 }
 
+export function useBRC20TokenInfoExplorerUrl(ticker: string) {
+  const chain = useChain()!
+  return `${chain.unisatExplorerUrl}/brc20/${encodeURIComponent(ticker)}`
+}
+
+export function useRunesTokenInfoExplorerUrl(runeId: string) {
+  const chain = useChain()!
+  return `${chain.unisatExplorerUrl}/runes/detail/${encodeURIComponent(runeId)}`
+}
+
+export function useAlkanesTokenInfoExplorerUrl(alkaneId: string) {
+  const chain = useChain()!
+  return `${chain.unisatExplorerUrl}/alkanes/detail/${encodeURIComponent(alkaneId)}`
+}
+
 export function useUnisatWebsite() {
   const chainType = useChainType()
   return CHAINS_MAP[chainType]!.unisatUrl
 }
 
+export function useIconBaseUrl() {
+  const chainType = useChainType()
+  return CHAINS_MAP[chainType]!.iconBaseUrl
+}
+
 export function useOrdinalsWebsite() {
   const chainType = useChainType()
   return CHAINS_MAP[chainType]!.ordinalsUrl
@@ -177,7 +197,7 @@ export function useVersionInfo() {
   const walletConfig = accountsState.walletConfig
   const newVersion = walletConfig.version
   const skippedVersion = accountsState.skippedVersion
-  const currentVesion = VERSION!
+  const currentVesion = PlatformEnv.VERSION
   let skipped = false
   let latestVersion = ''
   // skip if new version is empty
@@ -191,7 +211,7 @@ export function useVersionInfo() {
   }
 
   // skip if current version is greater or equal to new version
-  if (newVersion) {
+  if (currentVesion && newVersion) {
     if (compareVersions(currentVesion, newVersion) >= 0) {
       skipped = true
     } else {
@@ -208,6 +228,8 @@ export function useVersionInfo() {
     newVersion,
     latestVersion,
     skipped,
+    downloadUrl: '',
+    isNewest: false,
   }
 }
 
@@ -226,7 +248,12 @@ export function useAutoLockTimeId() {
   return state.autoLockTimeId
 }
 
-export function getAddressTips(address: string, chanEnum: ChainType) {
+export function useAddressTips() {
+  const chain = useChain()!
+  const account = useCurrentAccount()
+  const address = account.address
+  const chanEnum = chain.enum
+  const { t } = useI18n()
   let ret = {
     homeTip: '',
     sendTip: '',
@@ -247,12 +274,6 @@ export function getAddressTips(address: string, chanEnum: ChainType) {
   return ret
 }
 
-export function useAddressTips() {
-  const chain = useChain()!
-  const account = useCurrentAccount()
-  return getAddressTips(account.address, chain.enum)
-}
-
 export function useCAT721NFTContentBaseUrl(version: CAT_VERSION) {
   const chainType = useChainType()
   if (chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
@@ -268,26 +289,6 @@ export function useCAT721NFTContentBaseUrl(version: CAT_VERSION) {
   }
 }
 
-export function useBRC20MarketPlaceWebsite(ticker: string) {
-  const chainType = useChainType()
-  if (chainType === ChainType.BITCOIN_MAINNET) {
-    if (ticker.length == 6) {
-      return `${CHAINS_MAP[chainType]!.unisatUrl}/market/brc20_prog?tick=${ticker}`
-    }
-  }
-  return `${CHAINS_MAP[chainType]!.unisatUrl}/market/brc20?tick=${ticker}`
-}
-
-export function useRunesMarketPlaceWebsite(ticker: string) {
-  const chainType = useChainType()
-  return `${CHAINS_MAP[chainType]!.unisatUrl}/runes/market?tick=${ticker}`
-}
-
-export function useCAT20MarketPlaceWebsite(tokenId: string) {
-  const chainType = useChainType()
-  return `${CHAINS_MAP[chainType]!.unisatUrl}/dex/cat20/${tokenId}`
-}
-
 export function useBabylonConfig() {
   const chainType = useChainType()
   return BABYLON_CONFIG_MAP[chainType] || BABYLON_CONFIG_MAP[ChainType.BITCOIN_MAINNET]