@unisat/wallet-state 1.0.5 → 1.1.0

package/src/ui-hooks/useAlkanesCollectionListLogic.ts

@@ -0,0 +1,68 @@
+import { AlkanesCollection } from '@unisat/wallet-shared'
+
+import { useEffect, useRef } from 'react'
+import {
+  AlkanesAssetTabKey,
+  getSupportedAssets,
+  useAlkanesAssetTabKey,
+  useChainType,
+  useCurrentAccount,
+  useNavigation,
+  useWallet,
+  useWallTabFocusRefresh,
+} from '..'
+import { useInfiniteList } from './useInfiniteList'
+
+export function useAlkanesCollectionListLogic() {
+  const nav = useNavigation()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const chainType = useChainType()
+
+  const {
+    data: items,
+    total,
+    loading,
+    hasMore,
+    onRefresh,
+    onLoadMore,
+  } = useInfiniteList<AlkanesCollection>({
+    fetcher: async (page, pageSize) => {
+      const supportedAssets = getSupportedAssets(chainType, currentAccount.address)
+      if (!supportedAssets.assets.alkanes || currentAccount.address === '') {
+        return { list: [], total: 0 }
+      }
+      const { list, total } = await wallet.getAlkanesCollectionList(
+        currentAccount.address,
+        page,
+        pageSize
+      )
+
+      return { list, total }
+    },
+    dependencies: [currentAccount.address, chainType],
+  })
+
+  const tabKey = useAlkanesAssetTabKey()
+  const isFocus = tabKey === AlkanesAssetTabKey.COLLECTION
+  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: AlkanesCollection) => {
+    nav.navigate('AlkanesCollectionScreen', { collectionId: item.alkaneid })
+  }
+
+  return { items, total, loading, hasMore, onRefresh, onLoadMore, onClickItem }
+}

package/src/ui-hooks/useAlkanesListLogic.ts

@@ -0,0 +1,69 @@
+import { useEffect, useRef, useState } from 'react'
+
+import { AlkanesBalance, TickPriceItem } from '@unisat/wallet-shared'
+
+import {
+  AlkanesAssetTabKey,
+  getSupportedAssets,
+  useAlkanesAssetTabKey,
+  useChainType,
+  useCurrentAccount,
+  useNavigation,
+  useWallet,
+  useWallTabFocusRefresh,
+} from '..'
+import { useInfiniteList } from './useInfiniteList'
+
+export function useAlkanesListLogic() {
+  const nav = useNavigation()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const chainType = useChainType()
+  const [priceMap, setPriceMap] = useState<{ [key: string]: TickPriceItem }>({})
+
+  const {
+    data: items,
+    total,
+    loading,
+    hasMore,
+    onRefresh,
+    onLoadMore,
+  } = useInfiniteList<AlkanesBalance>({
+    fetcher: async (page, pageSize) => {
+      const supportedAssets = getSupportedAssets(chainType, currentAccount.address)
+      if (!supportedAssets.assets.alkanes || currentAccount.address === '') {
+        return { list: [], total: 0 }
+      }
+
+      const { list, total } = await wallet.getAlkanesList(currentAccount.address, page, pageSize)
+      if (list.length > 0) {
+        wallet.getAlkanesPrice(list.map(item => item.alkaneid)).then(setPriceMap)
+      }
+      return { list, total }
+    },
+    dependencies: [currentAccount.address, chainType],
+  })
+
+  const tabKey = useAlkanesAssetTabKey()
+  const isFocus = tabKey === AlkanesAssetTabKey.TOKEN
+  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: AlkanesBalance) => {
+    nav.navigate('AlkanesTokenScreen', { alkaneid: item.alkaneid })
+  }
+
+  return { items, total, loading, hasMore, onRefresh, onLoadMore, onClickItem, priceMap }
+}

package/src/ui-hooks/useAlkanesNFTListLogic.ts

