@unisat/wallet-state 1.0.5 → 1.1.0

package/src/ui-hooks/useSendOrdinalsInscriptionScreenLogic.ts

@@ -0,0 +1,137 @@
+import { Inscription } from '@unisat/wallet-shared'
+import { useEffect, useMemo, useState } from 'react'
+import {
+  useFeeRateBar,
+  useFetchUtxosCallback,
+  useI18n,
+  useNavigation,
+  useOrdinalsTx,
+  usePrepareSendOrdinalsInscriptionCallback,
+  useTools,
+  useWallet,
+} from '..'
+import { getAddressUtxoDust, isValidAddress } from '../utils/bitcoin-utils'
+
+export function useSendOrdinalsInscriptionScreenLogic() {
+  const [disabled, setDisabled] = useState(true)
+  const nav = useNavigation()
+
+  const { inscription } = nav.getRouteState<'SendOrdinalsInscriptionScreen'>()
+  const ordinalsTx = useOrdinalsTx()
+  const [toInfo, setToInfo] = useState({
+    address: ordinalsTx.toAddress,
+    domain: ordinalsTx.toDomain,
+  })
+  const { t } = useI18n()
+
+  const fetchBtcUtxos = useFetchUtxosCallback()
+  const tools = useTools()
+  useEffect(() => {
+    tools.showLoading(true)
+    fetchBtcUtxos().finally(() => {
+      tools.showLoading(false)
+    })
+  }, [])
+
+  const [error, setError] = useState('')
+  const prepareSendOrdinalsInscription = usePrepareSendOrdinalsInscriptionCallback()
+  const { feeRate } = useFeeRateBar()
+  const defaultOutputValue = inscription ? inscription.outputValue : 10000
+
+  const [outputValue, setOutputValue] = useState(defaultOutputValue)
+  const [inscriptions, setInscriptions] = useState<Inscription[]>([])
+
+  const wallet = useWallet()
+  useEffect(() => {
+    wallet.getInscriptionUtxoDetail(inscription.inscriptionId).then(v => {
+      setInscriptions(v.inscriptions)
+    })
+  }, [])
+
+  const minOutputValue = useMemo(() => {
+    if (toInfo.address) {
+      return getAddressUtxoDust(toInfo.address)
+    } else {
+      return 0
+    }
+  }, [toInfo.address])
+
+  useEffect(() => {
+    setDisabled(true)
+    setError('')
+
+    if (feeRate <= 0) {
+      setError(t('invalid_fee_rate'))
+      return
+    }
+
+    let dustUtxo = inscription.outputValue
+    try {
+      if (toInfo.address) {
+        dustUtxo = getAddressUtxoDust(toInfo.address)
+      }
+    } catch (e) {
+      // console.log(e);
+    }
+
+    const maxOffset = inscriptions.reduce((pre, cur) => {
+      return Math.max(pre, cur.offset)
+    }, 0)
+
+    const minOutputValue = Math.max(maxOffset + 1, dustUtxo)
+
+    if (outputValue < minOutputValue) {
+      setError(`${t('output_value_must_be_at_least')} ${minOutputValue}`)
+      return
+    }
+
+    if (!outputValue) {
+      return
+    }
+
+    if (!isValidAddress(toInfo.address)) {
+      return
+    }
+
+    setDisabled(false)
+  }, [toInfo, feeRate, outputValue, inscriptions])
+
+  const onAddressInputChange = val => {
+    setToInfo(val)
+  }
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  const onClickNext = () => {
+    prepareSendOrdinalsInscription({
+      toAddressInfo: toInfo,
+      inscriptionId: inscription.inscriptionId,
+      feeRate,
+      outputValue,
+    })
+      .then(toSignData => {
+        nav.navigate('TxConfirmScreen', { toSignData })
+      })
+      .catch(e => {
+        console.log(e)
+        setError(e.message)
+      })
+  }
+
+  return {
+    t,
+    onAddressInputChange,
+    toInfo,
+    outputValue,
+    minOutputValue,
+    defaultOutputValue,
+    setOutputValue,
+    inscriptions,
+    disabled,
+    error,
+    onClickBack,
+    onClickNext,
+  }
+}

