@unisat/wallet-state 1.0.0 → 1.0.2

package/src/hooks/settings.ts

@@ -1,7 +1,320 @@
-import { useWalletSelector } from './index';
+import compareVersions from 'compare-versions'
+import { useCallback } from 'react'
 
-export const useSettingsState = () => {
-  return useWalletSelector((state) => state.settings);
-};
+import { CHAINS_MAP, CAT_VERSION, VERSION } 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'
 
-// Additional settings hooks will be migrated here
+import { AppState } from '..'
+import { useCurrentAccount } from '../hooks/accounts'
+import { useAppDispatch, useAppSelector } from './base'
+import { settingsActions } from '../reducers/settings'
+
+export function useSettingsState(): AppState['settings'] {
+  return useAppSelector(state => state.settings)
+}
+
+export function useLocale() {
+  const settings = useSettingsState()
+  return settings.locale
+}
+
+export function useChangeLocaleCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (locale: string) => {
+      await wallet.setLocale(locale)
+      await addResourceBundle(locale)
+      i18n.changeLanguage(locale)
+      dispatch(
+        (settingsActions as any).updateSettings({
+          locale,
+        })
+      )
+
+      // @ts-ignore
+      window.location.reload()
+    },
+    [dispatch, wallet]
+  )
+}
+
+export function useNetworkType() {
+  const accountsState = useSettingsState()
+  const chain = CHAINS_MAP[accountsState.chainType]
+  if (chain) {
+    return chain.networkType
+  } else {
+    return NetworkType.TESTNET
+  }
+}
+
+export function useChangeNetworkTypeCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (type: NetworkType) => {
+      if (type === NetworkType.MAINNET) {
+        await wallet.setChainType(ChainType.BITCOIN_MAINNET)
+        dispatch(
+          (settingsActions as any).updateSettings({
+            chainType: ChainType.BITCOIN_MAINNET,
+          })
+        )
+      } else if (type === NetworkType.TESTNET) {
+        await wallet.setChainType(ChainType.BITCOIN_TESTNET)
+        dispatch(
+          (settingsActions as any).updateSettings({
+            chainType: ChainType.BITCOIN_TESTNET,
+          })
+        )
+      }
+    },
+    [dispatch]
+  )
+}
+
+export function useChainType() {
+  const accountsState = useSettingsState()
+  return accountsState.chainType
+}
+
+export function useChain() {
+  const accountsState = useSettingsState()
+  return CHAINS_MAP[accountsState.chainType]
+}
+
+export function useChangeChainTypeCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (type: ChainType) => {
+      dispatch(
+        (settingsActions as any).updateSettings({
+          chainType: type,
+        })
+      )
+      await wallet.setChainType(type)
+    },
+    [dispatch]
+  )
+}
+
+export function useBTCUnit() {
+  const chainType = useChainType()
+  return CHAINS_MAP[chainType]!.unit
+}
+
+export function useTxExplorerUrl(txid: string) {
+  const chain = useChain()!
+  if (chain.enum === ChainType.BITCOIN_MAINNET) {
+    return `${chain.unisatExplorerUrl}/tx/${txid}`
+  } else if (chain.defaultExplorer === 'mempool-space') {
+    return `${chain.mempoolSpaceUrl}/tx/${txid}`
+  } else {
+    return `${chain.unisatExplorerUrl}/tx/${txid}`
+  }
+}
+
+export function useGetTxExplorerUrlCallback() {
+  const chain = useChain()!
+  return useCallback(
+    (txid: string) => {
+      if (chain.enum === ChainType.BITCOIN_MAINNET) {
+        return `${chain.unisatExplorerUrl}/tx/${txid}`
+      } else if (chain.defaultExplorer === 'mempool-space') {
+        return `${chain.mempoolSpaceUrl}/tx/${txid}`
+      } else {
+        return `${chain.unisatExplorerUrl}/tx/${txid}`
+      }
+    },
+    [chain]
+  )
+}
+
+export function useAddressExplorerUrl(address: string) {
+  const chain = useChain()!
+  if (chain.enum === ChainType.BITCOIN_MAINNET) {
+    return `${chain.unisatExplorerUrl}/address/${address}`
+  } else if (chain.defaultExplorer === 'mempool-space') {
+    return `${chain.mempoolSpaceUrl}/address/${address}`
+  } else {
+    return `${chain.unisatExplorerUrl}/address/${address}`
+  }
+}
+
+export function useCAT20TokenInfoExplorerUrl(version: CAT_VERSION, tokenId: string) {
+  const chain = useChain()!
+  if (version === CAT_VERSION.V1) {
+    return `${chain.unisatExplorerUrl}/cat20/${tokenId}`
+  } else {
+    return `${chain.unisatExplorerUrl}/cat20-v2/${tokenId}`
+  }
+}
+
+export function useUnisatWebsite() {
+  const chainType = useChainType()
+  return CHAINS_MAP[chainType]!.unisatUrl
+}
+
+export function useOrdinalsWebsite() {
+  const chainType = useChainType()
+  return CHAINS_MAP[chainType]!.ordinalsUrl
+}
+
+export function useWalletConfig() {
+  const accountsState = useSettingsState()
+  return accountsState.walletConfig
+}
+
+export function useVersionInfo() {
+  const accountsState = useSettingsState()
+  const walletConfig = accountsState.walletConfig
+  const newVersion = walletConfig.version
+  const skippedVersion = accountsState.skippedVersion
+  const currentVesion = VERSION!
+  let skipped = false
+  let latestVersion = ''
+  // skip if new version is empty
+  if (!newVersion) {
+    skipped = true
+  }
+
+  // skip if skipped
+  if (newVersion == skippedVersion) {
+    skipped = true
+  }
+
+  // skip if current version is greater or equal to new version
+  if (newVersion) {
+    if (compareVersions(currentVesion, newVersion) >= 0) {
+      skipped = true
+    } else {
+      latestVersion = newVersion
+    }
+  }
+
+  // skip if current version is 0.0.0
+  if (currentVesion === '0.0.0') {
+    skipped = true
+  }
+  return {
+    currentVesion,
+    newVersion,
+    latestVersion,
+    skipped,
+  }
+}
+
+export function useSkipVersionCallback() {
+  const wallet = useWallet()
+  const dispatch = useAppDispatch()
+  return useCallback((version: string) => {
+    wallet.setSkippedVersion(version).then(v => {
+      dispatch((settingsActions as any).updateSettings({ skippedVersion: version }))
+    })
+  }, [])
+}
+
+export function useAutoLockTimeId() {
+  const state = useSettingsState()
+  return state.autoLockTimeId
+}
+
+export function getAddressTips(address: string, chanEnum: ChainType) {
+  let ret = {
+    homeTip: '',
+    sendTip: '',
+  }
+  try {
+    const chain = CHAINS_MAP[chanEnum]!
+    const addressType = getAddressType(address, chain.networkType)
+    if (chain.isFractal && addressType === AddressType.P2PKH) {
+      ret = {
+        homeTip: t('legacy_address_warning_3'),
+        sendTip: t('legacy_address_warning_4'),
+      }
+    }
+  } catch (e) {
+    console.log(e)
+  }
+
+  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) {
+    if (version === CAT_VERSION.V1) {
+      return 'https://tracker-fractal-mainnet.catprotocol.org'
+    } else {
+      return 'https://tracker2-fractal-mainnet.catprotocol.org'
+    }
+  } else if (chainType === ChainType.FRACTAL_BITCOIN_TESTNET) {
+    return 'https://tracker-fractal-testnet.catprotocol.org'
+  } else {
+    return ''
+  }
+}
+
+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]
+}
+
+export function useIsMainnetChain() {
+  const chainType = useChainType()
+  return chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET
+}
+
+export function useDeveloperMode() {
+  const settings = useSettingsState()
+  return settings.developerMode
+}
+
+export function useSetDeveloperModeCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(
+    async (developerMode: boolean) => {
+      await wallet.setDeveloperMode(developerMode)
+      dispatch(
+        (settingsActions as any).updateSettings({
+          developerMode,
+        })
+      )
+    },
+    [dispatch, wallet]
+  )
+}

