@unisat/wallet-state 1.0.5 → 1.2.0

package/src/ui-hooks/useAnnouncementCardLogic.ts

@@ -0,0 +1,91 @@
+import { Announcement, AnnouncementLinkType } from '@unisat/wallet-shared'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useStorage, useWallet } from 'src/context'
+
+const AUTO_PLAY_INTERVAL = 5000
+
+export function useAnnouncementCardLogic() {
+  const wallet = useWallet()
+  const storage = useStorage()
+
+  const [activeIndex, setActiveIndex] = useState(0)
+  const [dismissedIds, setDismissedIds] = useState<string[]>([])
+  const [announcements, setAnnouncements] = useState<Announcement[]>([])
+  const [loading, setLoading] = useState(false)
+  const [dismissedLoaded, setDismissedLoaded] = useState(false)
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null)
+
+  useEffect(() => {
+    const init = async () => {
+      try {
+        await loadDismissedIds()
+        await fetchAnnouncements()
+      } finally {
+        setDismissedLoaded(true)
+      }
+    }
+    init()
+  }, [])
+
+  const fetchAnnouncements = async () => {
+    try {
+      const response = await wallet.getAnnouncements(0, 10)
+      setAnnouncements(Array.isArray(response?.list) ? response.list : [])
+    } catch {
+      setAnnouncements([])
+    }
+  }
+
+  const loadDismissedIds = async () => {
+    const saved = await storage.getAnnouncementDismissedIds()
+    setDismissedIds(saved)
+  }
+
+  const validAnnouncements = useMemo(
+    () =>
+      announcements.filter(a => {
+        const now = Date.now()
+        return now >= a.startTime && now <= a.endTime && !dismissedIds.includes(a.id)
+      }),
+    [announcements, dismissedIds],
+  )
+
+  // Auto-play: hook is the single timing authority
+  useEffect(() => {
+    if (validAnnouncements.length <= 1) return undefined
+    timerRef.current = setInterval(() => {
+      setActiveIndex(prev => (prev + 1) % validAnnouncements.length)
+    }, AUTO_PLAY_INTERVAL)
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current)
+    }
+  }, [validAnnouncements.length])
+
+  const handleDotClick = useCallback((index: number) => {
+    setActiveIndex(index)
+  }, [])
+
+  const handleDismissAll = useCallback(async () => {
+    const ids = validAnnouncements.map(a => a.id)
+    if (ids.length === 0) return
+    const newIds = [...dismissedIds, ...ids]
+    setDismissedIds(newIds)
+    await storage.setAnnouncementDismissedIds(newIds)
+  }, [validAnnouncements, dismissedIds, storage])
+
+  const isLinkable = useCallback((announcement: Announcement) => {
+    return announcement.linkType !== AnnouncementLinkType.NONE && !!announcement.link
+  }, [])
+
+  const current = validAnnouncements[activeIndex] ?? validAnnouncements[0]
+
+  return {
+    loading,
+    validAnnouncements,
+    current,
+    activeIndex,
+    handleDotClick,
+    handleDismissAll,
+    isLinkable,
+  }
+}

package/src/ui-hooks/useBRC20BalanceCardLogic.ts

