@unisat/wallet-state 1.0.4 → 1.1.0

package/src/reducers/ui.ts

@@ -1,5 +1,5 @@
-import { Inscription } from '@unisat/wallet-shared'
 import { createSlice, Slice } from '@reduxjs/toolkit'
+import { Inscription } from '@unisat/wallet-shared'
 
 import { updateVersion } from '../actions/global'
 import {
@@ -10,6 +10,14 @@ import {
   OrdinalsAssetTabKey,
 } from '../types'
 
+export enum WallettopTabScreenTabKey {
+  Ordinals,
+  Atomicals,
+  Runes,
+  CAT20,
+  Alkanes,
+}
+
 export interface UIState {
   assetTabKey: AssetTabKey
   ordinalsAssetTabKey: OrdinalsAssetTabKey
@@ -22,8 +30,21 @@ export interface UIState {
       inscription?: Inscription
     }
     inputAmount: string
-    enableRBF: boolean
+  }
+  addressInput: {
+    address: string
+    domain: string
+    inscription?: Inscription
+  }
+  amountInput: {
+    amount: string
+  }
+  feeRateBar: {
     feeRate: number
+    feeRateInputVal: string
+    enableLowFeeRate: boolean
+    feeOptionIndex: number
+    showCustomInput: boolean
   }
   babylonSendScreen: {
     inputAmount: string
@@ -31,6 +52,11 @@ export interface UIState {
   }
   navigationSource: NavigationSource
   isBalanceHidden: boolean
+  balanceDetailExpanded: boolean
+
+  walletTopTabScreen: {
+    toptabKey: WallettopTabScreenTabKey
+  }
 }
 
 export const initialState: UIState = {
@@ -44,8 +70,20 @@ export const initialState: UIState = {
       domain: '',
     },
     inputAmount: '',
-    enableRBF: false,
+  },
+  addressInput: {
+    address: '',
+    domain: '',
+  },
+  amountInput: {
+    amount: '',
+  },
+  feeRateBar: {
     feeRate: 1,
+    feeRateInputVal: '',
+    enableLowFeeRate: false,
+    feeOptionIndex: 1, // Default to AVG
+    showCustomInput: false,
   },
   babylonSendScreen: {
     inputAmount: '',
@@ -53,6 +91,11 @@ export const initialState: UIState = {
   },
   navigationSource: NavigationSource.NORMAL,
   isBalanceHidden: false,
+  balanceDetailExpanded: true,
+
+  walletTopTabScreen: {
+    toptabKey: WallettopTabScreenTabKey.Ordinals,
+  },
 }
 
 const slice: Slice<UIState> = createSlice({
@@ -99,8 +142,6 @@ const slice: Slice<UIState> = createSlice({
             inscription?: Inscription
           }
           inputAmount?: string
-          enableRBF?: boolean
-          feeRate?: number
         }
       }
     ) {
@@ -110,13 +151,82 @@ const slice: Slice<UIState> = createSlice({
       if (action.payload.inputAmount !== undefined) {
         state.uiTxCreateScreen.inputAmount = action.payload.inputAmount
       }
-      if (action.payload.enableRBF !== undefined) {
-        state.uiTxCreateScreen.enableRBF = action.payload.enableRBF
+
+      state.uiTxCreateScreen = { ...state.uiTxCreateScreen }
+    },
+    updateFeeRateBar(
+      state,
+      action: {
+        payload: {
+          feeRate?: number
+          feeRateInputVal?: string
+          enableLowFeeRate?: boolean
+          feeOptionIndex?: number
+          showCustomInput?: boolean
+        }
       }
+    ) {
       if (action.payload.feeRate !== undefined) {
-        state.uiTxCreateScreen.feeRate = action.payload.feeRate
+        state.feeRateBar.feeRate = action.payload.feeRate
+      }
+      if (action.payload.feeRateInputVal !== undefined) {
+        state.feeRateBar.feeRateInputVal = action.payload.feeRateInputVal
+      }
+      if (action.payload.enableLowFeeRate !== undefined) {
+        state.feeRateBar.enableLowFeeRate = action.payload.enableLowFeeRate
       }
+      if (action.payload.feeOptionIndex !== undefined) {
+        state.feeRateBar.feeOptionIndex = action.payload.feeOptionIndex
+      }
+      if (action.payload.showCustomInput !== undefined) {
+        state.feeRateBar.showCustomInput = action.payload.showCustomInput
+      }
+      state.feeRateBar = { ...state.feeRateBar }
+    },
+    resetFeeRateBar(state) {
+      state.feeRateBar = initialState.feeRateBar
     },
+
+    updateAddressInput(
+      state,
+      action: {
+        payload: {
+          address?: string
+          domain?: string
+        }
+      }
+    ) {
+      if (action.payload.address !== undefined) {
+        state.addressInput.address = action.payload.address
+      }
+      if (action.payload.domain !== undefined) {
+        state.addressInput.domain = action.payload.domain
+      }
+      state.addressInput = { ...state.addressInput }
+    },
+
+    resetAddressInput(state) {
+      state.addressInput = initialState.addressInput
+    },
+
+    updateAmountInput(
+      state,
+      action: {
+        payload: {
+          amount?: string
+        }
+      }
+    ) {
+      if (action.payload.amount !== undefined) {
+        state.amountInput.amount = action.payload.amount
+      }
+      state.amountInput = { ...state.amountInput }
+    },
+
+    resetAmountInput(state) {
+      state.amountInput = initialState.amountInput
+    },
+
     resetTxCreateScreen(state) {
       state.uiTxCreateScreen = initialState.uiTxCreateScreen
     },
@@ -145,6 +255,9 @@ const slice: Slice<UIState> = createSlice({
     setBalanceHidden(state, action: { payload: boolean }) {
       state.isBalanceHidden = action.payload
     },
+    setBalanceDetailExpanded(state, action: { payload: boolean }) {
+      state.balanceDetailExpanded = action.payload
+    },
   },
   extraReducers: builder => {
     builder.addCase(updateVersion, state => {
@@ -164,12 +277,18 @@ const slice: Slice<UIState> = createSlice({
       if (!state.uiTxCreateScreen) {
         state.uiTxCreateScreen = initialState.uiTxCreateScreen
       }
+      if (!state.feeRateBar) {
+        state.feeRateBar = initialState.feeRateBar
+      }
       if (!state.babylonSendScreen) {
         state.babylonSendScreen = initialState.babylonSendScreen
       }
       if (state.isBalanceHidden === undefined) {
         state.isBalanceHidden = false
       }
+      if (state.balanceDetailExpanded === undefined) {
+        state.balanceDetailExpanded = true
+      }
     })
   },
 })

package/src/types/index.ts

@@ -1,3 +1,3 @@
 export * from './ui'
 
-export type TabOption = 'home' | 'discover' | 'settings'
+export type TabOption = 'home' | 'discover' | 'settings' | 'app'

package/src/ui-hooks/index.ts

@@ -0,0 +1,107 @@
+export { useAddressTypeScreenLogic } from './useAddressTypeScreenLogic'
+export { useAlkanesListLogic } from './useAlkanesListLogic'
+export { useAmountInputLogic } from './useAmountInputLogic'
+export { useAnnouncementCardLogic } from './useAnnouncementCardLogic'
+export {
+  BRC20SendTabKey,
+  useBRC20SendScreenLogic,
+  useBRC20SendScreenLogicStep1,
+  useBRC20SendScreenLogicStep2,
+  useBRC20SendScreenLogicStep3,
+  useTransferableListLogic,
+  type BRC20SendStepParams,
+  type ContextData,
+  type UpdateContextDataParams,
+} from './useBRC20SendScreenLogic'
+export { BRC20SingleStepKey, useBRC20SingleStepScreenLogic } from './useBRC20SingleStepScreenLogic'
+export {
+  type BRC20OutWalletBalanceItem,
+  BRC20TokenScreenTabKey,
+  useBRC20TokenHistoryLogic,
+  useBRC20TokenScreenLogic,
+} from './useBRC20TokenScreenLogic'
+export { useEditWalletNameScreenLogic } from './useEditWalletNameScreenLogic'
+export { useFeeRateBarLogic } from './useFeeRateBarLogic'
+export { useLockTimePageLogic } from './useLockTimePageLogic'
+export { useNotificationsLogic, useUnreadNotificationsCount } from './useNotificationsLogic'
+export { useSendOrdinalsInscriptionScreenLogic } from './useSendOrdinalsInscriptionScreenLogic'
+export { useTxCreateScreenLogic } from './useTxCreateScreenLogic'
+
+export {
+  useBRC20InscribeTransferLogic,
+  useBRC20InscribeTransferLogicStep1,
+  useBRC20InscribeTransferLogicStep2,
+  useBRC20InscribeTransferLogicStep3,
+  useBRC20InscribeTransferLogicStep4,
+  type BRC20InscribeTransferParams,
+} from './useBRC20InscribeTransferLogic'
+
+export { useAlkanesNFTScreenLogic } from './useAlkanesNFTScreenLogic'
+export { useAlkanesTokenScreenLogic } from './useAlkanesTokenScreenLogic'
+export { useCreateWalletLogicImportWordsStep } from './useCreateWalletLogicImportWordsStep'
+export { useOrdinalsInscriptionScreenLogic } from './useOrdinalsInscriptionScreenLogic'
+
+export { useRunesTokenScreenLogic } from './useRunesTokenScreenLogic'
+
+export { useBRC20BalanceCardLogic, type BRC20BalanceCardProps } from './useBRC20BalanceCardLogic'
+
+export { useExportMnemonicsScreenLogic } from './useExportMnemonicsScreenLogic'
+export { useExportPrivateKeyScreenLogic } from './useExportPrivateKeyScreenLogic'
+export { useSendRunesScreenLogic } from './useSendRunesScreenLogic'
+
+export { useEditContactScreenLogic } from './useEditContactScreenLogic'
+
+export { useEditAccountNameScreenLogic } from './useEditAccountNameScreenLogic'
+
+export { useAlkanesCollectionListLogic } from './useAlkanesCollectionListLogic'
+export { useBRC20ListLogic } from './useBRC20ListLogic'
+
+export { useInscriptionListLogic } from './useInscriptionListLogic'
+export { useRunesListLogic } from './useRunesListLogic'
+
+export { useCAT20ListLogic } from './useCAT20ListLogic'
+export { SendCAT20ScreenStep, useSendCAT20ScreenLogic } from './useSendCAT20ScreenLogic'
+export { SendCAT721ScreenStep, useSendCAT721ScreenLogic } from './useSendCAT721ScreenLogic'
+
+export { useAlkanesNFTListLogic } from './useAlkanesNFTListLogic'
+export { useBRC20ProgListLogic } from './useBRC20ProgListLogic'
+export { useCAT721ListLogic } from './useCAT721ListLogic'
+
+export { useCAT20TokenScreenLogic } from './useCAT20TokenScreenLogic'
+
+export { useSplitOrdinalsInscriptionScreenLogic } from './useSplitOrdinalsInscriptionScreenLogic'
+
+export { useCreatePasswordScreenLogic } from './useCreatePasswordScreenLogic'
+export {
+  SendAlkanesNFTScreenStep,
+  useSendAlkanesNFTScreenLogic,
+} from './useSendAlkanesNFTScreenLogic'
+export { SendAlkanesScreenStep, useSendAlkanesScreenLogic } from './useSendAlkanesScreenLogic'
+
+export { useRunesBalanceCardLogic, type RunesBalanceCardProps } from './useRunesBalanceCardLogic'
+
+export { useCAT20BalanceCardLogic, type CAT20BalanceCardProps } from './useCAT20BalanceCardLogic'
+
+export {
+  useAlkanesBalanceCardLogic,
+  type AlkanesBalanceCardProps,
+} from './useAlkanesBalanceCardLogic'
+
+export { useCAT721NFTScreenLogic } from './useCAT721NFTScreenLogic'
+
+export { useSignMessageLogic, type SignMessageProps } from './useSignMessageLogic'
+export { useSignPsbtLogic, type SignPsbtProps } from './useSignPsbtLogic'
+export type { PsbtLocalInfo } from '@unisat/wallet-shared'
+
+export { useTxConfirmScreenLogic } from './useTxConfirmScreenLogic'
+export { useTxFailScreenLogic } from './useTxFailScreenLogic'
+export { useTxSuccessScreenLogic } from './useTxSuccessScreenLogic'
+
+export {
+  useActionOverviewSectionLogic,
+  type ActionOverviewSectionProps,
+} from './useActionOverviewSectionLogic'
+export { useSettingsTabScreenLogic, type SettingsItemType } from './useSettingsTabScreenLogic'
+
+export { useBalanceCardLogic } from './useBalanceCardLogic'
+export { useBtcDisplayLogic } from './useBtcDisplayLogic'

package/src/ui-hooks/useActionOverviewSectionLogic.ts

@@ -0,0 +1,150 @@
+import {
+  DecodedPsbt,
+  Inscription,
+  PsbtActionDetailType,
+  PsbtActionInfo,
+  PsbtActionType,
+} from '@unisat/wallet-shared'
+import { useMemo } from 'react'
+import { useI18n } from 'src/context'
+import { useChain, useCurrentAddress } from 'src/hooks'
+
+export interface ActionOverviewSectionProps {
+  action: PsbtActionInfo
+  decodedPsbt: DecodedPsbt
+}
+
+export function useActionOverviewSectionLogic({ action, decodedPsbt }: ActionOverviewSectionProps) {
+  const { t } = useI18n()
+
+  const chain = useChain()
+
+  const currentAddress = useCurrentAddress()
+
+  const spendSatoshis = useMemo(() => {
+    const inValue = decodedPsbt.inputInfos
+      .filter(v => v.address === currentAddress)
+      .reduce((pre, cur) => cur.value + pre, 0)
+    const outValue = decodedPsbt.outputInfos
+      .filter(v => v.address === currentAddress)
+      .reduce((pre, cur) => cur.value + pre, 0)
+    const spend = inValue - outValue
+    return spend
+  }, [decodedPsbt, currentAddress])
+
+  const spendingInscriptionCount = useMemo(() => {
+    let count = 0
+    decodedPsbt.inputInfos.forEach(inputInfo => {
+      if (inputInfo.address === currentAddress) {
+        inputInfo.inscriptions.forEach(inscription => {
+          const inscriptionInfo: Inscription = decodedPsbt.inscriptions[inscription.inscriptionId]
+          if (inscriptionInfo.brc20 && inscriptionInfo.brc20.op === 'transfer') {
+            // skip brc20
+          } else {
+            count++
+          }
+        })
+      }
+    })
+    return count
+  }, [decodedPsbt, currentAddress])
+
+  const spendingBrc20Count = useMemo(() => {
+    let count = 0
+    decodedPsbt.inputInfos.forEach(inputInfo => {
+      if (inputInfo.address === currentAddress) {
+        inputInfo.inscriptions.forEach(inscription => {
+          const inscriptionInfo: Inscription = decodedPsbt.inscriptions[inscription.inscriptionId]
+          if (inscriptionInfo.brc20 && inscriptionInfo.brc20.op === 'transfer') {
+            count++
+          }
+        })
+      }
+    })
+    return count
+  }, [decodedPsbt, currentAddress])
+
+  const spendingRunesCount = useMemo(() => {
+    const runeMap: { [key: string]: string } = {}
+    decodedPsbt.inputInfos.forEach(inputInfo => {
+      if (inputInfo.address === currentAddress) {
+        inputInfo.runes.forEach(rune => {
+          runeMap[rune.runeid] = rune.runeid
+        })
+      }
+    })
+    return Object.keys(runeMap).length
+  }, [decodedPsbt, currentAddress])
+
+  const spendingAlkanesCount = useMemo(() => {
+    const alkaneMap: { [key: string]: string } = {}
+    decodedPsbt.inputInfos.forEach(inputInfo => {
+      if (inputInfo.address === currentAddress) {
+        inputInfo.alkanes.forEach(alkane => {
+          alkaneMap[alkane.alkaneid] = alkane.alkaneid
+        })
+      }
+    })
+    return Object.keys(alkaneMap).length
+  }, [decodedPsbt, currentAddress])
+
+  if (!action) {
+    action = {
+      name: '',
+      description: '',
+      type: PsbtActionType.DEFAULT,
+    }
+  }
+
+  if (action.details?.length === 0) {
+    action.details = []
+  }
+
+  if (action.type === PsbtActionType.DEFAULT) {
+    action.name = t('sign_transaction')
+    action.description = ''
+    action.details = []
+
+    if (
+      spendingInscriptionCount > 0 ||
+      spendingBrc20Count > 0 ||
+      spendingAlkanesCount > 0 ||
+      spendingRunesCount > 0
+    ) {
+      action.details.push({
+        type: PsbtActionDetailType.MULTIASSETS,
+        label: t('spending_assets'),
+        value: {
+          inscriptionCount: spendingInscriptionCount,
+          brc20Count: spendingBrc20Count,
+          runesCount: spendingRunesCount,
+          alkanesCount: spendingAlkanesCount,
+        },
+      })
+    }
+  }
+
+  const commonDetails: any[] = []
+  if (spendSatoshis > 0) {
+    commonDetails.push({
+      type: PsbtActionDetailType.SATOSHIS,
+      label: t('spending_amount'),
+      value: `${spendSatoshis}`,
+    })
+  }
+
+  if (spendSatoshis < 0) {
+    commonDetails.push({
+      type: PsbtActionDetailType.SATOSHIS,
+      label: t('receive'),
+      value: `${-spendSatoshis}`,
+    })
+  }
+
+  return {
+    decodedPsbt,
+    action,
+    commonDetails,
+    chain,
+  }
+}

package/src/ui-hooks/useAddressTypeScreenLogic.ts

@@ -0,0 +1,160 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+
+import { numUtils } from '@unisat/base-utils'
+import { ADDRESS_TYPES, KeyringType } from '@unisat/keyring-service/types'
+import { getAccountDerivationPath } from '@unisat/wallet-shared'
+import { AddressType } from '@unisat/wallet-types'
+import {
+  useAppDispatch,
+  useCurrentAccount,
+  useCurrentKeyring,
+  useI18n,
+  useNavigation,
+  useReloadAccounts,
+  useTools,
+  useWallet,
+} from '..'
+
+interface AddressTypeItem {
+  address: string
+  assets: { total_btc: string; satoshis: number; total_inscription: number }
+  name: string
+  value: AddressType
+}
+
+export function useAddressTypeScreenLogic() {
+  //   const isInTab = useExtensionIsInTab()
+  const { t } = useI18n()
+
+  const wallet = useWallet()
+  const currentKeyring = useCurrentKeyring()
+  const account = useCurrentAccount()
+
+  const nav = useNavigation()
+  const dispatch = useAppDispatch()
+  const reloadAccounts = useReloadAccounts()
+  const [addresses, setAddresses] = useState<string[]>([])
+  const [addressAssets, setAddressAssets] = useState<{
+    [key: string]: { total_btc: string; satoshis: number; total_inscription: number }
+  }>({})
+
+  const selfRef = useRef<{
+    addressAssets: {
+      [key: string]: { total_btc: string; satoshis: number; total_inscription: number }
+    }
+  }>({
+    addressAssets: {},
+  })
+  const self = selfRef.current
+
+  const tools = useTools()
+  const loadAddresses = async () => {
+    try {
+      tools.showLoading(true)
+      const _res = await wallet.getAllAddresses(currentKeyring, account.index || 0)
+      setAddresses(_res)
+      const balances = await wallet.getMultiAddressAssets(_res.join(','))
+      for (let i = 0; i < _res.length; i++) {
+        const address = _res[i]
+        const balance = balances[i]
+        const satoshis = balance.totalSatoshis
+        self.addressAssets[address] = {
+          total_btc: numUtils.satoshisToAmount(balance.totalSatoshis),
+          satoshis,
+          total_inscription: balance.inscriptionCount,
+        }
+      }
+      setAddressAssets(self.addressAssets)
+    } catch (e) {
+      console.error(e)
+    } finally {
+      tools.showLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    loadAddresses()
+  }, [])
+
+  const addressTypes = useMemo(() => {
+    // Cold wallets do not allow switching address types, only show the current type
+    if (currentKeyring.type === KeyringType.ColdWalletKeyring) {
+      return ADDRESS_TYPES.filter(v => v.value === currentKeyring.addressType)
+    }
+
+    if (currentKeyring.type === KeyringType.HdKeyring) {
+      return ADDRESS_TYPES.filter(v => {
+        if (v.displayIndex < 0) {
+          return false
+        }
+        // MagicEden only supports P2WPKH and P2TR
+        if (currentKeyring.accountIndexDerivation) {
+          return v.value === AddressType.P2WPKH || v.value === AddressType.P2TR
+        }
+        const address = addresses[v.value]
+        const balance = addressAssets[address]
+        if (v.isUnisatLegacy) {
+          if (!balance || balance.satoshis == 0) {
+            return false
+          }
+        }
+        return true
+      }).sort((a, b) => a.displayIndex - b.displayIndex)
+    } else {
+      return ADDRESS_TYPES.filter(v => v.displayIndex >= 0 && v.isUnisatLegacy != true).sort(
+        (a, b) => a.displayIndex - b.displayIndex
+      )
+    }
+  }, [currentKeyring.type, currentKeyring.addressType, addressAssets, addresses])
+
+  const items: AddressTypeItem[] = useMemo(() => {
+    return addressTypes.map(v => {
+      const address = addresses[v.value]
+      const assets = addressAssets[address] || {
+        total_btc: '--',
+        satoshis: 0,
+        total_inscription: 0,
+      }
+      const derivedPath = getAccountDerivationPath(v.hdPath, account.index || 0, currentKeyring.accountIndexDerivation)
+      let name = `${v.name} (${derivedPath})`
+      if (currentKeyring.type === KeyringType.SimpleKeyring) {
+        name = `${v.name}`
+      } else if (currentKeyring.type === KeyringType.ColdWalletKeyring) {
+        name = `❄️ ${v.name} (${derivedPath}) - ${t('Fixed by cold wallet')}`
+      }
+
+      return {
+        address,
+        assets,
+        name,
+        value: v.value,
+      }
+    })
+  }, [addressTypes])
+
+  const onClickItem = async (item: AddressTypeItem) => {
+    if (item.value == currentKeyring.addressType) {
+      return
+    }
+
+    // Cold wallets do not allow switching address types
+    if (currentKeyring.type === KeyringType.ColdWalletKeyring) {
+      tools.toastError(t('Cold wallet address type cannot be changed'))
+      return
+    }
+
+    await wallet.changeAddressType(item.value)
+    reloadAccounts()
+    // navigate('MainScreen')
+    tools.toastSuccess(t('address_type_changed'))
+
+    nav.navToTab()
+  }
+
+  return {
+    currentKeyring,
+    items,
+    wallet,
+    onClickItem,
+  }
+}

package/src/ui-hooks/useAlkanesBalanceCardLogic.ts

@@ -0,0 +1,41 @@
+import { bnUtils, numUtils } from '@unisat/base-utils'
+import { AlkanesBalance, TickPriceItem } from '@unisat/wallet-shared'
+import { useAlkanesIconInfo, useChain } from 'src/hooks'
+
+export interface AlkanesBalanceCardProps {
+  tokenBalance: AlkanesBalance
+  onClick?: () => void
+  price?: TickPriceItem
+}
+export function useAlkanesBalanceCardLogic(props: AlkanesBalanceCardProps) {
+  const { tokenBalance, onClick, price } = props
+
+  const chain = useChain()
+  const showPrice = chain.showPrice && price !== undefined
+
+  const balance = bnUtils.toDecimalNumber(tokenBalance.amount, tokenBalance.divisibility)
+  let balanceStr = balance.toString()
+  if (balance.lt(0.0001)) {
+    balanceStr = '<0.0001'
+  } else {
+    balanceStr = numUtils.showLongNumber(balance.toString())
+  }
+
+  const iconInfo = useAlkanesIconInfo(tokenBalance.name, tokenBalance.alkaneid)
+
+  return {
+    // balance
+    tokenBalance,
+    balance,
+    balanceStr,
+
+    // price
+    showPrice,
+    price,
+
+    // icon
+    iconInfo,
+
+    onClick,
+  }
+}