@unisat/wallet-state 1.0.4 → 1.1.0

package/src/hooks/transactions.ts

@@ -1,23 +1,14 @@
 import { useCallback, useMemo } from 'react'
 
-import { RawTxInfo, ToAddressInfo, UnspentOutput } from '@unisat/wallet-shared'
+import { ToAddressInfo, ToSignData, UnspentOutput } from '@unisat/wallet-shared'
 
-import { useI18n } from './i18n'
-import { useBTCUnit } from '../hooks/settings'
-
-import { AppState } from '..'
+import { numUtils, timeUtils } from '@unisat/base-utils'
+import { AppState, useI18n, useTools } from '..'
+import { useWallet } from '../context/WalletContext'
 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) => {},
-  }
-}
+import { useAppDispatch, useAppSelector } from './base'
 
 export function useTransactionsState(): AppState['transactions'] {
   return useAppSelector(state => state.transactions)
@@ -34,15 +25,13 @@ export function usePrepareSendBTCCallback() {
   const fromAddress = useAccountAddress()
   const utxos = useUtxos()
   const fetchUtxos = useFetchUtxosCallback()
-  const account = useCurrentAccount()
-  const btcUnit = useBTCUnit()
+
   const { t } = useI18n()
   return useCallback(
     async ({
       toAddressInfo,
       toAmount,
       feeRate,
-      enableRBF,
       memo,
       memos,
       disableAutoAdjust,
@@ -50,7 +39,6 @@ export function usePrepareSendBTCCallback() {
       toAddressInfo: ToAddressInfo
       toAmount: number
       feeRate?: number
-      enableRBF: boolean
       memo?: string
       memos?: string[]
       disableAutoAdjust?: boolean
@@ -70,47 +58,26 @@ export function usePrepareSendBTCCallback() {
         const summary = await wallet.getFeeSummary()
         feeRate = summary.list[1]!.feeRate
       }
-      let res: {
-        psbtHex: string
-        rawtx: string
-        fee: number
-      }
+      let res: ToSignData
 
       if (safeBalance === toAmount && !disableAutoAdjust) {
-        res = await wallet.sendAllBTC({
+        res = await wallet.createSendAllBTCPsbt({
           to: toAddressInfo.address,
           btcUtxos: _utxos,
-          enableRBF,
           feeRate,
         })
       } else {
-        res = await wallet.sendBTC({
+        res = await wallet.createSendBTCPsbt({
           to: toAddressInfo.address,
           amount: toAmount,
           btcUtxos: _utxos,
-          enableRBF,
           feeRate,
           memo: memo!,
           memos: memos!,
         })
       }
 
-      dispatch(
-        (transactionsActions as any).updateBitcoinTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          feeRate,
-          enableRBF,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo,
-        fee: res.fee,
-      }
-      return rawTxInfo
+      return res
     },
     [dispatch, wallet, fromAddress, utxos, fetchUtxos]
   )
@@ -119,9 +86,6 @@ export function usePrepareSendBTCCallback() {
 export function usePrepareSendBypassHeadOffsetsCallback() {
   const dispatch = useAppDispatch()
   const wallet = useWallet()
-  const fromAddress = useAccountAddress()
-  const account = useCurrentAccount()
-  const btcUnit = useBTCUnit()
   return useCallback(
     async ({
       toAddressInfo,
@@ -132,7 +96,7 @@ export function usePrepareSendBypassHeadOffsetsCallback() {
       toAmount: number
       feeRate: number
     }) => {
-      const res = await wallet.sendCoinBypassHeadOffsets(
+      const res = await wallet.createSendBTCOffsetPsbt(
         [
           {
             address: toAddressInfo.address,
@@ -141,24 +105,9 @@ export function usePrepareSendBypassHeadOffsetsCallback() {
         ],
         feeRate
       )
-
-      dispatch(
-        (transactionsActions as any).updateBitcoinTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          feeRate,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo,
-        fee: res.fee,
-      }
-      return rawTxInfo
+      return res
     },
-    [dispatch, wallet, fromAddress]
+    [dispatch, wallet]
   )
 }
 
@@ -196,7 +145,7 @@ export function usePushBitcoinTxCallback() {
 
       return ret
     },
-    [dispatch, wallet]
+    [dispatch, wallet, tools]
   )
 }
 
@@ -211,20 +160,17 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
   const fromAddress = useAccountAddress()
   const utxos = useUtxos()
   const fetchUtxos = useFetchUtxosCallback()
-  const account = useCurrentAccount()
   return useCallback(
     async ({
       toAddressInfo,
       inscriptionId,
       feeRate,
       outputValue,
-      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       inscriptionId: string
       feeRate?: number
       outputValue?: number
-      enableRBF: boolean
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
@@ -236,31 +182,15 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
         btcUtxos = await fetchUtxos()
       }
 
-      const res = await wallet.sendOrdinalsInscription({
+      const toSignData = await wallet.createSendInscriptionPsbt({
         to: toAddressInfo.address,
         inscriptionId,
         feeRate,
         outputValue: outputValue!,
-        enableRBF,
         btcUtxos,
       })
-      dispatch(
-        (transactionsActions as any).updateOrdinalsTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          // inscription,
-          feeRate,
-          outputValue,
-          enableRBF,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo,
-      }
-      return rawTxInfo
+
+      return toSignData
     },
     [dispatch, wallet, fromAddress, utxos]
   )
@@ -272,18 +202,15 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
   const fromAddress = useAccountAddress()
   const fetchUtxos = useFetchUtxosCallback()
   const utxos = useUtxos()
-  const account = useCurrentAccount()
   return useCallback(
     async ({
       toAddressInfo,
       inscriptionIds,
       feeRate,
-      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       inscriptionIds: string[]
       feeRate?: number
-      enableRBF: boolean
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
@@ -294,28 +221,14 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
       if (btcUtxos.length === 0) {
         btcUtxos = await fetchUtxos()
       }
-      const res = await wallet.sendOrdinalsInscriptions({
+      const res = await wallet.createSendMultipleInscriptionsPsbt({
         to: toAddressInfo.address,
         inscriptionIds,
         feeRate,
-        enableRBF,
         btcUtxos,
       })
-      dispatch(
-        (transactionsActions as any).updateOrdinalsTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          feeRate,
-          enableRBF,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo,
-      }
-      return rawTxInfo
+
+      return res
     },
     [dispatch, wallet, fromAddress, utxos]
   )
@@ -333,44 +246,24 @@ export function useCreateSplitTxCallback() {
       inscriptionId,
       feeRate,
       outputValue,
-      enableRBF,
     }: {
       inscriptionId: string
       feeRate: number
       outputValue: number
-      enableRBF: boolean
     }) => {
       let btcUtxos = utxos
       if (btcUtxos.length === 0) {
         btcUtxos = await fetchUtxos()
       }
 
-      const res = await wallet.splitOrdinalsInscription({
+      const res = await wallet.createSplitInscriptionPsbt({
         inscriptionId,
         feeRate,
         outputValue,
-        enableRBF,
         btcUtxos,
       })
-      dispatch(
-        (transactionsActions as any).updateOrdinalsTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          // inscription,
-          enableRBF,
-          feeRate,
-          outputValue,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo: {
-          address: fromAddress,
-        },
-      }
-      return { rawTxInfo, splitedCount: res.splitedCount }
+
+      return res
     },
     [dispatch, wallet, fromAddress, utxos]
   )
@@ -492,14 +385,12 @@ export function usePrepareSendRunesCallback() {
       runeAmount,
       outputValue,
       feeRate,
-      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       runeid: string
       runeAmount: string
       outputValue?: number
       feeRate: number
-      enableRBF: boolean
     }) => {
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
@@ -516,35 +407,17 @@ export function usePrepareSendRunesCallback() {
         assetUtxos = await fetchAssetUtxosRunes(runeid)
       }
 
-      const res = await wallet.sendRunes({
+      const toSignData = await wallet.createSendRunesPsbt({
         to: toAddressInfo.address,
         runeid,
         runeAmount,
         outputValue: outputValue!,
         feeRate,
-        enableRBF,
         btcUtxos,
         assetUtxos,
       })
 
-      dispatch(
-        (transactionsActions as any).updateRunesTx({
-          rawtx: res.rawtx,
-          psbtHex: res.psbtHex,
-          fromAddress,
-          feeRate,
-          enableRBF,
-          runeid,
-          runeAmount,
-          outputValue,
-        })
-      )
-      const rawTxInfo: RawTxInfo = {
-        psbtHex: res.psbtHex,
-        rawtx: res.rawtx,
-        toAddressInfo,
-      }
-      return rawTxInfo
+      return toSignData
     },
     [dispatch, wallet, fromAddress, utxos, assetUtxosRunes, fetchAssetUtxosRunes, account]
   )
@@ -564,14 +437,14 @@ export function usePrepareSendAlkanesCallback() {
       alkaneid: string,
       amount: string,
       feeRate: number,
-      enableRBF = false
+      type: 'ft' | 'nft'
     ) => {
-      return await wallet.sendAlkanes({
+      return await wallet.createSendAlkanesPsbt({
         to: toAddressInfo.address,
         alkaneid,
         amount,
         feeRate,
-        enableRBF,
+        type,
       })
     },
     [wallet, account]

package/src/hooks/ui.ts

@@ -1,17 +1,14 @@
-import { useMemo } from 'react'
+import { useCallback, useMemo } from 'react'
 
-import { ChainType } from '@unisat/wallet-types'
-import { Inscription } from '@unisat/wallet-shared'
+import { CHAINS_MAP, Inscription } from '@unisat/wallet-shared'
+import { AddressType, ChainType } from '@unisat/wallet-types'
 import { getAddressType } from '../utils/bitcoin-utils'
-import { AddressType } from '@unisat/wallet-types'
 
 import { AppState, AssetTabKey } from '..'
-import { useCurrentAccount, useCurrentAddress } from '../hooks/accounts'
+import { useCurrentAddress } from '../hooks/accounts'
 import { useAppDispatch, useAppSelector } from '../hooks/base'
-import { useChainType, useNetworkType } from '../hooks/settings'
+import { useChainType, useIconBaseUrl, useUnisatWebsite } from '../hooks/settings'
 import { uiActions } from '../reducers/ui'
-import { TypeChain } from '@unisat/wallet-shared'
-import { useLocation } from 'react-router-dom'
 export function useUIState(): AppState['ui'] {
   return useAppSelector(state => state.ui)
 }
@@ -46,15 +43,110 @@ export function useUpdateUiTxCreateScreen() {
   return ({
     toInfo,
     inputAmount,
-    enableRBF,
-    feeRate,
   }: {
     toInfo?: { address: string; domain: string; inscription?: Inscription }
     inputAmount?: string
-    enableRBF?: boolean
+  }) => {
+    dispatch(
+      (uiActions as any).updateTxCreateScreen({
+        toInfo,
+        inputAmount,
+      })
+    )
+  }
+}
+
+export function useFeeRateBar() {
+  const uiState = useUIState()
+  return uiState.feeRateBar
+}
+
+export function useUpdateFeeRateBar() {
+  const dispatch = useAppDispatch()
+  return ({
+    feeRate,
+    feeRateInputVal,
+    enableLowFeeRate,
+    feeOptionIndex,
+    showCustomInput,
+  }: {
     feeRate?: number
+    feeRateInputVal?: string
+    enableLowFeeRate?: boolean
+    feeOptionIndex?: number
+    showCustomInput?: boolean
   }) => {
-    dispatch((uiActions as any).updateTxCreateScreen({ toInfo, inputAmount, enableRBF, feeRate }))
+    dispatch(
+      (uiActions as any).updateFeeRateBar({
+        feeRate,
+        feeRateInputVal,
+        enableLowFeeRate,
+        feeOptionIndex,
+        showCustomInput,
+      })
+    )
+  }
+}
+
+export function useResetFeeRateBar() {
+  const dispatch = useAppDispatch()
+  return () => {
+    dispatch((uiActions as any).resetFeeRateBar())
+  }
+}
+
+export function useAddressInput() {
+  const uiState = useUIState()
+  return uiState.addressInput
+}
+
+export function useUpdateAddressInput() {
+  const dispatch = useAppDispatch()
+  return ({ address, domain }: { address?: string; domain?: string }) => {
+    dispatch(
+      (uiActions as any).updateAddressInput({
+        address,
+        domain,
+      })
+    )
+  }
+}
+
+export function useResetAddressInput() {
+  const dispatch = useAppDispatch()
+  return () => {
+    dispatch((uiActions as any).resetAddressInput())
+  }
+}
+
+export function useAmountInput() {
+  const uiState = useUIState()
+  return uiState.amountInput
+}
+
+export function useUpdateAmountInput() {
+  const dispatch = useAppDispatch()
+  return ({ amount }: { amount?: string }) => {
+    dispatch(
+      (uiActions as any).updateAmountInput({
+        amount,
+      })
+    )
+  }
+}
+
+export function useResetAmountInput() {
+  const dispatch = useAppDispatch()
+  return () => {
+    dispatch((uiActions as any).resetAmountInput())
+  }
+}
+
+export function useResetTxState() {
+  const dispatch = useAppDispatch()
+  return () => {
+    dispatch((uiActions as any).resetTxCreateScreen())
+    dispatch((uiActions as any).resetFeeRateBar())
   }
 }
 
@@ -65,18 +157,32 @@ export function useResetUiTxCreateScreen() {
   }
 }
 
-export function useSupportedAssets() {
-  const chainType = useChainType()
-  const currentAddress = useCurrentAddress()
-  const networkType = useNetworkType()
-  const currentAccount = useCurrentAccount()
+export const useThrottle = (callback, delay, lastCallRef) => {
+  return useCallback(
+    (...args) => {
+      const now = Date.now()
+      if (now - lastCallRef.current > delay) {
+        lastCallRef.current = now
+        callback(...args)
+      }
+    },
+    [callback, delay, lastCallRef]
+  )
+}
 
+export function getSupportedAssets(chainType: ChainType, address: string) {
   const assetTabKeys: AssetTabKey[] = []
+
+  const chain = CHAINS_MAP[chainType]
+  const networkType = chain.networkType
+  const addressType = getAddressType(address, networkType)
+
   const assets = {
     ordinals: false,
     runes: false,
     CAT20: false,
     alkanes: false,
+    brc20Prog: false,
   }
 
   assets.ordinals = true
@@ -86,27 +192,35 @@ export function useSupportedAssets() {
   assetTabKeys.push(AssetTabKey.RUNES)
 
   if (
-    chainType === ChainType.FRACTAL_BITCOIN_MAINNET ||
-    chainType === ChainType.FRACTAL_BITCOIN_TESTNET
+    (chainType === ChainType.FRACTAL_BITCOIN_MAINNET ||
+      chainType === ChainType.FRACTAL_BITCOIN_TESTNET) &&
+    (addressType == AddressType.P2TR || addressType == AddressType.P2WPKH)
   ) {
-    const addressType = getAddressType(currentAddress, networkType)
-    if (addressType == AddressType.P2TR || addressType == AddressType.P2WPKH) {
-      assets.CAT20 = true
-      assetTabKeys.push(AssetTabKey.CAT)
-    }
+    assets.CAT20 = true
+    assetTabKeys.push(AssetTabKey.CAT)
   }
 
-  if (chainType === ChainType.BITCOIN_SIGNET || chainType === ChainType.BITCOIN_MAINNET) {
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.BITCOIN_SIGNET) {
     assets.alkanes = true
     assetTabKeys.push(AssetTabKey.ALKANES)
   }
 
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.BITCOIN_SIGNET) {
+    assets.brc20Prog = true
+  }
+
   return {
-    tabKeys: assetTabKeys,
     assets,
-    key: assetTabKeys.join(','),
+    tabKeys: assetTabKeys,
+    key: chainType + address + assetTabKeys.join(','),
   }
 }
+export function useSupportedAssets() {
+  const chainType = useChainType()
+  const currentAddress = useCurrentAddress()
+  const supportedAssets = getSupportedAssets(chainType, currentAddress)
+  return supportedAssets
+}
 
 export const useIsInExpandView = () => {
   // @ts-ignore
@@ -124,18 +238,100 @@ export const useIsInExpandView = () => {
   }, [window.innerWidth])
 }
 
-export const useUtxoTools = (chain: TypeChain) => {
-  const openUtxoTools = () => {
-    // @ts-ignore
-    window.open(`${chain.unisatUrl}/utxo?tab=all`)
+export function useWalletTopTabScreenState() {
+  const uiState = useUIState()
+  return uiState.walletTopTabScreen
+}
+
+export function useBRC20IconInfo(ticker: string) {
+  const baseUrl = useIconBaseUrl()
+  const iconUrl = `${baseUrl}/brc20/${ticker}`
+  const iconShortName = ticker.substring(0, 2)
+  const chainType = useChainType()
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
+    return { iconUrl, iconShortName }
   }
 
-  return {
-    openUtxoTools,
+  return { iconUrl: '', iconShortName }
+}
+
+export function useRunesIconInfo(spacedRune: string) {
+  const baseUrl = useIconBaseUrl()
+  const iconUrl = `${baseUrl}/runes/${spacedRune}`
+  const iconShortName = spacedRune.substring(0, 2)
+  const chainType = useChainType()
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
+    return { iconUrl, iconShortName }
   }
+
+  return { iconUrl: '', iconShortName }
 }
 
-export function useLocationState<T>() {
-  const { state } = useLocation()
-  return state as T
+export function useAlkanesIconInfo(name: string, alkaneid: string) {
+  const baseUrl = useIconBaseUrl()
+  const iconUrl = `${baseUrl}/alkanes/${name}/${alkaneid}`
+  const iconShortName = name.substring(0, 2)
+  const chainType = useChainType()
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
+    return { iconUrl, iconShortName }
+  }
+
+  return { iconUrl: '', iconShortName }
+}
+
+export function useCAT20IconInfo(name: string, tokenId: string) {
+  const baseUrl = useIconBaseUrl()
+  const iconUrl = `${baseUrl}/cat20/${name}/${tokenId}`
+  const iconShortName = name.substring(0, 2)
+  const chainType = useChainType()
+  if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
+    return { iconUrl, iconShortName }
+  }
+
+  return { iconUrl: '', iconShortName }
+}
+
+export function useBRC20MarketPlaceWebsite(ticker: string) {
+  const chainType = useChainType()
+  const unisatWebsite = useUnisatWebsite()
+  if (chainType === ChainType.BITCOIN_MAINNET) {
+    if (ticker.length == 6) {
+      return `${unisatWebsite}/market/brc20_prog?tick=${ticker}`
+    }
+  }
+  return `${unisatWebsite}/market/brc20?tick=${ticker}`
+}
+
+export function useRunesMarketUrl(ticker: string) {
+  const unisatWebsite = useUnisatWebsite()
+  return `${unisatWebsite}/runes/market?tick=${ticker}`
+}
+
+export function useAlkanesMarketPlaceWebsite(alkaneid: string) {
+  const unisatWebsite = useUnisatWebsite()
+  return `${unisatWebsite}/alkanes/market?tick=${alkaneid}`
+}
+
+export function useCAT20MarketPlaceWebsite(tokenId: string) {
+  const unisatWebsite = useUnisatWebsite()
+  return `${unisatWebsite}/dex/cat20/${tokenId}`
+}
+
+export function useRunesInscribeUrl(rune: string) {
+  const unisatWebsite = useUnisatWebsite()
+  const newUrl = `${unisatWebsite}/runes/inscribe?only=1&tab=mint&rune=${rune}`
+  return newUrl
+}
+
+export function useBalanceCardDetailExpanded() {
+  const uiState = useUIState()
+  return uiState.balanceDetailExpanded
+}
+
+export function useToggleBalanceCardDetailExpanded() {
+  const { balanceDetailExpanded } = useUIState()
+  const dispatch = useAppDispatch()
+  return useCallback(() => {
+    dispatch((uiActions as any).setBalanceDetailExpanded(!balanceDetailExpanded))
+  }, [dispatch, balanceDetailExpanded])
 }