package/src/ui-hooks/useSendRunesScreenLogic.ts

@@ -0,0 +1,172 @@
+import { bnUtils } from '@unisat/base-utils'
+import { Inscription } from '@unisat/wallet-shared'
+import BigNumber from 'bignumber.js'
+import { useEffect, useMemo, useState } from 'react'
+import { useI18n, useNavigation, useTools } from 'src/context'
+import {
+  useCurrentAccount,
+  useFeeRateBar,
+  useFetchAssetUtxosRunesCallback,
+  useFetchUtxosCallback,
+  usePrepareSendRunesCallback,
+  useRunesTx,
+} from 'src/hooks'
+import { getAddressUtxoDust, isValidAddress } from 'src/utils/bitcoin-utils'
+
+export function useSendRunesScreenLogic() {
+  const nav = useNavigation()
+  const props = nav.getRouteState<'SendRunesScreen'>()
+  const { t } = useI18n()
+
+  const runeBalance = props.runeBalance
+
+  const runeInfo = props.runeInfo
+
+  const runesTx = useRunesTx()
+  const [inputAmount, setInputAmount] = useState('')
+  const [disabled, setDisabled] = useState(true)
+  const [toInfo, setToInfo] = useState<{
+    address: string
+    domain: string
+    inscription?: Inscription
+  }>({
+    address: runesTx.toAddress,
+    domain: runesTx.toDomain,
+    inscription: undefined,
+  })
+
+  const [availableBalance, setAvailableBalance] = useState('0')
+  const [error, setError] = useState('')
+
+  const defaultOutputValue = 546
+
+  const currentAccount = useCurrentAccount()
+  const [outputValue, setOutputValue] = useState(defaultOutputValue)
+  const minOutputValue = useMemo(() => {
+    if (toInfo.address) {
+      const dust1 = getAddressUtxoDust(currentAccount.address)
+      const dust2 = getAddressUtxoDust(toInfo.address)
+      return Math.max(dust1, dust2)
+    } else {
+      return 0
+    }
+  }, [toInfo.address, currentAccount.address])
+
+  const fetchUtxos = useFetchUtxosCallback()
+
+  const fetchAssetUtxosRunes = useFetchAssetUtxosRunesCallback()
+  const tools = useTools()
+  useEffect(() => {
+    fetchUtxos()
+    tools.showLoading(true)
+    fetchAssetUtxosRunes(runeInfo.runeid)
+      .then(utxos => {
+        let balance = new BigNumber(0)
+        for (let i = 0; i < utxos.length; i++) {
+          const utxo = utxos[i]
+          if (utxo.runes) {
+            utxo.runes.forEach(rune => {
+              if (rune.runeid === runeInfo.runeid) {
+                balance = balance.plus(new BigNumber(rune.amount))
+              }
+            })
+          }
+        }
+        setAvailableBalance(balance.toString())
+      })
+      .finally(() => {
+        tools.showLoading(false)
+      })
+  }, [])
+
+  const prepareSendRunes = usePrepareSendRunesCallback()
+
+  const { feeRate } = useFeeRateBar()
+
+  useEffect(() => {
+    setError('')
+    setDisabled(true)
+
+    if (!isValidAddress(toInfo.address)) {
+      return
+    }
+    if (!inputAmount) {
+      return
+    }
+
+    const runeAmount = bnUtils.fromDecimalAmount(inputAmount, runeInfo.divisibility)
+    if (feeRate <= 0) {
+      return
+    }
+
+    if (bnUtils.compareAmount(runeAmount, '0') <= 0) {
+      return
+    }
+
+    if (bnUtils.compareAmount(runeAmount, availableBalance) > 0) {
+      setError(t('insufficient_balance'))
+      return
+    }
+
+    if (outputValue < minOutputValue) {
+      setError(`${t('output_value_must_be_at_least')} ${minOutputValue}`)
+      return
+    }
+
+    if (!outputValue) {
+      return
+    }
+
+    setDisabled(false)
+  }, [toInfo, inputAmount, feeRate, outputValue, minOutputValue, availableBalance])
+
+  const totalBalanceStr = useMemo(() => {
+    return bnUtils.toDecimalAmount(runeBalance.amount, runeBalance.divisibility)
+  }, [runeBalance])
+  const availableBalanceStr = useMemo(() => {
+    return bnUtils.toDecimalAmount(availableBalance, runeBalance?.divisibility)
+  }, [availableBalance, runeBalance])
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+  const onClickNext = () => {
+    const runeAmount = bnUtils.fromDecimalAmount(inputAmount, runeInfo.divisibility)
+    prepareSendRunes({
+      toAddressInfo: toInfo,
+      runeid: runeInfo.runeid,
+      runeAmount: runeAmount,
+      outputValue: outputValue,
+      feeRate,
+    })
+      .then(toSignData => {
+        nav.navigate('TxConfirmScreen', { toSignData })
+      })
+      .catch(e => {
+        console.log(e)
+        setError(e.message)
+      })
+  }
+
+  return {
+    // info
+    runeInfo,
+    inputAmount,
+    totalBalanceStr,
+    availableBalanceStr,
+
+    setInputAmount,
+    disabled,
+    toInfo,
+    setToInfo,
+    error,
+    defaultOutputValue,
+    minOutputValue,
+    setOutputValue,
+    t,
+
+    // actions
+    onClickBack,
+    onClickNext,
+  }
+}

