@unisat/wallet-state 1.0.0 → 1.0.1

package/src/hooks/accounts.ts

@@ -1,15 +1,17 @@
 import { useCallback } from 'react'
 
-import { Account, AddressType } from '@/shared/types'
-import { useWallet } from '@/ui/utils'
+import { Account } from '@unisat/wallet-shared'
+
+import { AddressType } from '@unisat/wallet-types'
 import { KeyringType } from '@unisat/keyring-service/types'
 
 import { AppState } from '..'
-import { useAppDispatch, useAppSelector } from '../hooks'
-import { useCurrentKeyring } from '../keyrings/hooks'
-import { keyringsActions } from '../keyrings/reducer'
-import { settingsActions } from '../settings/reducer'
-import { accountActions } from './reducer'
+import { useAppDispatch, useAppSelector } from './base'
+import { useCurrentKeyring } from './keyrings'
+import { keyringsActions } from '../reducers/keyrings'
+import { settingsActions } from '../reducers/settings'
+import { accountActions } from '../reducers/accounts'
+import { useWallet } from '../context/WalletContext'
 
 export function useAccountsState(): AppState['accounts'] {
   return useAppSelector(state => state.accounts)
@@ -78,7 +80,7 @@ export function useReadTab() {
       await wallet.readTab(name)
       if (name == 'app') {
         const appSummary = await wallet.getAppSummary()
-        dispatch(accountActions.setAppSummary(appSummary))
+        dispatch(accountActions['setAppSummary']!(appSummary))
       }
     },
     [dispatch, wallet, appSummary]
@@ -93,7 +95,7 @@ export function useReadApp() {
     async (id: number) => {
       await wallet.readApp(id)
       const appSummary = await wallet.getAppSummary()
-      dispatch(accountActions.setAppSummary(appSummary))
+      dispatch(accountActions['setAppSummary']!(appSummary))
     },
     [dispatch, wallet, appSummary]
   )
@@ -114,7 +116,7 @@ export function useSetCurrentAccountCallback() {
   const dispatch = useAppDispatch()
   return useCallback(
     (account: Account) => {
-      dispatch(accountActions.setCurrent(account))
+      dispatch(accountActions['setCurrent']!(account))
     },
     [dispatch]
   )
@@ -132,7 +134,7 @@ export function useImportAccountCallback() {
         const alianName = await wallet.getNextAlianName(currentKeyring)
         await wallet.createKeyringWithPrivateKey(privateKey, addressType, alianName)
         const currentAccount = await wallet.getCurrentAccount()
-        dispatch(accountActions.setCurrent(currentAccount))
+        dispatch(accountActions['setCurrent']!(currentAccount))
 
         success = true
       } catch (e) {
@@ -154,7 +156,7 @@ export function useChangeAddressFlagCallback() {
       const account = isAdd
         ? await wallet.addAddressFlag(currentAccount, flag)
         : await wallet.removeAddressFlag(currentAccount, flag)
-      dispatch(accountActions.setCurrentAddressFlag(account.flag))
+      dispatch(accountActions['setCurrentAddressFlag']!(account.flag))
     },
     [dispatch, wallet, currentAccount]
   )
@@ -201,11 +203,11 @@ export function useFetchBalanceCallback() {
 
     const summary = await wallet.getAddressSummary(currentAccount.address)
     summary.address = currentAccount.address
-    dispatch(accountActions.setAddressSummary(summary))
+    dispatch(accountActions['setAddressSummary']!(summary))
 
     const balanceV2 = await wallet.getAddressBalanceV2(currentAccount.address)
     dispatch(
-      accountActions.setBalanceV2({
+      accountActions['setBalanceV2']!({
         address: currentAccount.address,
         balance: balanceV2,
       })
@@ -218,22 +220,22 @@ export function useReloadAccounts() {
   const wallet = useWallet()
   return useCallback(async () => {
     const keyrings = await wallet.getKeyrings()
-    dispatch(keyringsActions.setKeyrings(keyrings))
+    dispatch(keyringsActions['setKeyrings']!(keyrings))
 
     const currentKeyring = await wallet.getCurrentKeyring()
-    dispatch(keyringsActions.setCurrent(currentKeyring))
+    dispatch(keyringsActions['setCurrent']!(currentKeyring))
 
     const _accounts = await wallet.getAccounts()
-    dispatch(accountActions.setAccounts(_accounts))
+    dispatch(accountActions['setAccounts']!(_accounts))
 
     const account = await wallet.getCurrentAccount()
-    dispatch(accountActions.setCurrent(account))
+    dispatch(accountActions['setCurrent']!(account))
 
-    dispatch(accountActions.expireBalance())
-    dispatch(accountActions.expireInscriptions())
+    dispatch(accountActions['expireBalance']!(null))
+    dispatch(accountActions['expireInscriptions']!(null))
 
     wallet.getWalletConfig().then(data => {
-      dispatch(settingsActions.updateSettings({ walletConfig: data }))
+      dispatch(settingsActions['updateSettings']!({ walletConfig: data }))
     })
   }, [dispatch, wallet])
 }

package/src/hooks/approval.ts

@@ -0,0 +1,72 @@
+import { useEffect, useRef, useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+
+import { useWallet } from '../context/WalletContext'
+
+const UI_TYPE = {
+  Tab: 'index',
+  Pop: 'popup',
+  Notification: 'notification',
+  SidePanel: 'sidepanel',
+}
+
+type UiTypeCheck = {
+  isTab: boolean
+  isNotification: boolean
+  isPop: boolean
+  isSidePanel: boolean
+}
+
+export const getUiType = (): UiTypeCheck => {
+  // @ts-ignore
+  const { pathname } = window.location
+  return Object.entries(UI_TYPE).reduce((m, [key, value]) => {
+    // @ts-ignore
+    m[`is${key}`] = pathname === `/${value}.html`
+
+    return m
+  }, {} as UiTypeCheck)
+}
+
+export const useApproval = () => {
+  const wallet = useWallet()
+  const navigate = useNavigate()
+  const getApproval = wallet.getApproval
+
+  const resolveApproval = async (data?: any, stay = false, forceReject = false) => {
+    const approval = await getApproval()
+
+    if (approval) {
+      wallet.resolveApproval(data, forceReject)
+    }
+    if (stay) {
+      return
+    }
+    setTimeout(() => {
+      navigate('/')
+    })
+  }
+
+  const rejectApproval = async (err: any, stay = false, isInternal = false) => {
+    const approval = await getApproval()
+    if (approval) {
+      await wallet.rejectApproval(err, stay, isInternal)
+    }
+    if (!stay) {
+      navigate('/')
+    }
+  }
+
+  useEffect(() => {
+    if (!getUiType().isNotification) {
+      return () => {}
+    }
+    // @ts-ignore
+    window.addEventListener('beforeunload', rejectApproval)
+
+    // @ts-ignore
+    return () => window.removeEventListener('beforeunload', rejectApproval)
+  }, [])
+
+  return [getApproval, resolveApproval, rejectApproval] as const
+}

package/src/hooks/base.ts

@@ -0,0 +1,6 @@
+import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux'
+
+import { AppDispatch, AppState } from '../index'
+
+export const useAppDispatch = () => useDispatch<AppDispatch>()
+export const useAppSelector: TypedUseSelectorHook<AppState> = useSelector

package/src/hooks/discovery.ts

@@ -0,0 +1,29 @@
+import { AppState } from '..'
+import { useAppSelector } from './base'
+
+export function useDiscoveryState(): AppState['discovery'] {
+  return useAppSelector(state => state.discovery)
+}
+
+export function useAppList() {
+  const state = useDiscoveryState()
+  return state.appList
+}
+
+export function useBannerList() {
+  const state = useDiscoveryState()
+  return state.bannerList
+}
+
+export function useLastFetchInfo() {
+  const state = useDiscoveryState()
+  return {
+    lastFetchTime: state.lastFetchTime,
+    lasfFetchChainType: state.lastFetchChainType,
+  }
+}
+
+export function useHasNewBanner() {
+  const state = useDiscoveryState()
+  return state.hasNewBanner
+}

package/src/hooks/global.ts

@@ -1,7 +1,131 @@
-import { useWalletSelector } from './index';
+import { useCallback } from 'react'
 
-export const useGlobalState = () => {
-  return useWalletSelector((state) => state.global);
-};
+import { AddressType } from '@unisat/wallet-types'
 
-// Additional global hooks will be migrated here
+import { AppState } from '..'
+import { useAppDispatch, useAppSelector } from './base'
+import { TabOption, globalActions } from '../reducers/global'
+import { useWallet } from '../context/WalletContext'
+import { useApproval } from './approval'
+
+export function useGlobalState(): AppState['global'] {
+  return useAppSelector(state => state.global)
+}
+
+export function useTab() {
+  const globalState = useGlobalState()
+  return globalState.tab
+}
+
+export function useSetTabCallback() {
+  const dispatch = useAppDispatch()
+  return useCallback(
+    (tab: TabOption) => {
+      dispatch(
+        globalActions['update']!({
+          tab,
+        })
+      )
+    },
+    [dispatch]
+  )
+}
+
+export function useBooted() {
+  const globalState = useGlobalState()
+  return globalState.isBooted
+}
+
+export function useIsUnlocked() {
+  const globalState = useGlobalState()
+  return globalState.isUnlocked
+}
+
+export function useIsReady() {
+  const globalState = useGlobalState()
+  return globalState.isReady
+}
+
+export function useUnlockCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  const [, resolveApproval] = useApproval()
+  return useCallback(
+    async (password: string) => {
+      await wallet.unlock(password)
+      dispatch(globalActions.update({ isUnlocked: true }))
+      resolveApproval()
+    },
+    [dispatch, wallet]
+  )
+}
+
+export function useCreateAccountCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (
+      mnemonics: string,
+      hdPath: string,
+      passphrase: string,
+      addressType: AddressType,
+      accountCount: number
+    ) => {
+      await wallet.createKeyringWithMnemonics(
+        mnemonics,
+        hdPath,
+        passphrase,
+        addressType,
+        accountCount
+      )
+      dispatch(globalActions.update({ isUnlocked: true }))
+    },
+    [dispatch, wallet]
+  )
+}
+
+export function useImportAccountsFromKeystoneCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (
+      urType: string,
+      urCbor: string,
+      addressType: AddressType,
+      accountCount: number,
+      hdPath: string,
+      filterPubkey?: string[],
+      connectionType: 'USB' | 'QR' = 'USB'
+    ) => {
+      await wallet.createKeyringWithKeystone(
+        urType,
+        urCbor,
+        addressType,
+        hdPath,
+        accountCount,
+        filterPubkey,
+        connectionType
+      )
+      dispatch(globalActions.update({ isUnlocked: true }))
+    },
+    [dispatch, wallet]
+  )
+}
+
+export function useCreateColdWalletCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (
+      xpub: string,
+      addressType: AddressType,
+      alianName?: string,
+      hdPath?: string,
+      accountCount?: number
+    ) => {
+      await wallet.createKeyringWithColdWallet(xpub, addressType, alianName, hdPath, accountCount)
+      dispatch(globalActions.update({ isUnlocked: true }))
+    },
+    [dispatch, wallet]
+  )
+}