@@ -0,0 +1,115 @@
+import { AddressTokenSummary, TickPriceItem, TokenBalance } from '@unisat/wallet-shared'
+import BigNumber from 'bignumber.js'
+import { useMemo, useState } from 'react'
+import { useI18n } from 'src/context'
+import { useBRC20IconInfo, useChain, useCurrentAccount } from 'src/hooks'
+
+export interface BRC20BalanceCardProps {
+  tokenBalance: TokenBalance
+  onClick?: () => void
+  price?: TickPriceItem
+}
+export function useBRC20BalanceCardLogic(props: BRC20BalanceCardProps) {
+  const {
+    price,
+    tokenBalance: {
+      ticker,
+      overallBalance,
+      transferableBalance,
+      selfMint,
+      displayName,
+      tag,
+      swapBalance,
+      progBalance,
+    },
+    onClick,
+  } = props
+
+  const account = useCurrentAccount()
+  const [tokenSummary, setTokenSummary] = useState<AddressTokenSummary>()
+
+  const { t } = useI18n()
+
+  const deploy_count = tokenSummary ? (tokenSummary.tokenInfo.holder == account.address ? 1 : 0) : 0
+  let _names: string[] = []
+  const _amounts: string[] = []
+  if (deploy_count > 0) {
+    _names.push('Deploy')
+    _amounts.push('')
+  }
+  if (tokenSummary) {
+    tokenSummary.transferableList.forEach(v => {
+      _names.push('Transfer')
+      _amounts.push(v.amount)
+    })
+  }
+
+  for (let i = 0; i < _names.length; i++) {
+    if (i == 3) {
+      if (_names.length > 4) {
+        if (deploy_count > 0) {
+          _names[i] = `${_names.length - 3}+`
+        } else {
+          _names[i] = `${_names.length - 2}+`
+        }
+        _amounts[i] = ''
+      }
+      break
+    }
+  }
+  _names = _names.splice(0, 4)
+
+  const onSwapBalance = swapBalance
+  const onProgBalance = progBalance
+  const inWalletBalance = overallBalance
+
+  const totalBalance = useMemo(() => {
+    return new BigNumber(inWalletBalance)
+      .plus(new BigNumber(onSwapBalance || 0))
+      .plus(new BigNumber(onProgBalance || 0))
+      .toString()
+  }, [inWalletBalance, onSwapBalance, onProgBalance])
+
+  let hasOutWalletBalance = false
+  if (onSwapBalance && onSwapBalance !== '0') {
+    hasOutWalletBalance = true
+  }
+  if (onProgBalance && onProgBalance !== '0') {
+    hasOutWalletBalance = true
+  }
+
+  // icon
+  const iconInfo = useBRC20IconInfo(ticker)
+
+  // price
+  const chain = useChain()
+  const showPrice = chain.showPrice
+
+  return {
+    // info
+    ticker,
+    displayName,
+    selfMint,
+    tag,
+
+    // icon
+    iconInfo,
+
+    // balance
+    totalBalance,
+    hasOutWalletBalance,
+    onProgBalance,
+    inWalletBalance,
+    onSwapBalance,
+
+    // price
+    price,
+    showPrice,
+
+    // click
+    onClick,
+
+    // others
+    t,
+  }
+}

package/src/ui-hooks/useBRC20InscribeTransferLogic.ts