package/src/ui-hooks/useSettingsTabScreenLogic.ts

@@ -0,0 +1,211 @@
+import { KeyringType } from '@unisat/keyring-service/types'
+import { ADDRESS_TYPES, FEEDBACK_URL, PlatformEnv } from '@unisat/wallet-shared'
+import { useMemo, useState } from 'react'
+import { useDevice, useI18n, useNavigation, useTools, useWallet } from 'src/context'
+import { useChain, useCurrentAccount, useCurrentKeyring, useVersionInfo } from 'src/hooks'
+
+export interface SettingsItemType {
+  key: string
+  label?: string
+  value?: string
+  desc?: string
+  danger?: boolean
+  right: boolean
+  icon?: string
+  badge?: string
+  onClick?: () => void
+}
+
+export function useSettingsTabScreenLogic() {
+  const nav = useNavigation()
+  const currentKeyring = useCurrentKeyring()
+  const currentAccount = useCurrentAccount()
+  const chain = useChain()
+  const wallet = useWallet()
+  const tools = useTools()
+  const [connected, setConnected] = useState(false)
+  const versionInfo = useVersionInfo()
+  const hasUpdate =
+    versionInfo.latestVersion && versionInfo.latestVersion !== versionInfo.currentVesion
+  const { t } = useI18n()
+
+  const { isExtensionInExpandView } = useDevice()
+
+  const isCustomHdPath = useMemo(() => {
+    const item = ADDRESS_TYPES[currentKeyring.addressType]
+    return currentKeyring.hdPath !== '' && item.hdPath !== currentKeyring.hdPath
+  }, [currentKeyring])
+
+  const settings_connectedSites: SettingsItemType = useMemo(() => {
+    const value = connected ? t('connected') : t('not_connected')
+    return {
+      key: 'settings_connectedSites',
+      label: t('connected_sites'),
+      value,
+      desc: '',
+      right: true,
+      icon: 'connectedSites',
+      onClick: () => {
+        nav.navigate('ConnectedSitesScreen')
+      },
+    }
+  }, [t, connected])
+
+  const settings_addressBook: SettingsItemType = useMemo(() => {
+    return {
+      key: 'settings_addressBook',
+      label: t('address_book'),
+      value: t('addressbook_desc'),
+      desc: '',
+      right: true,
+      icon: 'addressBook',
+      onClick: () => {
+        // todo
+        nav.navigate('ContactsScreen', {})
+      },
+    }
+  }, [t])
+  const settings_addressType: SettingsItemType = useMemo(() => {
+    let value = ''
+    const item = ADDRESS_TYPES[currentKeyring.addressType]
+    const hdPath = currentKeyring.hdPath || item.hdPath
+    if (currentKeyring.type === KeyringType.SimpleKeyring) {
+      value = `${item.name}`
+    } else {
+      value = `${item.name} (${hdPath}/${currentAccount.index})`
+    }
+    return {
+      key: 'settings_addressType',
+      label: t('address_type'),
+      value,
+      desc: '',
+      right: true,
+      icon: 'addressType',
+      onClick: () => {
+        if (isCustomHdPath) {
+          tools.showTip(
+            t(
+              'the_wallet_currently_uses_a_custom_hd_path_and_does_not_support_switching_address_types'
+            )
+          )
+          return
+        }
+        nav.navigate('AddressTypeScreen')
+      },
+    }
+  }, [t, isCustomHdPath])
+
+  const settings_advanced = useMemo(() => {
+    return {
+      key: 'settings_advanced',
+      label: t('settings'),
+      value: t('advanced_settings'),
+      desc: '',
+      right: true,
+      icon: 'advance',
+      onClick: () => {
+        nav.navigate('AdvancedScreen')
+      },
+    }
+  }, [t])
+
+  const settings_feedback = useMemo(() => {
+    return {
+      key: 'settings_feedback',
+      label: t('feedback'),
+      value: t('let_us_know_what_you_think'),
+      desc: '',
+      route: '',
+      right: true,
+      icon: 'feedback',
+      onClick: () => {
+        const addressParam = currentAccount.address
+
+        let feedbackUrl = FEEDBACK_URL
+        feedbackUrl += `?address=${addressParam}&category=wallet`
+
+        nav.navToUrl(feedbackUrl)
+      },
+    }
+  }, [t])
+
+  const settings_rateus = useMemo(() => {
+    return {
+      key: 'settings_rateus',
+      label: t('rate_us'),
+      value: t('like_our_wallet_wed_love_your_rating'),
+      desc: '',
+      route: '',
+      right: true,
+      icon: 'rateUs',
+      onClick: () => {
+        nav.navToUrl(PlatformEnv.REVIEW_URL)
+      },
+    }
+  }, [t])
+
+  const settings_aboutus = useMemo(() => {
+    return {
+      key: 'settings_aboutus',
+      label: t('about_us'),
+      value: '',
+      desc: '',
+      right: true,
+      icon: 'aboutUsLogo',
+      badge: hasUpdate ? t('new_version') : undefined,
+      onClick: () => {
+        nav.navigate('AboutUsScreen')
+      },
+    }
+  }, [t, hasUpdate])
+
+  const settings_lockwallet = useMemo(() => {
+    return {
+      key: 'settings_lockwallet',
+      label: '',
+      value: '',
+      desc: t('lock_immediately'),
+      right: false,
+      onClick: () => {
+        wallet.lockWallet()
+
+        // Add small delay to ensure lock state updates before navigation
+        // Prevents race condition where unlock screen might redirect back to main
+        setTimeout(() => {
+          nav.navToLock({
+            autoUnlockByFace: false,
+          })
+        }, 10)
+        return
+      },
+    }
+  }, [t])
+
+  const settings_expandview = useMemo(() => {
+    if (isExtensionInExpandView) {
+      return null
+    }
+    return {
+      key: 'settings_expandview',
+      label: '',
+      value: '',
+      desc: t('expand_view'),
+      right: false,
+      onClick: () => {
+        nav.openExtensionInTab()
+      },
+    }
+  }, [t])
+
+  return {
+    settings_connectedSites,
+    settings_addressBook,
+    settings_addressType,
+    settings_advanced,
+    settings_feedback,
+    settings_rateus,
+    settings_aboutus,
+    settings_lockwallet,
+    settings_expandview,
+  }
+}