@@ -0,0 +1,42 @@
+import { AlkanesInfo } from '@unisat/wallet-shared'
+
+import { getSupportedAssets, useChainType, useCurrentAccount, useNavigation, useWallet } from '..'
+import { useInfiniteList } from './useInfiniteList'
+
+export function useAlkanesNFTListLogic(collectionId: string) {
+  const nav = useNavigation()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const chainType = useChainType()
+
+  const {
+    data: items,
+    total,
+    loading,
+    hasMore,
+    onRefresh,
+    onLoadMore,
+  } = useInfiniteList<AlkanesInfo>({
+    fetcher: async (page, pageSize) => {
+      const supportedAssets = getSupportedAssets(chainType, currentAccount.address)
+      if (!supportedAssets.assets.alkanes || currentAccount.address === '') {
+        return { list: [], total: 0 }
+      }
+      const { list, total } = await wallet.getAlkanesCollectionItems(
+        currentAccount.address,
+        collectionId,
+        page,
+        pageSize
+      )
+
+      return { list, total }
+    },
+    dependencies: [currentAccount.address, collectionId, chainType],
+  })
+
+  const onClickItem = (item: AlkanesInfo) => {
+    nav.navigate('AlkanesNFTScreen', { alkanesInfo: item })
+  }
+
+  return { items, total, loading, hasMore, onRefresh, onLoadMore, onClickItem }
+}

package/src/ui-hooks/useAlkanesNFTScreenLogic.ts

@@ -0,0 +1,45 @@
+import { useEffect, useState } from 'react'
+import { useI18n, useNavigation, useWallet } from 'src/context'
+import { useResetTxState } from 'src/hooks'
+
+export function useAlkanesNFTScreenLogic() {
+  const nav = useNavigation()
+  const { alkanesInfo } = nav.getRouteState<'AlkanesNFTScreen'>()
+
+  const { t } = useI18n()
+
+  const resetTxState = useResetTxState()
+
+  const [availableUtxo, setAvailableUtxo] = useState(0)
+  const wallet = useWallet()
+
+  useEffect(() => {
+    const fetchData = async () => {
+      const utxos = await wallet.getAssetUtxosAlkanes(alkanesInfo.alkaneid)
+      setAvailableUtxo(utxos.length)
+    }
+    fetchData()
+  }, [wallet])
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  const onClickSend = () => {
+    resetTxState()
+    nav.navigate('SendAlkanesNFTScreen', {
+      alkanesInfo,
+    })
+  }
+
+  const disabledSend = availableUtxo <= 0
+
+  return {
+    alkanesInfo,
+    t,
+    availableUtxo,
+    onClickBack,
+    onClickSend,
+    disabledSend,
+  }
+}

package/src/ui-hooks/useAlkanesTokenScreenLogic.ts

@@ -0,0 +1,130 @@
+import { useEffect, useMemo, useState } from 'react'
+
+import { AddressAlkanesTokenSummary } from '@unisat/wallet-shared'
+import {
+  useAlkanesIconInfo,
+  useCurrentAccount,
+  useI18n,
+  useNavigation,
+  useResetTxState,
+  useTools,
+  useWallet,
+} from '..'
+
+export function useAlkanesTokenScreenLogic() {
+  const nav = useNavigation()
+  const { alkaneid } = nav.getRouteState<'AlkanesTokenScreen'>()
+  const [tokenSummary, setTokenSummary] = useState<AddressAlkanesTokenSummary>({
+    tokenBalance: {
+      alkaneid: '',
+      name: '',
+      amount: '',
+      symbol: '',
+      divisibility: 0,
+      available: '',
+    },
+    tokenInfo: {
+      alkaneid: '',
+      name: '',
+      symbol: '',
+      totalSupply: '10000000000000',
+      maxSupply: '10000000000000',
+      cap: 0,
+      mintable: false,
+      perMint: '0',
+      minted: 0,
+      holders: 0,
+      aligned: true,
+      nftData: {
+        collectionId: '',
+      },
+      logo: '',
+    },
+    tradeUrl: '',
+    mintUrl: '',
+  })
+
+  const wallet = useWallet()
+
+  const account = useCurrentAccount()
+
+  const [loading, setLoading] = useState(true)
+
+  const [warning, setWarning] = useState(false)
+
+  const { t } = useI18n()
+
+  useEffect(() => {
+    wallet.getAddressAlkanesTokenSummary(account.address, alkaneid, false).then(tokenSummary => {
+      setTokenSummary(tokenSummary)
+      setLoading(false)
+    })
+  }, [])
+
+  const resetTxState = useResetTxState()
+
+  const enableMint = useMemo(() => {
+    return tokenSummary.mintUrl && tokenSummary.mintUrl.trim() !== ''
+  }, [tokenSummary.mintUrl])
+
+  const enableTransfer = useMemo(() => {
+    let enable = false
+    if (tokenSummary.tokenBalance.amount !== '0') {
+      enable = true
+    }
+    return enable
+  }, [tokenSummary])
+
+  const tools = useTools()
+
+  const enableTrade = useMemo(() => {
+    return tokenSummary.tradeUrl && tokenSummary.tradeUrl.trim() !== ''
+  }, [tokenSummary.tradeUrl])
+
+  const onClickMint = () => {
+    if (tokenSummary.mintUrl) {
+      nav.navToUrl(tokenSummary.mintUrl)
+    }
+  }
+
+  const onClickSend = () => {
+    if (tokenSummary.tokenInfo?.aligned === false) {
+      // tools.toastError(t('important_to_not_transfer_this_token'));
+      setWarning(true)
+      return
+    }
+
+    resetTxState()
+    nav.navigate('SendAlkanesScreen', {
+      tokenBalance: tokenSummary.tokenBalance,
+      tokenInfo: tokenSummary.tokenInfo,
+    })
+  }
+
+  const onClickTrade = () => {
+    if (tokenSummary.tradeUrl) {
+      nav.navToUrl(tokenSummary.tradeUrl)
+    }
+  }
+
+  const iconInfo = useAlkanesIconInfo(
+    tokenSummary.tokenBalance.name,
+    tokenSummary.tokenBalance.alkaneid
+  )
+
+  return {
+    tokenSummary,
+    loading,
+    enableMint,
+    enableTransfer,
+    enableTrade,
+    warning,
+    setWarning,
+    t,
+    tools,
+    onClickMint,
+    onClickSend,
+    onClickTrade,
+    iconInfo,
+  }
+}

