@unisat/wallet-state 1.0.4 → 1.1.0

package/src/ui-hooks/useOrdinalsInscriptionScreenLogic.ts

@@ -0,0 +1,130 @@
+import { Inscription } from '@unisat/wallet-shared'
+import { useCallback, useEffect, useState } from 'react'
+import { useI18n, useNavigation, useWallet } from 'src/context'
+import { useCurrentAccount, useResetTxState } from 'src/hooks'
+
+const HIGH_BALANCE = 10000
+
+enum TabKey {
+  DETAILS = 'DETAILS',
+  PROVENANCE = 'PROVENANCE',
+}
+export function useOrdinalsInscriptionScreenLogic() {
+  const nav = useNavigation()
+  const props = nav.getRouteState<'OrdinalsInscriptionScreen'>()
+  const inscriptionId = props.inscriptionId
+
+  const [inscription, setInscription] = useState<Inscription>(props.inscription)
+  const [isLoadingDetails, setIsLoadingDetails] = useState(false)
+  const [isInitialLoading, setIsInitialLoading] = useState(!props.inscription)
+
+  const currentAccount = useCurrentAccount()
+
+  const resetTxState = useResetTxState()
+
+  const { t } = useI18n()
+
+  const [isNeedToSplit, setIsNeedToSplit] = useState(false)
+  const [isMultiStuck, setIsMultiStuck] = useState(false)
+  const wallet = useWallet()
+
+  const [tabKey, setTabKey] = useState(TabKey.DETAILS)
+
+  const resetState = useCallback(() => {
+    setIsNeedToSplit(false)
+    setIsMultiStuck(false)
+    setIsLoadingDetails(false)
+    setIsInitialLoading(!props?.inscription)
+    setTabKey(TabKey.DETAILS)
+  }, [props?.inscription])
+
+  const fetchInscriptionData = async (id: string) => {
+    if (!id) return
+
+    // If we already have basic inscription data, show it immediately
+    // and load details in the background
+    const isBackgroundLoading = !!inscription
+
+    if (isBackgroundLoading) {
+      setIsLoadingDetails(true)
+    } else {
+      setIsInitialLoading(true)
+    }
+
+    try {
+      const data = await wallet.getInscriptionInfo(id)
+      setInscription(data)
+      setTabKey(TabKey.DETAILS)
+
+      if (data.multipleNFT) {
+        setIsMultiStuck(true)
+
+        if (data.sameOffset) {
+          setIsNeedToSplit(false)
+        } else {
+          if (data.outputValue > HIGH_BALANCE) {
+            setIsNeedToSplit(true)
+          }
+        }
+      } else {
+        if (data.outputValue > HIGH_BALANCE) {
+          setIsNeedToSplit(true)
+        }
+      }
+    } catch (e) {
+      console.error('Failed to fetch inscription data:', e)
+    } finally {
+      setIsLoadingDetails(false)
+      setIsInitialLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    if (inscriptionId) {
+      resetState()
+
+      // Always fetch the latest data, but we'll show what we have immediately
+      fetchInscriptionData(inscriptionId)
+    }
+  }, [inscriptionId])
+
+  const onClickSplit = () => {
+    resetTxState()
+    nav.navigate('SplitOrdinalsInscriptionScreen', { inscription, inscriptionId })
+  }
+
+  const onClickSend = () => {
+    resetTxState()
+    nav.navigate('SendOrdinalsInscriptionScreen', { inscription, inscriptionId })
+  }
+
+  const isUnconfirmed = inscription ? inscription.timestamp == 0 : false
+
+  const withSend = inscription ? currentAccount.address === inscription.address : false
+
+  const children = inscription ? inscription.children || [] : []
+  const parents = inscription ? inscription.parents || [] : []
+
+  const hasProvenance = children.length > 0 || parents.length > 0
+  const shouldShowTabs = hasProvenance === true
+
+  return {
+    inscription,
+    isLoadingDetails,
+    isInitialLoading,
+    isNeedToSplit,
+    isMultiStuck,
+    tabKey,
+    setTabKey,
+    TabKey,
+    resetState,
+    t,
+    inscriptionId,
+    onClickSend,
+    onClickSplit,
+    isUnconfirmed,
+    withSend,
+    shouldShowTabs,
+    nav,
+  }
+}

