@unisat/wallet-state 1.0.5 → 1.2.0

package/src/ui-hooks/useSignPsbtLogic.ts

@@ -0,0 +1,517 @@
+import { numUtils } from '@unisat/base-utils'
+import { KeyringType, ToSignInput } from '@unisat/keyring-service/types'
+import {
+  ApprovalSession,
+  ContractResult,
+  DecodedPsbt,
+  LocalPsbtSummary,
+  SignedData,
+  SignState,
+  TickPriceItem,
+  ToSignData,
+  WebsiteResult,
+} from '@unisat/wallet-shared'
+import logger from 'loglevel'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useApproval, useI18n, useTools, useWallet } from 'src/context'
+import { useCurrentAccount } from 'src/hooks'
+import { useAsyncEffect } from 'src/utils/ui-utils'
+
+interface InscriptionInfo {
+  id: string
+  isSent: boolean
+}
+
+export interface TxInfo {
+  changedBalance: number
+  changedInscriptions: InscriptionInfo[]
+  rawtx: string
+  psbtHex: string
+  toSignInputs: ToSignInput[]
+  txError: string
+  decodedPsbt: DecodedPsbt
+  contractResults: ContractResult[]
+}
+
+export const initTxInfo: TxInfo = {
+  changedBalance: 0,
+  changedInscriptions: [],
+  rawtx: '',
+  psbtHex: '',
+  toSignInputs: [],
+  txError: '',
+  decodedPsbt: {
+    inputInfos: [],
+    outputInfos: [],
+    fee: 0,
+    feeRate: 0,
+    risks: [],
+    features: {
+      rbf: false,
+    },
+    inscriptions: {},
+    isScammer: false,
+    shouldWarnFeeRate: false,
+    recommendedFeeRate: 1,
+    isCompleted: false,
+  },
+  contractResults: [],
+}
+
+export interface SignPsbtProps {
+  header?: React.ReactNode
+  params: {
+    data: {
+      toSignDatas: ToSignData[]
+    }
+    session?: ApprovalSession
+  }
+  handleCancel?: () => void
+  handleConfirm?: (signedDatas: SignedData[]) => void
+  fromApproval?: boolean
+}
+
+export function useSignPsbtLogic(props: SignPsbtProps) {
+  const {
+    params: {
+      data: { toSignDatas },
+      session,
+    },
+    handleCancel,
+    handleConfirm,
+  } = props
+  const { resolveApproval, rejectApproval } = useApproval()
+
+  const [loading, setLoading] = useState(false)
+  const [isPsbtSigning, setIsPsbtSigning] = useState(false)
+  const [isPsbtRiskPopoverVisible, setIsPsbtRiskPopoverVisible] = useState(false)
+  const [isKeystoneSigning, setIsKeystoneSigning] = useState(false)
+  const [isColdWalletSigning, setIsColdWalletSigning] = useState(false)
+
+  const [contractPopoverData, setContractPopoverData] = useState(undefined)
+
+  const wallet = useWallet()
+  const tools = useTools()
+  const currentAccount = useCurrentAccount()
+  const keyringType = currentAccount.type
+
+  const { t } = useI18n()
+
+  const [disclaimerVisible, setDisclaimerVisible] = useState(false)
+  const [localPsbtSummary, setLocalPsbtSummary] = useState<LocalPsbtSummary | null>(null)
+
+  const [signingTxIndex, setSigningTxIndex] = useState(toSignDatas.length > 1 ? -1 : 0)
+  const [signedStates, setSignedStates] = useState<SignState[]>(
+    toSignDatas.map(() => SignState.PENDING)
+  )
+
+  const [websiteResult, setWebsiteResult] = useState<WebsiteResult>({
+    isScammer: false,
+    warning: '',
+    allowQuickMultiSign: false,
+  })
+
+  const isMultipleViewMode = toSignDatas.length > 1
+
+  const [allowQuickMultiSign, setAllowQuickMultiSign] = useState(false)
+
+  //
+
+  useEffect(() => {
+    if (toSignDatas.length <= 1) {
+      return
+    }
+
+    if (
+      keyringType === KeyringType.KeystoneKeyring ||
+      keyringType === KeyringType.ColdWalletKeyring
+    ) {
+      return
+    }
+
+    setAllowQuickMultiSign(websiteResult.allowQuickMultiSign && toSignDatas.length > 1)
+  }, [websiteResult, keyringType])
+
+  useAsyncEffect(async () => {
+    const website = session?.origin
+    if (website) {
+      const result = await wallet.checkWebsite(website)
+      setWebsiteResult(result)
+
+      // Also check local user-granted trust
+      if (!result.allowQuickMultiSign && toSignDatas.length > 1) {
+        const sites = await wallet.getConnectedSites()
+        const site = sites.find(s => s.origin === website)
+        if (site?.allowQuickMultiSign) {
+          setAllowQuickMultiSign(true)
+        }
+      }
+    }
+  }, [])
+
+  const currentToSignData = toSignDatas[signingTxIndex]
+
+  const signedDatas = useRef<SignedData[]>([])
+
+  const decodedPsbtDatas = useRef<DecodedPsbt[]>([])
+  useAsyncEffect(async () => {
+    if (decodedPsbtDatas.current[signingTxIndex]) {
+      return
+    }
+    if (!currentToSignData) {
+      return
+    }
+    try {
+      setLoading(true)
+
+      const decodedPsbt = await wallet.decodePsbt(currentToSignData.psbtHex, session?.origin || '')
+      decodedPsbtDatas.current[signingTxIndex] = decodedPsbt
+    } catch (e) {
+      logger.error('Failed to decode PSBT data:', e)
+    } finally {
+      setLoading(false)
+    }
+  }, [signingTxIndex, currentToSignData])
+
+  const currentDecodedPsbt = decodedPsbtDatas.current[signingTxIndex]
+
+  const [brc20PriceMap, setBrc20PriceMap] = useState<Record<string, TickPriceItem>>()
+  const [runesPriceMap, setRunesPriceMap] = useState<Record<string, TickPriceItem>>()
+
+  useEffect(() => {
+    if (!currentDecodedPsbt?.inputInfos) return
+
+    const runesMap = {}
+    const brc20Map = {}
+
+    // collect asset information
+    currentDecodedPsbt.inputInfos.forEach(v => {
+      if (v.runes) {
+        v.runes.forEach(w => {
+          runesMap[w.spacedRune] = true
+        })
+      }
+
+      if (v.inscriptions) {
+        v.inscriptions.forEach(w => {
+          const inscription = currentDecodedPsbt.inscriptions[w.inscriptionId]
+          if (inscription && inscription.brc20) {
+            brc20Map[inscription.brc20.tick] = true
+          }
+        })
+      }
+    })
+
+    // get asset price
+    if (Object.keys(runesMap).length > 0) {
+      wallet
+        .getRunesPrice(Object.keys(runesMap))
+        .then(setRunesPriceMap)
+        .catch(e => tools.toastError(e.message))
+    }
+
+    if (Object.keys(brc20Map).length > 0) {
+      wallet
+        .getBrc20sPrice(Object.keys(brc20Map))
+        .then(setBrc20PriceMap)
+        .catch(e => tools.toastError(e.message))
+    }
+  }, [currentDecodedPsbt])
+
+  const networkFee = currentDecodedPsbt ? numUtils.satoshisToAmount(currentDecodedPsbt.fee) : '0'
+  const isValid = currentDecodedPsbt ? currentDecodedPsbt.inputInfos.length > 0 : false
+  const hasRisk = currentDecodedPsbt ? currentDecodedPsbt.risks.length > 0 : false
+
+  let showFeeSection = false
+  if (currentDecodedPsbt && currentDecodedPsbt.isCompleted) {
+    showFeeSection = true
+  }
+
+  let isScammer = false
+  if (currentDecodedPsbt && currentDecodedPsbt.isScammer == true) {
+    isScammer = true
+  }
+  if (websiteResult && websiteResult.isScammer == true) {
+    isScammer = true
+  }
+
+  const isAllSigned = signedStates.every(state => state === SignState.SUCCESS)
+  const signedCount = signedStates.filter(state => state === SignState.SUCCESS).length
+
+  const defaultHandleCancel = () => rejectApproval()
+  const actualHandleCancel = handleCancel || defaultHandleCancel
+
+  const multiSignList = useMemo(() => {
+    return toSignDatas.map((data, index) => {
+      const signState = signedStates[index]
+      let buttonText = 'View'
+      if (signState == SignState.PENDING) {
+        buttonText = t('view')
+      } else if (signState == SignState.SUCCESS) {
+        buttonText = t('signed')
+      } else if (signState == SignState.FAILED) {
+        buttonText = t('reject')
+      }
+
+      let buttonPreset = 'primary'
+      if (signState === SignState.SUCCESS) {
+        buttonPreset = 'approval'
+      } else if (signState === SignState.FAILED) {
+        buttonPreset = 'danger'
+      }
+
+      const psbtInfo = localPsbtSummary?.items?.[index]
+
+      const onClick = () => {
+        setSigningTxIndex(index)
+      }
+      return {
+        index,
+        buttonText,
+        buttonPreset,
+        psbtInfo,
+        onClick,
+      }
+    })
+  }, [toSignDatas, signedStates, localPsbtSummary, t])
+
+  // action
+  const onClickBack = () => {
+    if (isMultipleViewMode && signingTxIndex != -1) {
+      // back to multi sign view
+      setSigningTxIndex(-1)
+      setIsPsbtRiskPopoverVisible(false)
+      return
+    }
+    actualHandleCancel()
+  }
+
+  const onClickSign = () => {
+    if (currentDecodedPsbt?.risks?.length > 0) {
+      setIsPsbtRiskPopoverVisible(true)
+      return
+    }
+    onNextStep()
+  }
+
+  useAsyncEffect(async () => {
+    if (toSignDatas.length <= 1) return
+    try {
+      const summary = await wallet.analyzeLocalPsbts(toSignDatas)
+      setLocalPsbtSummary(summary)
+    } catch (e) {
+      logger.error('analyzeLocalPsbts failed:', e)
+    }
+  }, [])
+
+  const onTryMultiSign = async () => {
+    setDisclaimerVisible(true)
+  }
+
+  const onTrustSite = async () => {
+    const origin = session?.origin
+    if (!origin) return
+    await wallet.updateConnectSite(origin, { allowQuickMultiSign: true })
+    setAllowQuickMultiSign(true)
+  }
+
+  const onQuickMultiSign = async () => {
+    // Run analysis if not yet done (user clicked before async summary completed)
+
+    try {
+      setIsPsbtSigning(true)
+      // Yield to the JS event loop so the loading UI can render before heavy signing work begins
+      await new Promise<void>(resolve => setTimeout(resolve, 50))
+      const summary = localPsbtSummary ?? (await wallet.analyzeLocalPsbts(toSignDatas))
+      if (!localPsbtSummary) setLocalPsbtSummary(summary)
+
+      if (summary.parseErrorCount > 0) {
+        tools.toastError(t('failed_to_parse_psbt'))
+        return
+      }
+      if (summary.hasSighashNone) {
+        tools.toastError(t('sighash_none_detected'))
+        return
+      }
+      if (summary.hasAssets) {
+        tools.toastError(t('quick_sign_assets_detected'))
+        return
+      }
+
+      for (let i = 0; i < toSignDatas.length; i++) {
+        try {
+          const toSignData = toSignDatas[i]
+          const signedData = await wallet.signPsbtV2(toSignData)
+          onSignedData(signedData, i)
+        } catch (e) {
+          signedStates[i] = SignState.FAILED
+          setSignedStates([...signedStates])
+          tools.toastError(`Signing failed for PSBT ${i}: ${e.message}`)
+        }
+      }
+    } catch (e) {
+    } finally {
+      setIsPsbtSigning(false)
+      setDisclaimerVisible(false)
+    }
+  }
+
+  const localSign = async () => {
+    try {
+      const toSignData = toSignDatas[signingTxIndex]
+      const signedData = await wallet.signPsbtV2(toSignData)
+      onSignedData(signedData, signingTxIndex)
+    } catch (e) {
+      logger.error('Local signing failed:', e)
+      if (e.message.includes('Can not sign for input')) {
+        tools.toastError(t('sign_psbt_input_error'))
+      } else {
+        tools.toastError(e.message)
+      }
+      signedStates[signingTxIndex] = SignState.FAILED
+      setSignedStates([...signedStates])
+    }
+  }
+
+  const onNextStep = () => {
+    if (keyringType === KeyringType.KeystoneKeyring) {
+      setIsKeystoneSigning(true)
+    } else if (keyringType === KeyringType.ColdWalletKeyring) {
+      setIsColdWalletSigning(true)
+    } else {
+      localSign()
+    }
+  }
+
+  const onSignedData = (data: SignedData, signingTxIndex: number) => {
+    signedStates[signingTxIndex] = SignState.SUCCESS
+    setSignedStates([...signedStates])
+
+    signedDatas.current[signingTxIndex] = data
+
+    // single mode
+    if (!isMultipleViewMode) {
+      if (handleConfirm) {
+        handleConfirm(signedDatas.current)
+      } else {
+        resolveApproval(signedDatas.current)
+      }
+      return
+    }
+
+    // multiple mode
+    const isAllSigned = signedStates.every(state => state === SignState.SUCCESS)
+    if (isAllSigned) {
+      if (handleConfirm) {
+        handleConfirm(signedDatas.current)
+      } else {
+        resolveApproval(signedDatas.current)
+      }
+      return
+    } else {
+      setSigningTxIndex(-1)
+      setIsPsbtRiskPopoverVisible(false)
+      return
+    }
+  }
+
+  // keystone
+  const onKeystoneSigningSuccess = (data: SignedData) => {
+    setIsKeystoneSigning(false)
+    onSignedData(data, signingTxIndex)
+  }
+
+  const onKeystoneSigningBack = () => {
+    setIsKeystoneSigning(false)
+  }
+
+  // coldwallet
+  const onColdWalletSigningSuccess = (data: { psbtHex: string; rawtx: string }) => {
+    setIsColdWalletSigning(false)
+    onSignedData(data, signingTxIndex)
+  }
+
+  const onColdWalletSigningBack = () => {
+    setIsColdWalletSigning(false)
+  }
+
+  // risk popover
+  const onRiskPopoverConfirm = () => {
+    setIsPsbtRiskPopoverVisible(false)
+    onNextStep()
+  }
+
+  const onRiskPopoverClose = () => {
+    setIsPsbtRiskPopoverVisible(false)
+  }
+
+  // disclaimer modal
+  const onDisclaimerModalClose = () => {
+    setDisclaimerVisible(false)
+  }
+
+  const showMultiSignView = isMultipleViewMode && signingTxIndex == -1
+
+  const isWaitingData = showMultiSignView == false && (!currentDecodedPsbt || !currentToSignData)
+
+  const showLoading = isWaitingData || loading
+
+  const backButtonText = isMultipleViewMode ? t('back') : t('reject')
+
+  return {
+    isPsbtRiskPopoverVisible,
+    contractPopoverData,
+    setContractPopoverData,
+    t,
+    brc20PriceMap,
+    runesPriceMap,
+    session,
+    isPsbtSigning,
+
+    // page state
+    isKeystoneSigning,
+    isColdWalletSigning,
+    showMultiSignView,
+    showLoading,
+
+    disclaimerVisible,
+    localPsbtSummary,
+
+    // data
+    toSignDatas,
+    currentToSignData,
+    currentDecodedPsbt,
+
+    // state
+    networkFee,
+    isValid,
+    hasRisk,
+    showFeeSection,
+    isScammer,
+    allowQuickMultiSign,
+
+    // multiple sign state
+    isAllSigned,
+    signedCount,
+    multiSignList,
+
+    // actions
+    backButtonText,
+    onClickBack,
+    onClickSign,
+    onQuickMultiSign,
+    onTryMultiSign,
+    onTrustSite,
+
+    onKeystoneSigningSuccess,
+    onKeystoneSigningBack,
+
+    onColdWalletSigningSuccess,
+    onColdWalletSigningBack,
+
+    onRiskPopoverConfirm,
+    onRiskPopoverClose,
+
+    onDisclaimerModalClose,
+  }
+}