package/src/ui-hooks/useAmountInputLogic.ts

@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+export interface AmountInputProps {}
+
+export function useAmountInputLogic(props: {
+  value?: string
+  runesDecimal?: number
+  disableDecimal?: boolean
+  enableBrc20Decimal?: boolean
+  onAmountInputChange?: (amount: string) => void
+
+  min?: number
+  step?: number
+}) {
+  const { disableDecimal, enableBrc20Decimal, runesDecimal, onAmountInputChange, min, step } = props
+
+  const [inputValue, setInputValue] = useState(props.value || '')
+
+  useEffect(() => {
+    onAmountInputChange(inputValue)
+  }, [inputValue])
+
+  const propValueRef = useRef(props.value)
+  useEffect(() => {
+    if (props.value !== propValueRef.current) {
+      propValueRef.current = props.value
+      setInputValue(props.value || '')
+    }
+  }, [props.value])
+
+  const handleInputAmount = useCallback(
+    (e: { target: { value: string } } | string) => {
+      const raw = typeof e === 'string' ? e : e.target.value
+
+      let regex: RegExp
+      if (disableDecimal) {
+        regex = /^[1-9]\d*$/
+      } else if (enableBrc20Decimal) {
+        regex = /^(0(\.\d{0,18})?|[1-9]\d*\.?\d{0,18})$/
+      } else if (runesDecimal !== undefined) {
+        regex = new RegExp(`^(0(\\.\\d{0,${runesDecimal}})?|[1-9]\\d*\\.?\\d{0,${runesDecimal}})$`)
+      } else {
+        regex = /^(0(\.\d{0,8})?|[1-9]\d*\.?\d{0,8})$/
+      }
+
+      if (regex.test(raw) || raw === '') {
+        setInputValue(raw)
+      }
+    },
+    [disableDecimal, enableBrc20Decimal, runesDecimal]
+  )
+
+  const handleStepUp = useCallback(() => {
+    setInputValue(prev => {
+      const currentVal = parseFloat(prev) || 0
+      const decimal = runesDecimal ?? 2
+      return (currentVal + step).toFixed(decimal)
+    })
+  }, [step, runesDecimal])
+
+  const handleStepDown = useCallback(() => {
+    setInputValue(prev => {
+      const currentVal = parseFloat(prev) || 0
+      const decimal = runesDecimal ?? 2
+      return Math.max(min, currentVal - step).toFixed(decimal)
+    })
+  }, [step, min, runesDecimal])
+
+  const handleReset = useCallback(() => {
+    setInputValue('')
+  }, [])
+
+  return {
+    handleInputAmount,
+    handleStepUp,
+    handleStepDown,
+    handleReset,
+    inputValue,
+  }
+}

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,
+  }
+}