@@ -0,0 +1,418 @@
+import { numUtils } from '@unisat/base-utils'
+import {
+  InscribeOrder,
+  SignedData,
+  SignPsbtParams,
+  TokenBalance,
+  TokenInfo,
+  ToSignData,
+} from '@unisat/wallet-shared'
+import BigNumber from 'bignumber.js'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useApproval, useI18n, useNavigation, useTools, useWallet } from 'src/context'
+import {
+  useBTCUnit,
+  useCurrentAccount,
+  useFeeRateBar,
+  useFetchUtxosCallback,
+  usePrepareSendBypassHeadOffsetsCallback,
+  usePushBitcoinTxCallback,
+  useUpdateFeeRateBar,
+} from 'src/hooks'
+import { getAddressUtxoDust } from 'src/utils/bitcoin-utils'
+
+enum Step {
+  STEP1,
+  STEP2,
+  STEP3,
+  STEP4,
+}
+
+interface ContextData {
+  step: Step
+  ticker: string
+  session?: any
+  tokenBalance?: TokenBalance
+  order?: InscribeOrder
+  toSignData?: ToSignData
+  amount?: string
+  isApproval: boolean
+  tokenInfo?: TokenInfo
+  amountEditable?: boolean
+  enableRBF: boolean
+}
+
+interface UpdateContextDataParams {
+  step?: Step
+  ticket?: string
+  session?: any
+  tokenBalance?: TokenBalance
+  order?: InscribeOrder
+  toSignData?: ToSignData
+  amount?: string
+  tokenInfo?: TokenInfo
+  amountEditable?: boolean
+  enableRBF?: boolean
+}
+
+export interface BRC20InscribeTransferParams {
+  contextData: ContextData
+  updateContextData: (params: UpdateContextDataParams) => void
+}
+
+export function useBRC20InscribeTransferLogic() {
+  const nav = useNavigation()
+  const { ticker } = nav.getRouteState<'BRC20InscribeTransfer'>()
+
+  const [contextData, setContextData] = useState<ContextData>({
+    step: Step.STEP1,
+    ticker: ticker,
+    isApproval: false,
+    enableRBF: true,
+  })
+  const updateContextData = useCallback((params: UpdateContextDataParams) => {
+    setContextData(prev => Object.assign({}, prev, params))
+  }, [])
+  return {
+    contextData,
+    updateContextData,
+  }
+}
+
+export function useBRC20InscribeTransferLogicStep1(params: BRC20InscribeTransferParams) {
+  const { contextData, updateContextData } = params
+  const { t } = useI18n()
+  const nav = useNavigation()
+
+  const { rejectApproval } = useApproval()
+
+  const handleCancel = () => {
+    rejectApproval(t('user_rejected_the_request'))
+  }
+
+  const wallet = useWallet()
+  const account = useCurrentAccount()
+  const feeRateBarState = useFeeRateBar()
+  const updateFeeRateBar = useUpdateFeeRateBar()
+  const [inputAmount, setInputAmount] = useState('')
+
+  const tools = useTools()
+  const prepareSendBypassHeadOffsets = usePrepareSendBypassHeadOffsetsCallback()
+
+  const fetchUtxos = useFetchUtxosCallback()
+
+  const [loading, setLoading] = useState(true)
+  const [loadingOnly, setLoadingOnly] = useState(false)
+  const [inputError, setInputError] = useState('')
+  const [inputErrorAvailable, setInputErrorAvailable] = useState('')
+
+  const [disabled, setDisabled] = useState(true)
+
+  const [inputDisabled, setInputDisabled] = useState(false)
+
+  const defaultOutputValue = 546
+  // const defaultOutputValue = getAddressUtxoDust(account.address);
+
+  const [outputValue, setOutputValue] = useState<number>(defaultOutputValue)
+
+  useEffect(() => {
+    if (contextData.amount) {
+      setInputAmount(contextData.amount.toString())
+      setInputDisabled(true)
+    }
+  }, [])
+
+  useEffect(() => {
+    wallet.getEnableRBF().then(enableRBF => {
+      updateContextData({ enableRBF })
+    })
+  }, [])
+
+  useEffect(() => {
+    setInputError('')
+    setInputErrorAvailable('')
+    setDisabled(true)
+    if (!inputAmount) {
+      return
+    }
+
+    if (inputAmount.split('.').length > 1) {
+      const decimal = inputAmount.split('.')[1].length
+      const token_decimal = contextData.tokenInfo?.decimal || 0
+      if (decimal > token_decimal) {
+        setInputError(
+          `${t('this_token_only_supports_up_to')} ${token_decimal} ${t('decimal_places')}`
+        )
+        return
+      }
+    }
+
+    const amount = new BigNumber(inputAmount)
+    if (!amount) {
+      return
+    }
+
+    if (!contextData.tokenBalance) {
+      return
+    }
+
+    if (amount.lte(0)) {
+      return
+    }
+
+    if (amount.gt(contextData.tokenBalance.availableBalanceSafe)) {
+      setInputErrorAvailable(t('insufficient_balance'))
+      return
+    }
+
+    if (feeRateBarState.feeRate <= 0) {
+      return
+    }
+
+    const dust = getAddressUtxoDust(account.address)
+    if (outputValue < dust) {
+      setInputError(`${t('output_value_must_be_at_least')} ${dust}`)
+      return
+    }
+
+    if (!outputValue) {
+      return
+    }
+
+    setDisabled(false)
+  }, [inputAmount, feeRateBarState.feeRate, outputValue, contextData.tokenBalance])
+
+  useEffect(() => {
+    fetchUtxos()
+
+    wallet
+      .getBRC20Summary({
+        address: account.address,
+        ticker: contextData.ticker,
+      })
+      .then(v => {
+        updateContextData({ tokenBalance: v.tokenBalance, tokenInfo: v.tokenInfo })
+        setTimeout(() => {
+          setLoading(false)
+        }, 100)
+      })
+      .catch(e => {
+        tools.toastError(e.message)
+      })
+  }, [])
+
+  const onClickInscribe = async () => {
+    try {
+      tools.showLoading(true)
+      const amount = inputAmount
+      const order = await wallet.inscribeBRC20Transfer(
+        account.address,
+        contextData.ticker,
+        amount,
+        feeRateBarState.feeRate,
+        outputValue
+      )
+
+      const toSignData = await prepareSendBypassHeadOffsets({
+        toAddressInfo: { address: order.payAddress, domain: '' },
+        toAmount: order.totalFee,
+        feeRate: feeRateBarState.feeRate,
+        enableRBF: contextData.enableRBF,
+      })
+      updateContextData({ order, amount, toSignData, step: Step.STEP2 })
+    } catch (e) {
+      tools.toastError((e as Error).message.replace('Error:', ''))
+    } finally {
+      tools.showLoading(false)
+    }
+  }
+
+  return {
+    onClickInscribe,
+    loading,
+    t,
+    nav,
+    inputAmount,
+    inputError,
+    setInputAmount,
+    inputDisabled,
+    inputErrorAvailable,
+    defaultOutputValue,
+    setOutputValue,
+    disabled,
+    enableRBF: contextData.enableRBF,
+    setEnableRBF: (value: boolean) => {
+      updateContextData({ enableRBF: value })
+      wallet.setEnableRBF(value)
+    },
+    loadingOnly,
+    handleCancel,
+  }
+}
+
+export function useBRC20InscribeTransferLogicStep2(params: BRC20InscribeTransferParams) {
+  const { contextData } = params
+  const { order, tokenBalance, amount, toSignData, session } = contextData
+  const btcUnit = useBTCUnit()
+  const { t } = useI18n()
+
+  if (!order || !tokenBalance || !toSignData) {
+    return {
+      isEmpty: true,
+      networkFee: '0',
+      outputValue: '0',
+      minerFee: '0',
+      originServiceFee: '0',
+      serviceFee: '0',
+      totalFee: '0',
+      btcUnit,
+      t,
+      session,
+      amount,
+      tokenBalance,
+    }
+  }
+
+  const fee = toSignData.estimatedFee || 0
+  const networkFee = useMemo(() => numUtils.satoshisToAmount(fee), [fee])
+  const outputValue = useMemo(
+    () => numUtils.satoshisToAmount(order.outputValue),
+    [order.outputValue]
+  )
+  const minerFee = useMemo(() => numUtils.satoshisToAmount(order.minerFee + fee), [order.minerFee])
+  const originServiceFee = useMemo(
+    () => numUtils.satoshisToAmount(order.originServiceFee),
+    [order.originServiceFee]
+  )
+  const serviceFee = useMemo(() => numUtils.satoshisToAmount(order.serviceFee), [order.serviceFee])
+  const totalFee = useMemo(() => numUtils.satoshisToAmount(order.totalFee + fee), [order.totalFee])
+
+  return {
+    networkFee,
+    outputValue,
+    minerFee,
+    originServiceFee,
+    serviceFee,
+    totalFee,
+    btcUnit,
+    t,
+    session,
+    amount,
+    tokenBalance,
+    order,
+    toSignData,
+  }
+}
+
+export function useBRC20InscribeTransferLogicStep3(params: BRC20InscribeTransferParams) {
+  const { contextData, updateContextData } = params
+
+  const pushBitcoinTx = usePushBitcoinTxCallback()
+  const nav = useNavigation()
+
+  const onHeaderBack = () => {
+    updateContextData({
+      step: Step.STEP2,
+    })
+  }
+
+  const onSignPsbtHandleCancel = () => {
+    updateContextData({
+      step: Step.STEP2,
+    })
+  }
+  const signPsbtParams: SignPsbtParams = {
+    data: {
+      toSignDatas: [contextData.toSignData!],
+    },
+  }
+
+  const tools = useTools()
+  const onSignPsbtHandleConfirm = async (signedDatas: SignedData[]) => {
+    tools.showLoading(true)
+    try {
+      const { success, error } = await pushBitcoinTx(signedDatas[0].psbtHex)
+      if (success) {
+        updateContextData({
+          step: Step.STEP4,
+        })
+      } else {
+        throw new Error(error)
+      }
+      return
+    } catch (e) {
+      nav.navigate('TxFailScreen', { error: (e as any).message })
+    } finally {
+      tools.showLoading(false)
+    }
+  }
+
+  return {
+    signPsbtParams,
+    onSignPsbtHandleConfirm,
+    onSignPsbtHandleCancel,
+    onHeaderBack,
+  }
+}
+
+export function useBRC20InscribeTransferLogicStep4(params: BRC20InscribeTransferParams) {
+  const { contextData } = params
+  const { tokenBalance, order } = contextData
+  const tools = useTools()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const { resolveApproval, rejectApproval } = useApproval()
+  const nav = useNavigation()
+  const [result, setResult] = useState<any>()
+  const { t } = useI18n()
+  const checkResult = async () => {
+    const result = await wallet.getInscribeResult(order.orderId)
+    if (!result) {
+      setTimeout(() => {
+        checkResult()
+      }, 2000)
+      return
+    }
+    tools.showLoading(false)
+    setResult(result)
+  }
+
+  useEffect(() => {
+    checkResult()
+  }, [])
+
+  const onClickConfirm = () => {
+    tools.showLoading(true)
+    wallet
+      .getBRC20Summary({
+        address: currentAccount.address,
+        ticker: tokenBalance.ticker,
+      })
+      .then(v => {
+        if (contextData.isApproval) {
+          resolveApproval({
+            inscriptionId: result.inscriptionId,
+            inscriptionNumber: result.inscriptionNumber,
+            ticker: tokenBalance.ticker,
+            amount: result.amount,
+          })
+        } else {
+          nav.navigate('BRC20SendScreen', {
+            tokenBalance: v.tokenBalance,
+            selectedInscriptionIds: [result.inscriptionId],
+            selectedAmount: result.amount,
+            tokenInfo: v.tokenInfo,
+          })
+        }
+      })
+      .finally(() => {
+        tools.showLoading(false)
+      })
+  }
+
+  return {
+    t,
+    result,
+    onClickConfirm,
+  }
+}