package/src/ui-hooks/useRunesBalanceCardLogic.ts

@@ -0,0 +1,44 @@
+import { bnUtils, numUtils } from '@unisat/base-utils'
+import { RuneBalance, TickPriceItem } from '@unisat/wallet-shared'
+import { useChain, useRunesIconInfo } from 'src/hooks'
+
+export interface RunesBalanceCardProps {
+  tokenBalance: RuneBalance
+  onClick?: () => void
+  price?: TickPriceItem
+}
+export function useRunesBalanceCardLogic(props: RunesBalanceCardProps) {
+  const { tokenBalance, price, onClick } = props
+
+  // balance
+  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())
+  }
+
+  // price
+  const chain = useChain()
+  const showPrice = chain.showPrice
+
+  // icon
+  const iconInfo = useRunesIconInfo(tokenBalance.spacedRune)
+
+  return {
+    // balance
+    tokenBalance,
+    balance,
+    balanceStr,
+
+    // price
+    showPrice,
+    price,
+
+    // icon
+    iconInfo,
+
+    onClick,
+  }
+}

package/src/ui-hooks/useRunesListLogic.ts

@@ -0,0 +1,74 @@
+import { RuneBalance, TickPriceItem } from '@unisat/wallet-shared'
+import { useEffect, useRef, useState } from 'react'
+import {
+  AssetTabKey,
+  useAssetTabKey,
+  useChainType,
+  useCurrentAccount,
+  useNavigation,
+  useWallet,
+  useWallTabFocusRefresh,
+} from '..'
+import { useInfiniteList } from './useInfiniteList'
+
+export function useRunesListLogic() {
+  const nav = useNavigation()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const chainType = useChainType()
+  const [priceMap, setPriceMap] = useState<{ [key: string]: TickPriceItem }>({})
+
+  const priceMapRef = useRef(priceMap)
+  const updatePrices = (res: { [tick: string]: TickPriceItem }) => {
+    const newPriceMap = { ...priceMapRef.current }
+    Object.keys(res).forEach(tick => {
+      newPriceMap[tick] = res[tick]
+    })
+    priceMapRef.current = newPriceMap
+    setPriceMap(newPriceMap)
+  }
+
+  const {
+    data: items,
+    total,
+    loading,
+    hasMore,
+    onRefresh,
+    onLoadMore,
+  } = useInfiniteList<RuneBalance>({
+    fetcher: async (page, pageSize) => {
+      if (currentAccount.address === '') {
+        return { list: [], total: 0 }
+      }
+      const { list, total } = await wallet.getRunesList(currentAccount.address, page, pageSize)
+      if (list.length > 0) {
+        wallet.getRunesPrice(list.map(item => item.spacedRune)).then(updatePrices)
+      }
+      return { list, total }
+    },
+    dependencies: [currentAccount.address, chainType],
+  })
+
+  const assetTabKey = useAssetTabKey()
+  const isFocus = assetTabKey === AssetTabKey.RUNES
+  const lastRefreshTimeRef = useRef<number>(0)
+  const walletTabFocusRefresh = useWallTabFocusRefresh()
+  useEffect(() => {
+    if (!isFocus) return
+
+    // already refreshed → do nothing
+    const alreadyRefreshed = lastRefreshTimeRef.current === walletTabFocusRefresh
+    if (alreadyRefreshed) return
+
+    onRefresh()
+
+    // mark refreshed
+    lastRefreshTimeRef.current = walletTabFocusRefresh
+  }, [walletTabFocusRefresh, isFocus])
+
+  const onClickItem = (item: RuneBalance) => {
+    nav.navigate('RunesTokenScreen', { runeid: item.runeid })
+  }
+
+  return { items, total, loading, hasMore, onRefresh, onLoadMore, onClickItem, priceMap }
+}

package/src/ui-hooks/useRunesTokenScreenLogic.ts