package/src/ui-hooks/useSplitOrdinalsInscriptionScreenLogic.ts

@@ -0,0 +1,109 @@
+import { Inscription } from '@unisat/wallet-shared'
+import { useEffect, useState } from 'react'
+import { useI18n, useNavigation, useWallet } from 'src/context'
+import {
+  useCreateSplitTxCallback,
+  useCurrentAccount,
+  useFeeRateBar,
+  useOrdinalsTx,
+} from 'src/hooks'
+import { getAddressUtxoDust } from 'src/utils/bitcoin-utils'
+
+export function useSplitOrdinalsInscriptionScreenLogic() {
+  const nav = useNavigation()
+  const props = nav.getRouteState<'SplitOrdinalsInscriptionScreen'>()
+
+  const inscription = props.inscription
+
+  const [disabled, setDisabled] = useState(true)
+
+  const ordinalsTx = useOrdinalsTx()
+
+  const [error, setError] = useState('')
+  const createSplitTx = useCreateSplitTxCallback()
+
+  const defaultOutputValue = props.inscription ? props.inscription.outputValue : 10000
+  const { t } = useI18n()
+  const account = useCurrentAccount()
+  const minOutputValue = getAddressUtxoDust(account.address)
+  const [outputValue, setOutputValue] = useState(defaultOutputValue)
+  const [enableRBF, setEnableRBF] = useState(true)
+
+  const { feeRate } = useFeeRateBar()
+
+  const [inscriptions, setInscriptions] = useState<Inscription[]>([])
+
+  const [splitedCount, setSplitedCount] = useState(0)
+  const wallet = useWallet()
+  useEffect(() => {
+    wallet.getEnableRBF().then(enableRBF => {
+      setEnableRBF(enableRBF)
+    })
+  }, [wallet])
+
+  useEffect(() => {
+    wallet.getInscriptionUtxoDetail(props.inscription.inscriptionId).then(v => {
+      setInscriptions(v.inscriptions)
+    })
+  }, [])
+
+  const onEnableRBFChange = (value: boolean) => {
+    setEnableRBF(value)
+    wallet.setEnableRBF(value)
+  }
+
+  useEffect(() => {
+    setDisabled(true)
+    setError('')
+    setSplitedCount(0)
+
+    if (feeRate <= 0) {
+      setError(t('invalid_fee_rate'))
+      return
+    }
+
+    if (!outputValue) {
+      return
+    }
+
+    if (outputValue < minOutputValue) {
+      setError(`${t('output_value_must_be_at_least')} ${minOutputValue}`)
+      return
+    }
+
+    setDisabled(false)
+  }, [feeRate, outputValue])
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  const onOutputValueChange = (value: number) => {
+    setOutputValue(value)
+  }
+
+  const onClickNext = () => {
+    createSplitTx({ inscriptionId: inscription.inscriptionId, feeRate, outputValue, enableRBF })
+      .then(toSignData => {
+        nav.navigate('TxConfirmScreen', { toSignData })
+      })
+      .catch(e => {
+        console.log(e)
+        setError(e.message)
+      })
+  }
+
+  return {
+    t,
+    inscriptions,
+    minOutputValue,
+    splitedCount,
+    enableRBF,
+    setEnableRBF: onEnableRBFChange,
+    error,
+    disabled,
+    onOutputValueChange,
+    onClickBack,
+    onClickNext,
+  }
+}

package/src/ui-hooks/useTxConfirmScreenLogic.ts

@@ -0,0 +1,47 @@
+import { SignPsbtParams, SignPsbtResult } from '@unisat/wallet-shared'
+import { useI18n, useNavigation } from 'src/context'
+import { usePushBitcoinTxCallback } from 'src/hooks'
+
+export function useTxConfirmScreenLogic() {
+  const { t } = useI18n()
+  const nav = useNavigation()
+  const { toSignData } = nav.getRouteState<'TxConfirmScreen'>()
+  const pushBitcoinTx = usePushBitcoinTxCallback()
+
+  const signPsbtParams: SignPsbtParams = {
+    data: {
+      toSignDatas: [toSignData],
+    },
+  }
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  const onClickCancel = () => {
+    nav.goBack()
+  }
+
+  const onClickConfirm = async (signedDatas: SignPsbtResult) => {
+    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 })
+    }
+  }
+
+  return {
+    // data
+    signPsbtParams,
+
+    // actions
+    onClickBack,
+    onClickCancel,
+    onClickConfirm,
+  }
+}