package/src/ui-hooks/useBRC20ListLogic.ts

@@ -0,0 +1,79 @@
+import { TickPriceItem, TokenBalance } from '@unisat/wallet-shared'
+import { useEffect, useRef, useState } from 'react'
+import {
+  OrdinalsAssetTabKey,
+  useChainType,
+  useCurrentAccount,
+  useNavigation,
+  useOrdinalsAssetTabKey,
+  useWallTabFocusRefresh,
+  useWallet,
+} from '..'
+import { useInfiniteList } from './useInfiniteList'
+
+export function useBRC20ListLogic() {
+  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<TokenBalance>({
+    fetcher: async (page, pageSize) => {
+      if (currentAccount.address === '') {
+        return { list: [], total: 0 }
+      }
+      const { list, total } = await wallet.getBRC20List({
+        address: currentAccount.address,
+        currentPage: page,
+        pageSize,
+      })
+      if (list.length > 0) {
+        wallet.getBrc20sPrice(list.map(item => item.ticker)).then(updatePrices)
+      }
+      return { list, total }
+    },
+    dependencies: [currentAccount.address, chainType],
+  })
+
+  const tabKey = useOrdinalsAssetTabKey()
+  const isFocus = tabKey === OrdinalsAssetTabKey.BRC20
+  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: TokenBalance) => {
+    nav.navigate('BRC20TokenScreen', { tokenBalance: item, ticker: item.ticker })
+  }
+
+  return { items, total, loading, hasMore, onRefresh, onLoadMore, onClickItem, priceMap }
+}