package/src/hooks/transactions.ts

@@ -1,17 +1,23 @@
 import { useCallback, useMemo } from 'react'
 
-import { RawTxInfo, ToAddressInfo } from '@/shared/types'
-import { useTools } from '@/ui/components/ActionComponent'
-import { useI18n } from '@/ui/hooks/useI18n'
-import { useBTCUnit } from '@/ui/state/settings/hooks'
-import { satoshisToBTC, sleep, useWallet } from '@/ui/utils'
-import { UnspentOutput } from '@unisat/tx-helpers/types'
+import { RawTxInfo, ToAddressInfo, UnspentOutput } from '@unisat/wallet-shared'
+
+import { useI18n } from './i18n'
+import { useBTCUnit } from '../hooks/settings'
 
 import { AppState } from '..'
-import { useAccountAddress, useCurrentAccount } from '../accounts/hooks'
-import { accountActions } from '../accounts/reducer'
-import { useAppDispatch, useAppSelector } from '../hooks'
-import { transactionsActions } from './reducer'
+import { useAccountAddress, useCurrentAccount } from '../hooks/accounts'
+import { accountActions } from '../reducers/accounts'
+import { useAppDispatch, useAppSelector } from './base'
+import { transactionsActions } from '../reducers/transactions'
+import { numUtils, timeUtils } from '@unisat/base-utils'
+import { useWallet } from '../context/WalletContext'
+
+function useTools() {
+  return {
+    showLoading: (show: boolean) => {},
+  }
+}
 
 export function useTransactionsState(): AppState['transactions'] {
   return useAppSelector(state => state.transactions)
@@ -62,7 +68,7 @@ export function usePrepareSendBTCCallback() {
 
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
-        feeRate = summary.list[1].feeRate
+        feeRate = summary.list[1]!.feeRate
       }
       let res: {
         psbtHex: string
@@ -84,13 +90,13 @@ export function usePrepareSendBTCCallback() {
           btcUtxos: _utxos,
           enableRBF,
           feeRate,
-          memo,
-          memos,
+          memo: memo!,
+          memos: memos!,
         })
       }
 
       dispatch(
-        transactionsActions.updateBitcoinTx({
+        (transactionsActions as any).updateBitcoinTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,
@@ -137,7 +143,7 @@ export function usePrepareSendBypassHeadOffsetsCallback() {
       )
 
       dispatch(
-        transactionsActions.updateBitcoinTx({
+        (transactionsActions as any).updateBitcoinTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,
@@ -170,15 +176,15 @@ export function usePushBitcoinTxCallback() {
       try {
         tools.showLoading(true)
         const txid = await wallet.pushTx(rawtx)
-        await sleep(3) // Wait for transaction synchronization
+        await timeUtils.sleep(3) // Wait for transaction synchronization
         tools.showLoading(false)
-        dispatch(transactionsActions.updateBitcoinTx({ txid }))
-        dispatch(accountActions.expireBalance())
+        dispatch((transactionsActions as any).updateBitcoinTx({ txid }))
+        dispatch((accountActions as any).expireBalance())
         setTimeout(() => {
-          dispatch(accountActions.expireBalance())
+          dispatch((accountActions as any).expireBalance())
         }, 2000)
         setTimeout(() => {
-          dispatch(accountActions.expireBalance())
+          dispatch((accountActions as any).expireBalance())
         }, 5000)
 
         ret.success = true
@@ -222,7 +228,7 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
-        feeRate = summary.list[1].feeRate
+        feeRate = summary.list[1]!.feeRate
       }
 
       let btcUtxos = utxos
@@ -234,12 +240,12 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
         to: toAddressInfo.address,
         inscriptionId,
         feeRate,
-        outputValue,
+        outputValue: outputValue!,
         enableRBF,
         btcUtxos,
       })
       dispatch(
-        transactionsActions.updateOrdinalsTx({
+        (transactionsActions as any).updateOrdinalsTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,
@@ -281,7 +287,7 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
-        feeRate = summary.list[1].feeRate
+        feeRate = summary.list[1]!.feeRate
       }
 
       let btcUtxos = utxos
@@ -296,7 +302,7 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
         btcUtxos,
       })
       dispatch(
-        transactionsActions.updateOrdinalsTx({
+        (transactionsActions as any).updateOrdinalsTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,
@@ -347,7 +353,7 @@ export function useCreateSplitTxCallback() {
         btcUtxos,
       })
       dispatch(
-        transactionsActions.updateOrdinalsTx({
+        (transactionsActions as any).updateOrdinalsTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,
@@ -384,16 +390,16 @@ export function usePushOrdinalsTxCallback() {
       try {
         tools.showLoading(true)
         const txid = await wallet.pushTx(rawtx)
-        await sleep(3) // Wait for transaction synchronization
+        await timeUtils.sleep(3) // Wait for transaction synchronization
         tools.showLoading(false)
-        dispatch(transactionsActions.updateOrdinalsTx({ txid }))
+        dispatch((transactionsActions as any).updateOrdinalsTx({ txid }))
 
-        dispatch(accountActions.expireBalance())
+        dispatch((accountActions as any).expireBalance())
         setTimeout(() => {
-          dispatch(accountActions.expireBalance())
+          dispatch((accountActions as any).expireBalance())
         }, 2000)
         setTimeout(() => {
-          dispatch(accountActions.expireBalance())
+          dispatch((accountActions as any).expireBalance())
         }, 5000)
 
         ret.success = true
@@ -421,7 +427,7 @@ export function useFetchUtxosCallback() {
   const account = useCurrentAccount()
   return useCallback(async () => {
     const data = await wallet.getBTCUtxos()
-    dispatch(transactionsActions.setUtxos(data))
+    dispatch((transactionsActions as any).setUtxos(data))
     return data
   }, [wallet, account])
 }
@@ -435,7 +441,7 @@ export function useSetSpendUnavailableUtxosCallback() {
   const dispatch = useAppDispatch()
   return useCallback(
     (utxos: UnspentOutput[]) => {
-      dispatch(transactionsActions.setSpendUnavailableUtxos(utxos))
+      dispatch((transactionsActions as any).setSpendUnavailableUtxos(utxos))
     },
     [dispatch]
   )
@@ -447,7 +453,7 @@ export function useSafeBalance() {
     const satoshis = utxos
       .filter(v => v.inscriptions.length === 0)
       .reduce((pre, cur) => pre + cur.satoshis, 0)
-    return satoshisToBTC(satoshis)
+    return numUtils.satoshisToAmount(satoshis)
   }, [utxos])
 }
 
@@ -463,7 +469,7 @@ export function useFetchAssetUtxosRunesCallback() {
   return useCallback(
     async (rune: string) => {
       const data = await wallet.getAssetUtxosRunes(rune)
-      dispatch(transactionsActions.setAssetUtxosRunes(data))
+      dispatch((transactionsActions as any).setAssetUtxosRunes(data))
       return data
     },
     [wallet, account]
@@ -497,7 +503,7 @@ export function usePrepareSendRunesCallback() {
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
-        feeRate = summary.list[1].feeRate
+        feeRate = summary.list[1]!.feeRate
       }
 
       let btcUtxos = utxos
@@ -514,7 +520,7 @@ export function usePrepareSendRunesCallback() {
         to: toAddressInfo.address,
         runeid,
         runeAmount,
-        outputValue,
+        outputValue: outputValue!,
         feeRate,
         enableRBF,
         btcUtxos,
@@ -522,7 +528,7 @@ export function usePrepareSendRunesCallback() {
       })
 
       dispatch(
-        transactionsActions.updateRunesTx({
+        (transactionsActions as any).updateRunesTx({
           rawtx: res.rawtx,
           psbtHex: res.psbtHex,
           fromAddress,

package/src/hooks/ui.ts

@@ -1,7 +1,135 @@
-import { useWalletSelector } from './index';
+import { useMemo } from 'react'
 
-export const useUIState = () => {
-  return useWalletSelector((state) => state.ui);
-};
+import { ChainType } from '@unisat/wallet-types'
+import { Inscription } from '@unisat/wallet-shared'
+import { getAddressType } from '../utils/bitcoin-utils'
+import { AddressType } from '@unisat/wallet-types'
 
-// Additional UI hooks will be migrated here
+import { AppState } from '..'
+import { useCurrentAccount, useCurrentAddress } from '../hooks/accounts'
+import { useAppDispatch, useAppSelector } from '../hooks/base'
+import { useChainType, useNetworkType } from '../hooks/settings'
+import { AssetTabKey, uiActions } from '../reducers/ui'
+import { TypeChain } from '@unisat/wallet-shared'
+export function useUIState(): AppState['ui'] {
+  return useAppSelector(state => state.ui)
+}
+
+export function useAssetTabKey() {
+  const uiState = useUIState()
+  return uiState.assetTabKey
+}
+
+export function useOrdinalsAssetTabKey() {
+  const uiState = useUIState()
+  return uiState.ordinalsAssetTabKey
+}
+
+export function useCATAssetTabKey() {
+  const uiState = useUIState()
+  return uiState.catAssetTabKey
+}
+
+export function useAlkanesAssetTabKey() {
+  const uiState = useUIState()
+  return uiState.alkanesAssetTabKey
+}
+
+export function useUiTxCreateScreen() {
+  const uiState = useUIState()
+  return uiState.uiTxCreateScreen
+}
+
+export function useUpdateUiTxCreateScreen() {
+  const dispatch = useAppDispatch()
+  return ({
+    toInfo,
+    inputAmount,
+    enableRBF,
+    feeRate,
+  }: {
+    toInfo?: { address: string; domain: string; inscription?: Inscription }
+    inputAmount?: string
+    enableRBF?: boolean
+    feeRate?: number
+  }) => {
+    dispatch((uiActions as any).updateTxCreateScreen({ toInfo, inputAmount, enableRBF, feeRate }))
+  }
+}
+
+export function useResetUiTxCreateScreen() {
+  const dispatch = useAppDispatch()
+  return () => {
+    dispatch((uiActions as any).resetTxCreateScreen())
+  }
+}
+
+export function useSupportedAssets() {
+  const chainType = useChainType()
+  const currentAddress = useCurrentAddress()
+  const networkType = useNetworkType()
+  const currentAccount = useCurrentAccount()
+
+  const assetTabKeys: AssetTabKey[] = []
+  const assets = {
+    ordinals: false,
+    runes: false,
+    CAT20: false,
+    alkanes: false,
+  }
+
+  assets.ordinals = true
+  assetTabKeys.push(AssetTabKey.ORDINALS)
+
+  assets.runes = true
+  assetTabKeys.push(AssetTabKey.RUNES)
+
+  if (
+    chainType === ChainType.FRACTAL_BITCOIN_MAINNET ||
+    chainType === ChainType.FRACTAL_BITCOIN_TESTNET
+  ) {
+    const addressType = getAddressType(currentAddress, networkType)
+    if (addressType == AddressType.P2TR || addressType == AddressType.P2WPKH) {
+      assets.CAT20 = true
+      assetTabKeys.push(AssetTabKey.CAT)
+    }
+  }
+
+  if (chainType === ChainType.BITCOIN_SIGNET || chainType === ChainType.BITCOIN_MAINNET) {
+    assets.alkanes = true
+    assetTabKeys.push(AssetTabKey.ALKANES)
+  }
+
+  return {
+    tabKeys: assetTabKeys,
+    assets,
+    key: assetTabKeys.join(','),
+  }
+}
+
+export const useIsInExpandView = () => {
+  // @ts-ignore
+  if (typeof window === 'undefined') {
+    return false
+  }
+  return useMemo(() => {
+    // @ts-ignore
+    if (window.innerWidth > 156 * 3) {
+      return true
+    } else {
+      return false
+    }
+    // @ts-ignore
+  }, [window.innerWidth])
+}
+
+export const useUtxoTools = (chain: TypeChain) => {
+  const openUtxoTools = () => {
+    // @ts-ignore
+    window.open(`${chain.unisatUrl}/utxo?tab=all`)
+  }
+
+  return {
+    openUtxoTools,
+  }
+}