@unisat/wallet-state 1.1.0 → 1.2.1

package/src/hooks/transactions.ts

@@ -5,7 +5,7 @@ import { ToAddressInfo, ToSignData, UnspentOutput } from '@unisat/wallet-shared'
 import { numUtils, timeUtils } from '@unisat/base-utils'
 import { AppState, useI18n, useTools } from '..'
 import { useWallet } from '../context/WalletContext'
-import { useAccountAddress, useCurrentAccount } from '../hooks/accounts'
+import { useAccountAddress, useCurrentAccount, useCurrentAccountCapabilities } from '../hooks/accounts'
 import { accountActions } from '../reducers/accounts'
 import { transactionsActions } from '../reducers/transactions'
 import { useAppDispatch, useAppSelector } from './base'
@@ -25,6 +25,7 @@ export function usePrepareSendBTCCallback() {
   const fromAddress = useAccountAddress()
   const utxos = useUtxos()
   const fetchUtxos = useFetchUtxosCallback()
+  const accountCapabilities = useCurrentAccountCapabilities()
 
   const { t } = useI18n()
   return useCallback(
@@ -35,6 +36,7 @@ export function usePrepareSendBTCCallback() {
       memo,
       memos,
       disableAutoAdjust,
+      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       toAmount: number
@@ -42,7 +44,11 @@ export function usePrepareSendBTCCallback() {
       memo?: string
       memos?: string[]
       disableAutoAdjust?: boolean
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       let _utxos: UnspentOutput[] = utxos
       if (_utxos.length === 0) {
         _utxos = await fetchUtxos()
@@ -65,6 +71,7 @@ export function usePrepareSendBTCCallback() {
           to: toAddressInfo.address,
           btcUtxos: _utxos,
           feeRate,
+          enableRBF,
         })
       } else {
         res = await wallet.createSendBTCPsbt({
@@ -72,6 +79,7 @@ export function usePrepareSendBTCCallback() {
           amount: toAmount,
           btcUtxos: _utxos,
           feeRate,
+          enableRBF,
           memo: memo!,
           memos: memos!,
         })
@@ -79,23 +87,30 @@ export function usePrepareSendBTCCallback() {
 
       return res
     },
-    [dispatch, wallet, fromAddress, utxos, fetchUtxos]
+    [dispatch, wallet, fromAddress, utxos, fetchUtxos, accountCapabilities.canCreateSigningRequest, t]
   )
 }
 
 export function usePrepareSendBypassHeadOffsetsCallback() {
   const dispatch = useAppDispatch()
   const wallet = useWallet()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   return useCallback(
     async ({
       toAddressInfo,
       toAmount,
       feeRate,
+      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       toAmount: number
       feeRate: number
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       const res = await wallet.createSendBTCOffsetPsbt(
         [
           {
@@ -103,11 +118,12 @@ export function usePrepareSendBypassHeadOffsetsCallback() {
             satoshis: toAmount,
           },
         ],
-        feeRate
+        feeRate,
+        enableRBF
       )
       return res
     },
-    [dispatch, wallet]
+    [dispatch, wallet, accountCapabilities.canCreateSigningRequest, t]
   )
 }
 
@@ -160,18 +176,25 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
   const fromAddress = useAccountAddress()
   const utxos = useUtxos()
   const fetchUtxos = useFetchUtxosCallback()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   return useCallback(
     async ({
       toAddressInfo,
       inscriptionId,
       feeRate,
       outputValue,
+      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       inscriptionId: string
       feeRate?: number
       outputValue?: number
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
         feeRate = summary.list[1]!.feeRate
@@ -188,11 +211,12 @@ export function usePrepareSendOrdinalsInscriptionCallback() {
         feeRate,
         outputValue: outputValue!,
         btcUtxos,
+        enableRBF,
       })
 
       return toSignData
     },
-    [dispatch, wallet, fromAddress, utxos]
+    [dispatch, wallet, fromAddress, utxos, accountCapabilities.canCreateSigningRequest, t]
   )
 }
 
@@ -202,16 +226,23 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
   const fromAddress = useAccountAddress()
   const fetchUtxos = useFetchUtxosCallback()
   const utxos = useUtxos()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   return useCallback(
     async ({
       toAddressInfo,
       inscriptionIds,
       feeRate,
+      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       inscriptionIds: string[]
       feeRate?: number
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
         feeRate = summary.list[1]!.feeRate
@@ -226,11 +257,12 @@ export function usePrepareSendOrdinalsInscriptionsCallback() {
         inscriptionIds,
         feeRate,
         btcUtxos,
+        enableRBF,
       })
 
       return res
     },
-    [dispatch, wallet, fromAddress, utxos]
+    [dispatch, wallet, fromAddress, utxos, accountCapabilities.canCreateSigningRequest, t]
   )
 }
 
@@ -241,16 +273,23 @@ export function useCreateSplitTxCallback() {
   const utxos = useUtxos()
   const fetchUtxos = useFetchUtxosCallback()
   const account = useCurrentAccount()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   return useCallback(
     async ({
       inscriptionId,
       feeRate,
       outputValue,
+      enableRBF,
     }: {
       inscriptionId: string
       feeRate: number
       outputValue: number
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       let btcUtxos = utxos
       if (btcUtxos.length === 0) {
         btcUtxos = await fetchUtxos()
@@ -261,11 +300,12 @@ export function useCreateSplitTxCallback() {
         feeRate,
         outputValue,
         btcUtxos,
+        enableRBF,
       })
 
       return res
     },
-    [dispatch, wallet, fromAddress, utxos]
+    [dispatch, wallet, fromAddress, utxos, accountCapabilities.canCreateSigningRequest, t]
   )
 }
 
@@ -378,6 +418,8 @@ export function usePrepareSendRunesCallback() {
   const assetUtxosRunes = useAssetUtxosRunes()
   const fetchAssetUtxosRunes = useFetchAssetUtxosRunesCallback()
   const account = useCurrentAccount()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   return useCallback(
     async ({
       toAddressInfo,
@@ -385,13 +427,18 @@ export function usePrepareSendRunesCallback() {
       runeAmount,
       outputValue,
       feeRate,
+      enableRBF,
     }: {
       toAddressInfo: ToAddressInfo
       runeid: string
       runeAmount: string
       outputValue?: number
       feeRate: number
+      enableRBF?: boolean
     }) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       if (!feeRate) {
         const summary = await wallet.getFeeSummary()
         feeRate = summary.list[1]!.feeRate
@@ -415,11 +462,22 @@ export function usePrepareSendRunesCallback() {
         feeRate,
         btcUtxos,
         assetUtxos,
+        enableRBF,
       })
 
       return toSignData
     },
-    [dispatch, wallet, fromAddress, utxos, assetUtxosRunes, fetchAssetUtxosRunes, account]
+    [
+      dispatch,
+      wallet,
+      fromAddress,
+      utxos,
+      assetUtxosRunes,
+      fetchAssetUtxosRunes,
+      account,
+      accountCapabilities.canCreateSigningRequest,
+      t,
+    ]
   )
 }
 
@@ -431,23 +489,30 @@ export function useRunesTx() {
 export function usePrepareSendAlkanesCallback() {
   const wallet = useWallet()
   const account = useCurrentAccount()
+  const accountCapabilities = useCurrentAccountCapabilities()
+  const { t } = useI18n()
   const callback = useCallback(
     async (
       toAddressInfo: ToAddressInfo,
       alkaneid: string,
       amount: string,
       feeRate: number,
-      type: 'ft' | 'nft'
+      type: 'ft' | 'nft',
+      enableRBF?: boolean
     ) => {
+      if (!accountCapabilities.canCreateSigningRequest) {
+        throw new Error(t('not_supported'))
+      }
       return await wallet.createSendAlkanesPsbt({
         to: toAddressInfo.address,
         alkaneid,
         amount,
         feeRate,
         type,
+        enableRBF,
       })
     },
-    [wallet, account]
+    [wallet, account, accountCapabilities.canCreateSigningRequest, t]
   )
   return callback
 }

package/src/hooks/ui.ts

@@ -33,6 +33,11 @@ export function useAlkanesAssetTabKey() {
   return uiState.alkanesAssetTabKey
 }
 
+export function useMoreAssetTabKey() {
+  const uiState = useUIState()
+  return uiState.moreAssetTabKey
+}
+
 export function useUiTxCreateScreen() {
   const uiState = useUIState()
   return uiState.uiTxCreateScreen
@@ -40,20 +45,26 @@ export function useUiTxCreateScreen() {
 
 export function useUpdateUiTxCreateScreen() {
   const dispatch = useAppDispatch()
-  return ({
-    toInfo,
-    inputAmount,
-  }: {
-    toInfo?: { address: string; domain: string; inscription?: Inscription }
-    inputAmount?: string
-  }) => {
-    dispatch(
-      (uiActions as any).updateTxCreateScreen({
-        toInfo,
-        inputAmount,
-      })
-    )
-  }
+  return useCallback(
+    ({
+      toInfo,
+      inputAmount,
+      enableRBF,
+    }: {
+      toInfo?: { address: string; domain: string; inscription?: Inscription }
+      inputAmount?: string
+      enableRBF?: boolean
+    }) => {
+      dispatch(
+        (uiActions as any).updateTxCreateScreen({
+          toInfo,
+          inputAmount,
+          enableRBF,
+        })
+      )
+    },
+    [dispatch]
+  )
 }
 
 export function useFeeRateBar() {
@@ -63,36 +74,39 @@ export function useFeeRateBar() {
 
 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).updateFeeRateBar({
-        feeRate,
-        feeRateInputVal,
-        enableLowFeeRate,
-        feeOptionIndex,
-        showCustomInput,
-      })
-    )
-  }
+  return useCallback(
+    ({
+      feeRate,
+      feeRateInputVal,
+      enableLowFeeRate,
+      feeOptionIndex,
+      showCustomInput,
+    }: {
+      feeRate?: number
+      feeRateInputVal?: string
+      enableLowFeeRate?: boolean
+      feeOptionIndex?: number
+      showCustomInput?: boolean
+    }) => {
+      dispatch(
+        (uiActions as any).updateFeeRateBar({
+          feeRate,
+          feeRateInputVal,
+          enableLowFeeRate,
+          feeOptionIndex,
+          showCustomInput,
+        })
+      )
+    },
+    [dispatch]
+  )
 }
 
 export function useResetFeeRateBar() {
   const dispatch = useAppDispatch()
-  return () => {
+  return useCallback(() => {
     dispatch((uiActions as any).resetFeeRateBar())
-  }
+  }, [dispatch])
 }
 
 export function useAddressInput() {
@@ -102,21 +116,24 @@ export function useAddressInput() {
 
 export function useUpdateAddressInput() {
   const dispatch = useAppDispatch()
-  return ({ address, domain }: { address?: string; domain?: string }) => {
-    dispatch(
-      (uiActions as any).updateAddressInput({
-        address,
-        domain,
-      })
-    )
-  }
+  return useCallback(
+    ({ address, domain }: { address?: string; domain?: string }) => {
+      dispatch(
+        (uiActions as any).updateAddressInput({
+          address,
+          domain,
+        })
+      )
+    },
+    [dispatch]
+  )
 }
 
 export function useResetAddressInput() {
   const dispatch = useAppDispatch()
-  return () => {
+  return useCallback(() => {
     dispatch((uiActions as any).resetAddressInput())
-  }
+  }, [dispatch])
 }
 
 export function useAmountInput() {
@@ -126,35 +143,38 @@ export function useAmountInput() {
 
 export function useUpdateAmountInput() {
   const dispatch = useAppDispatch()
-  return ({ amount }: { amount?: string }) => {
-    dispatch(
-      (uiActions as any).updateAmountInput({
-        amount,
-      })
-    )
-  }
+  return useCallback(
+    ({ amount }: { amount?: string }) => {
+      dispatch(
+        (uiActions as any).updateAmountInput({
+          amount,
+        })
+      )
+    },
+    [dispatch]
+  )
 }
 
 export function useResetAmountInput() {
   const dispatch = useAppDispatch()
-  return () => {
+  return useCallback(() => {
     dispatch((uiActions as any).resetAmountInput())
-  }
+  }, [dispatch])
 }
 
 export function useResetTxState() {
   const dispatch = useAppDispatch()
-  return () => {
+  return useCallback(() => {
     dispatch((uiActions as any).resetTxCreateScreen())
     dispatch((uiActions as any).resetFeeRateBar())
-  }
+  }, [dispatch])
 }
 
 export function useResetUiTxCreateScreen() {
   const dispatch = useAppDispatch()
-  return () => {
+  return useCallback(() => {
     dispatch((uiActions as any).resetTxCreateScreen())
-  }
+  }, [dispatch])
 }
 
 export const useThrottle = (callback, delay, lastCallRef) => {
@@ -202,7 +222,7 @@ export function getSupportedAssets(chainType: ChainType, address: string) {
 
   if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.BITCOIN_SIGNET) {
     assets.alkanes = true
-    assetTabKeys.push(AssetTabKey.ALKANES)
+    assetTabKeys.push(AssetTabKey.MORE)
   }
 
   if (chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.BITCOIN_SIGNET) {

package/src/reducers/accounts.ts

@@ -183,6 +183,9 @@ const slice: Slice<AccountsState> = createSlice({
     setAddressSummary(state, action: { payload: any }) {
       state.addressSummary = action.payload
     },
+    setModelPopover(state, action: { payload: MolelsPopover }) {
+      state.molelsPopover = action.payload
+    },
     expireBalance(state) {
       const balance = state.balanceMap[state.current.address]
       if (balance) {

package/src/reducers/ui.ts

@@ -6,6 +6,7 @@ import {
   AlkanesAssetTabKey,
   AssetTabKey,
   CATAssetTabKey,
+  MoreAssetTabKey,
   NavigationSource,
   OrdinalsAssetTabKey,
 } from '../types'
@@ -23,6 +24,7 @@ export interface UIState {
   ordinalsAssetTabKey: OrdinalsAssetTabKey
   catAssetTabKey: CATAssetTabKey
   alkanesAssetTabKey: AlkanesAssetTabKey
+  moreAssetTabKey: MoreAssetTabKey
   uiTxCreateScreen: {
     toInfo: {
       address: string
@@ -30,6 +32,7 @@ export interface UIState {
       inscription?: Inscription
     }
     inputAmount: string
+    enableRBF: boolean
   }
   addressInput: {
     address: string
@@ -64,12 +67,14 @@ export const initialState: UIState = {
   ordinalsAssetTabKey: OrdinalsAssetTabKey.ALL,
   catAssetTabKey: CATAssetTabKey.CAT20,
   alkanesAssetTabKey: AlkanesAssetTabKey.TOKEN,
+  moreAssetTabKey: MoreAssetTabKey.ALKANES_TOKEN,
   uiTxCreateScreen: {
     toInfo: {
       address: '',
       domain: '',
     },
     inputAmount: '',
+    enableRBF: true,
   },
   addressInput: {
     address: '',
@@ -113,6 +118,7 @@ const slice: Slice<UIState> = createSlice({
           ordinalsAssetTabKey?: OrdinalsAssetTabKey
           catAssetTabKey?: CATAssetTabKey
           alkanesAssetTabKey?: AlkanesAssetTabKey
+          moreAssetTabKey?: MoreAssetTabKey
         }
       }
     ) {
@@ -130,6 +136,9 @@ const slice: Slice<UIState> = createSlice({
       if (payload.alkanesAssetTabKey !== undefined) {
         state.alkanesAssetTabKey = payload.alkanesAssetTabKey
       }
+      if (payload.moreAssetTabKey !== undefined) {
+        state.moreAssetTabKey = payload.moreAssetTabKey
+      }
       return state
     },
     updateTxCreateScreen(
@@ -142,6 +151,7 @@ const slice: Slice<UIState> = createSlice({
             inscription?: Inscription
           }
           inputAmount?: string
+          enableRBF?: boolean
         }
       }
     ) {
@@ -151,6 +161,9 @@ 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 }
     },
@@ -274,8 +287,16 @@ const slice: Slice<UIState> = createSlice({
       if (!state.alkanesAssetTabKey) {
         state.alkanesAssetTabKey = AlkanesAssetTabKey.TOKEN
       }
+      if (state.moreAssetTabKey === undefined) {
+        state.moreAssetTabKey = MoreAssetTabKey.ALKANES_TOKEN
+      }
+      if (state.assetTabKey === (4 as AssetTabKey)) {
+        state.assetTabKey = AssetTabKey.MORE
+      }
       if (!state.uiTxCreateScreen) {
         state.uiTxCreateScreen = initialState.uiTxCreateScreen
+      } else if (state.uiTxCreateScreen.enableRBF === undefined) {
+        state.uiTxCreateScreen.enableRBF = true
       }
       if (!state.feeRateBar) {
         state.feeRateBar = initialState.feeRateBar

package/src/types/ui.ts

@@ -3,7 +3,7 @@ export enum AssetTabKey {
   ATOMICALS = 1, // IGNORED
   RUNES = 2,
   CAT = 3,
-  ALKANES = 4,
+  MORE = 4,
 }
 
 export enum OrdinalsAssetTabKey {
@@ -24,6 +24,11 @@ export enum AlkanesAssetTabKey {
   COLLECTION,
 }
 
+export enum MoreAssetTabKey {
+  ALKANES_TOKEN,
+  ALKANES_COLLECTION,
+}
+
 export enum NavigationSource {
   BACK,
   NORMAL,

package/src/ui-hooks/useAddressTypeScreenLogic.ts

@@ -2,7 +2,7 @@ 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 { getAccountCapabilities, getAccountDerivationPath } from '@unisat/wallet-shared'
 import { AddressType } from '@unisat/wallet-types'
 import {
   useAppDispatch,
@@ -29,6 +29,10 @@ export function useAddressTypeScreenLogic() {
   const wallet = useWallet()
   const currentKeyring = useCurrentKeyring()
   const account = useCurrentAccount()
+  const currentKeyringCapabilities = useMemo(
+    () => getAccountCapabilities({ type: currentKeyring.type }),
+    [currentKeyring.type]
+  )
 
   const nav = useNavigation()
   const dispatch = useAppDispatch()
@@ -77,8 +81,8 @@ export function useAddressTypeScreenLogic() {
   }, [])
 
   const addressTypes = useMemo(() => {
-    // Cold wallets do not allow switching address types, only show the current type
-    if (currentKeyring.type === KeyringType.ColdWalletKeyring) {
+    // Wallets backed by a fixed address do not allow switching address types.
+    if (!currentKeyringCapabilities.canChangeAddressType) {
       return ADDRESS_TYPES.filter(v => v.value === currentKeyring.addressType)
     }
 
@@ -105,7 +109,14 @@ export function useAddressTypeScreenLogic() {
         (a, b) => a.displayIndex - b.displayIndex
       )
     }
-  }, [currentKeyring.type, currentKeyring.addressType, addressAssets, addresses])
+  }, [
+    currentKeyring.type,
+    currentKeyring.addressType,
+    currentKeyringCapabilities.canChangeAddressType,
+    currentKeyring.accountIndexDerivation,
+    addressAssets,
+    addresses,
+  ])
 
   const items: AddressTypeItem[] = useMemo(() => {
     return addressTypes.map(v => {
@@ -115,7 +126,11 @@ export function useAddressTypeScreenLogic() {
         satoshis: 0,
         total_inscription: 0,
       }
-      const derivedPath = getAccountDerivationPath(v.hdPath, account.index || 0, currentKeyring.accountIndexDerivation)
+      const derivedPath = getAccountDerivationPath(
+        v.hdPath,
+        account.index || 0,
+        currentKeyring.accountIndexDerivation
+      )
       let name = `${v.name} (${derivedPath})`
       if (currentKeyring.type === KeyringType.SimpleKeyring) {
         name = `${v.name}`
@@ -137,9 +152,8 @@ export function useAddressTypeScreenLogic() {
       return
     }
 
-    // Cold wallets do not allow switching address types
-    if (currentKeyring.type === KeyringType.ColdWalletKeyring) {
-      tools.toastError(t('Cold wallet address type cannot be changed'))
+    if (!currentKeyringCapabilities.canChangeAddressType) {
+      tools.toastError(t('not_supported'))
       return
     }