package/src/hooks/i18n.ts

@@ -0,0 +1,53 @@
+import { useContext } from 'react'
+
+import { I18nContext } from '../context/I18nContext'
+import { FALLBACK_LOCALE, getCurrentLocaleAsync, LOCALE_NAMES } from '@unisat/i18n'
+
+const defaultI18nContext = {
+  t: (key: string) => key,
+  locale: FALLBACK_LOCALE,
+  supportedLocales: [FALLBACK_LOCALE],
+  localeNames: LOCALE_NAMES,
+  changeLocale: async () => {
+    /* empty implementation */
+  },
+}
+
+/**
+ * Use i18n Hook
+ * @returns i18n context
+ */
+export const useI18n = () => {
+  try {
+    const context = useContext(I18nContext)
+
+    if (!context) {
+      console.warn('useI18n must be used within an I18nProvider, using default context instead')
+      return defaultI18nContext
+    }
+
+    return context as any
+  } catch (error) {
+    console.error('Error in useI18n:', error)
+    return defaultI18nContext
+  }
+}
+
+/**
+ * Get current language
+ * @returns current language code
+ */
+export const getCurrentLocale = async (): Promise<string> => {
+  return await getCurrentLocaleAsync()
+}
+
+/**
+ * Select special languages for style adaptation
+ * @returns { currentLocale: string, isSpecialLocale: boolean }
+ */
+export const getSpecialLocale = async () => {
+  const currentLocale = await getCurrentLocale()
+  const specialLocales = ['es', 'ru', 'fr', 'ja']
+  const isSpecialLocale = specialLocales.includes(currentLocale)
+  return { currentLocale, isSpecialLocale }
+}