@@ -0,0 +1,149 @@
+import { AddressRunesTokenSummary } from '@unisat/wallet-shared'
+import { ChainType } from '@unisat/wallet-types'
+import { useEffect, useMemo, useState } from 'react'
+import { useI18n, useNavigation, useTools, useWallet } from 'src/context'
+import {
+  useChainType,
+  useCurrentAccount,
+  useOrdinalsWebsite,
+  useResetTxState,
+  useRunesIconInfo,
+  useRunesInscribeUrl,
+  useRunesMarketUrl,
+  useTxExplorerUrl,
+} from 'src/hooks'
+
+export function useRunesTokenScreenLogic() {
+  const nav = useNavigation()
+  const { runeid } = nav.getRouteState<'RunesTokenScreen'>()
+  const [tokenSummary, setTokenSummary] = useState<AddressRunesTokenSummary>({
+    runeBalance: {
+      runeid: '',
+      rune: '',
+      spacedRune: '',
+      amount: '',
+      symbol: '',
+      divisibility: 0,
+    },
+    runeInfo: {
+      rune: '',
+      runeid: '',
+      spacedRune: '',
+      symbol: '',
+      premine: '',
+      mints: '',
+      divisibility: 0,
+      etching: '',
+      terms: {
+        amount: '',
+        cap: '',
+        heightStart: 0,
+        heightEnd: 0,
+        offsetStart: 0,
+        offsetEnd: 0,
+      },
+      number: 0,
+      height: 0,
+      txidx: 0,
+      timestamp: 0,
+      burned: '',
+      holders: 0,
+      transactions: 0,
+      mintable: false,
+      remaining: '',
+      start: 0,
+      end: 0,
+      supply: '0',
+      parent: '',
+    },
+  })
+
+  const wallet = useWallet()
+
+  const account = useCurrentAccount()
+
+  const [loading, setLoading] = useState(true)
+
+  const { t } = useI18n()
+
+  useEffect(() => {
+    wallet.getAddressRunesTokenSummary(account.address, runeid).then(tokenSummary => {
+      setTokenSummary(tokenSummary)
+      setLoading(false)
+    })
+  }, [])
+
+  const enableMint = tokenSummary.runeInfo.mintable
+
+  const enableTransfer = useMemo(() => {
+    let enable = false
+    if (tokenSummary.runeBalance.amount !== '0') {
+      enable = true
+    }
+    return enable
+  }, [tokenSummary])
+
+  const tools = useTools()
+
+  const ordinalsWebsite = useOrdinalsWebsite()
+
+  const resetTxState = useResetTxState()
+
+  const txExplorerUrl = useTxExplorerUrl(tokenSummary.runeInfo.etching)
+
+  const chainType = useChainType()
+  const enableTrade = useMemo(() => {
+    if (
+      chainType === ChainType.BITCOIN_MAINNET ||
+      chainType === ChainType.FRACTAL_BITCOIN_MAINNET
+    ) {
+      return true
+    } else {
+      return false
+    }
+  }, [chainType])
+
+  const iconInfo = useRunesIconInfo(tokenSummary.runeInfo.spacedRune)
+  const inscribeUrl = useRunesInscribeUrl(tokenSummary.runeInfo.rune)
+  const marketPlaceUrl = useRunesMarketUrl(tokenSummary.runeInfo.spacedRune)
+
+  const onClickMint = () => {
+    nav.navToUrl(inscribeUrl)
+  }
+
+  const onClickSend = () => {
+    resetTxState()
+    nav.navigate('SendRunesScreen', {
+      runeBalance: tokenSummary.runeBalance,
+      runeInfo: tokenSummary.runeInfo,
+    })
+  }
+
+  const onClickTrade = () => {
+    if (marketPlaceUrl) {
+      nav.navToUrl(marketPlaceUrl)
+    }
+  }
+
+  return {
+    runeid,
+    tokenSummary,
+    iconInfo,
+
+    loading,
+    t,
+
+    enableMint,
+    onClickMint,
+
+    tools,
+    ordinalsWebsite,
+    txExplorerUrl,
+
+    enableTransfer,
+    onClickSend,
+
+    enableTrade,
+    onClickTrade,
+  }
+}