package/src/hooks/index.ts

@@ -1,15 +1,9 @@
-import { useDispatch, useSelector, TypedUseSelectorHook } from 'react-redux';
-import type { WalletDispatch } from '../store';
-import type { AppState } from '../types';
-
-// Typed hooks for the wallet store
-export const useWalletDispatch = () => useDispatch<WalletDispatch>();
-export const useWalletSelector: TypedUseSelectorHook<AppState> = useSelector;
-
-// Re-export common hooks that will be migrated from existing code
-export * from './accounts';
-export * from './transactions';
-export * from './settings';
-export * from './global';
-export * from './keyrings';
-export * from './ui';
+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'

package/src/hooks/keyrings.ts

@@ -1,7 +1,16 @@
-import { useWalletSelector } from './index';
+import { AppState } from '..'
+import { useAppSelector } from './base'
 
-export const useKeyringsState = () => {
-  return useWalletSelector((state) => state.keyrings);
-};
+export function useKeyringsState(): AppState['keyrings'] {
+  return useAppSelector(state => state.keyrings)
+}
 
-// Additional keyrings hooks will be migrated here
+export function useKeyrings() {
+  const keyringsState = useKeyringsState()
+  return keyringsState.keyrings
+}
+
+export function useCurrentKeyring() {
+  const keyringsState = useKeyringsState()
+  return keyringsState.current
+}