package/src/ui-hooks/useSendAlkanesNFTScreenLogic.ts

@@ -0,0 +1,138 @@
+import { Inscription, SignedData, SignPsbtParams, ToSignData } from '@unisat/wallet-shared'
+import { useEffect, useRef, useState } from 'react'
+import { useI18n, useNavigation, useTools } from 'src/context'
+import {
+  useCurrentAccount,
+  useFeeRateBar,
+  usePrepareSendAlkanesCallback,
+  usePushBitcoinTxCallback,
+} from 'src/hooks'
+import { isValidAddress } from 'src/utils/bitcoin-utils'
+
+export enum SendAlkanesNFTScreenStep {
+  CREATE_TX = 0,
+  SIGN_TX = 1,
+}
+export function useSendAlkanesNFTScreenLogic() {
+  const nav = useNavigation()
+  const props = nav.getRouteState<'SendAlkanesNFTScreen'>()
+
+  const { t } = useI18n()
+
+  const alkanesInfo = props.alkanesInfo
+
+  const [disabled, setDisabled] = useState(true)
+  const [toInfo, setToInfo] = useState<{
+    address: string
+    domain: string
+    inscription?: Inscription
+  }>({
+    address: '',
+    domain: '',
+    inscription: undefined,
+  })
+
+  const [error, setError] = useState('')
+
+  const currentAccount = useCurrentAccount()
+
+  const tools = useTools()
+
+  const { feeRate } = useFeeRateBar()
+
+  useEffect(() => {
+    setError('')
+    setDisabled(true)
+
+    if (!isValidAddress(toInfo.address)) {
+      return
+    }
+
+    if (feeRate <= 0) {
+      return
+    }
+
+    setDisabled(false)
+  }, [toInfo, feeRate])
+
+  const transferData = useRef<{
+    id: string
+    toSignData: ToSignData
+  }>({
+    id: '',
+    toSignData: null,
+  })
+
+  const [step, setStep] = useState(0)
+
+  const prepareSendAlkanes = usePrepareSendAlkanesCallback()
+  const pushBitcoinTx = usePushBitcoinTxCallback()
+
+  const onCreateTxHandleConfirm = async () => {
+    tools.showLoading(true)
+    try {
+      const toSignData = await prepareSendAlkanes(toInfo, alkanesInfo.alkaneid, '1', feeRate, 'nft')
+      if (toSignData) {
+        transferData.current.toSignData = toSignData
+        setStep(1)
+      }
+    } catch (e) {
+      const msg = (e as any).message
+      setError((e as any).message)
+    } finally {
+      tools.showLoading(false)
+    }
+  }
+
+  const onCreateTxHandleBack = () => {
+    nav.goBack()
+  }
+
+  const onSignPsbtHandleConfirm = async (signedDatas: SignedData[]) => {
+    tools.showLoading(true)
+    try {
+      const { success, txid, error } = await pushBitcoinTx(signedDatas[0].psbtHex)
+      if (success) {
+        nav.navigate('TxSuccessScreen', { txid })
+      } else {
+        throw new Error(error)
+      }
+    } catch (e) {
+      nav.navigate('TxFailScreen', { error: (e as any).message })
+    } finally {
+      tools.showLoading(false)
+    }
+  }
+
+  const onSignPsbtHandleCancel = () => {
+    setStep(SendAlkanesNFTScreenStep.CREATE_TX)
+  }
+
+  const onSignPsbtHandleBack = () => {
+    setStep(SendAlkanesNFTScreenStep.CREATE_TX)
+  }
+
+  const signPsbtParams: SignPsbtParams = {
+    data: {
+      toSignDatas: [transferData.current.toSignData],
+    },
+  }
+
+  return {
+    step,
+    t,
+    alkanesInfo,
+    toInfo,
+    disabled,
+    error,
+    setToInfo,
+
+    onCreateTxHandleConfirm,
+    onCreateTxHandleBack,
+
+    onSignPsbtHandleConfirm,
+    onSignPsbtHandleCancel,
+    onSignPsbtHandleBack,
+    signPsbtParams,
+  }
+}