@unisat/wallet-state 1.0.4 → 1.1.0

package/src/ui-hooks/useEditAccountNameScreenLogic.ts

@@ -0,0 +1,71 @@
+import { Account } from '@unisat/wallet-shared'
+import { useMemo, useState } from 'react'
+import { useLocation } from 'react-router-dom'
+import { useI18n, useNavigation, useWallet } from 'src/context'
+import { useAppDispatch } from 'src/hooks'
+import { accountActions, keyringsActions } from 'src/reducers'
+
+export function useEditAccountNameScreenLogic() {
+  const nav = useNavigation()
+  const { t } = useI18n()
+
+  const { state } = useLocation()
+  const { account } = state as {
+    account: Account
+  }
+
+  const wallet = useWallet()
+  const [alianName, setAlianName] = useState(account.alianName || '')
+  const dispatch = useAppDispatch()
+  const handleOnClick = async () => {
+    const newAccount = await wallet.setAccountAlianName(account, alianName)
+    // @ts-ignore SAFE
+    dispatch(keyringsActions.updateAccountName(newAccount))
+    // @ts-ignore SAFE
+    dispatch(accountActions.updateAccountName(newAccount))
+    nav.goBack()
+  }
+
+  const handleOnKeyUp = (e: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+    if ('Enter' == e.key && e.ctrlKey) {
+      handleOnClick()
+    }
+  }
+
+  const isValidName = useMemo(() => {
+    if (alianName.length == 0) {
+      return false
+    }
+    return true
+  }, [alianName])
+
+  const truncatedTitle = useMemo(() => {
+    const name = account.alianName || ''
+    if (name.length > 20) {
+      return name.slice(0, 10) + '...'
+    }
+    return name
+  }, [account.alianName])
+
+  const onInputChange = (e: { target: { value: string } } | string) => {
+    const value = typeof e === 'string' ? e : e.target.value
+    if (value.length <= 20) {
+      setAlianName(value)
+    }
+  }
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+  return {
+    alianName,
+    handleOnClick,
+    handleOnKeyUp,
+    isValidName,
+    truncatedTitle,
+    t,
+    account,
+    onInputChange,
+    onClickBack,
+  }
+}

package/src/ui-hooks/useEditContactScreenLogic.ts

@@ -0,0 +1,162 @@
+import { CHAINS_MAP } from '@unisat/wallet-shared'
+import { ChainType } from '@unisat/wallet-types'
+import { useEffect, useState } from 'react'
+import { useI18n, useNavigation, useWallet } from 'src/context'
+import { isValidAddress } from 'src/utils/bitcoin-utils'
+
+export function useEditContactScreenLogic() {
+  const nav = useNavigation()
+
+  // Required parameters
+  const { address, chain, selectedNetworkFilter } = nav.getRouteState<'EditContactScreen'>()
+  const wallet = useWallet()
+  const [name, setName] = useState('')
+  const [contactAddress, setContactAddress] = useState(address || '')
+  const [originalAddress, setOriginalAddress] = useState('')
+  const [originalChain, setOriginalChain] = useState<ChainType | undefined>()
+  const [chainType, setChainType] = useState<ChainType>(ChainType.BITCOIN_MAINNET)
+  const [error, setError] = useState('')
+  const [loading, setLoading] = useState(false)
+  const { t } = useI18n()
+
+  useEffect(() => {
+    if (address) {
+      fetchContact()
+    } else {
+      const preselectedChainType = selectedNetworkFilter as ChainType
+
+      if (preselectedChainType) {
+        setChainType(preselectedChainType)
+      }
+    }
+  }, [address, chain, selectedNetworkFilter])
+
+  const fetchContact = async () => {
+    if (!address || !chain) return
+
+    try {
+      const chainEnum = chain as ChainType
+      const contact = await wallet.getContactByAddressAndChain(address, chainEnum)
+
+      if (contact) {
+        setName(contact.name)
+        setContactAddress(contact.address)
+        setOriginalAddress(contact.address)
+        setOriginalChain(contact.chain)
+        setChainType(contact.chain)
+      } else {
+        setError(t('contact_not_found'))
+        setTimeout(() => {
+          nav.navigate('ContactsScreen', {})
+        }, 1500)
+      }
+    } catch (err) {
+      console.error('Error fetching contact:', err)
+      setError(t('failed_to_load_contact_information'))
+    }
+  }
+
+  const handleSubmit = async () => {
+    if (!name.trim()) {
+      setError(t('please_enter_name'))
+      return
+    }
+
+    if (!contactAddress.trim()) {
+      setError(t('please_enter_address'))
+      return
+    }
+
+    const networkType = CHAINS_MAP[chainType].networkType
+
+    if (!isValidAddress(contactAddress, networkType)) {
+      setError(t('invalid_address_format_for_selected_network'))
+      return
+    }
+
+    setError('')
+    setLoading(true)
+
+    try {
+      if (
+        originalAddress &&
+        originalChain &&
+        (originalAddress !== contactAddress.trim() || originalChain !== chainType)
+      ) {
+        await wallet.removeContact(originalAddress, originalChain)
+      }
+
+      await wallet.updateContact({
+        name: name.trim(),
+        address: contactAddress.trim(),
+        chain: chainType,
+        isContact: true,
+        isAlias: false,
+      })
+
+      nav.goBack()
+    } catch (err) {
+      setError(t('failed_to_save_contact'))
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleDelete = async () => {
+    if (!address || !originalChain) return
+
+    setLoading(true)
+    try {
+      await wallet.removeContact(address, originalChain)
+
+      nav.navigate('ContactsScreen', {
+        returnWithNetwork: chainType,
+      })
+    } catch (err) {
+      setError(t('failed_to_delete_contact'))
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleAddressChange = (e: { target: { value: string } } | string) => {
+    const value = (typeof e === 'string' ? e : e.target.value).trim()
+    setContactAddress(value)
+
+    if (error.includes('Invalid address') || !value) {
+      setError('')
+    }
+
+    if (value) {
+      const networkType = CHAINS_MAP[chainType].networkType
+
+      if (value.length > 15 && !isValidAddress(value, networkType)) {
+        setError(t('invalid_address_format_for_selected_network'))
+      }
+    }
+  }
+
+  const handleNameChange = (e: { target: { value: string } } | string) => {
+    const value = typeof e === 'string' ? e : e.target.value
+    setName(value)
+  }
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  return {
+    name,
+    contactAddress,
+    chainType,
+    error,
+    loading,
+    handleNameChange,
+    handleAddressChange,
+    handleSubmit,
+    handleDelete,
+    onClickBack,
+    address,
+    t,
+  }
+}

package/src/ui-hooks/useEditWalletNameScreenLogic.ts

@@ -0,0 +1,58 @@
+import { useMemo, useState } from 'react'
+
+import { keyringsActions, useAppDispatch, useI18n, useNavigation, useWallet } from '..'
+export function useEditWalletNameScreenLogic() {
+  const nav = useNavigation()
+  const { keyring } = nav.getRouteState<'EditWalletNameScreen'>()
+  const { t } = useI18n()
+  const wallet = useWallet()
+  const [alianName, setAlianName] = useState(keyring.alianName || '')
+  const dispatch = useAppDispatch()
+  const handleOnClick = async () => {
+    try {
+      const newKeyring = await wallet.setKeyringAlianName(keyring, alianName || keyring.alianName)
+      //@ts-ignore SAFE
+      dispatch(keyringsActions.updateKeyringName(newKeyring))
+      nav.goBack()
+    } catch (e) {
+      console.log(e)
+    }
+  }
+
+  const handleOnKeyUp = (e: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+    if ('Enter' == e.key && e.ctrlKey) {
+      handleOnClick()
+    }
+  }
+
+  const isValidName = useMemo(() => {
+    if (alianName.length == 0) {
+      return false
+    }
+    return true
+  }, [alianName])
+
+  const truncatedTitle = useMemo(() => {
+    if (keyring.alianName && keyring.alianName.length > 20) {
+      return keyring.alianName.slice(0, 20) + '...'
+    }
+    return keyring.alianName || ''
+  }, [keyring.alianName])
+
+  const onInputChange = (e: { target: { value: string } } | string) => {
+    const value = typeof e === 'string' ? e : e.target.value
+    if (value.length <= 20) {
+      setAlianName(value)
+    }
+  }
+
+  return {
+    t,
+    keyring,
+    isValidName,
+    truncatedTitle,
+    handleOnClick,
+    handleOnKeyUp,
+    onInputChange,
+  }
+}

package/src/ui-hooks/useExportMnemonicsScreenLogic.ts

@@ -0,0 +1,75 @@
+import { ADDRESS_TYPES } from '@unisat/wallet-shared'
+import { useEffect, useState } from 'react'
+import { useI18n, useNavigation, useTools, useWallet } from 'src/context'
+type Status = '' | 'error' | 'warning' | undefined
+
+export function useExportMnemonicsScreenLogic() {
+  const nav = useNavigation()
+  const { keyring } = nav.getRouteState<'ExportMnemonicsScreen'>()
+
+  const { t } = useI18n()
+
+  const [password, setPassword] = useState('')
+  const [disabled, setDisabled] = useState(true)
+
+  const [mnemonic, setMnemonic] = useState('')
+  const [status, setStatus] = useState<Status>('')
+  const [error, setError] = useState('')
+  const wallet = useWallet()
+  const tools = useTools()
+
+  const [passphrase, setPassphrase] = useState('')
+
+  const btnClick = async () => {
+    try {
+      const { mnemonic, hdPath, passphrase } = await wallet.getMnemonics(password, keyring)
+      setMnemonic(mnemonic)
+      setPassphrase(passphrase)
+    } catch (e) {
+      setStatus('error')
+      setError((e as any).message)
+    }
+  }
+
+  const handleOnKeyUp = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if ('Enter' == e.key) {
+      btnClick()
+    }
+  }
+
+  useEffect(() => {
+    setDisabled(true)
+    if (password) {
+      setDisabled(false)
+      setStatus('')
+      setError('')
+    }
+  }, [password])
+
+  function copy(str: string) {
+    tools.copyToClipboard(str)
+  }
+  const words = mnemonic.split(' ')
+
+  const pathName = ADDRESS_TYPES.find(v => v.hdPath === keyring.hdPath)?.name || 'custom'
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  return {
+    words,
+    pathName,
+    t,
+    setPassword,
+    disabled,
+    btnClick,
+    handleOnKeyUp,
+    mnemonic,
+    passphrase,
+    error,
+    copy,
+    keyring,
+    onClickBack,
+  }
+}

package/src/ui-hooks/useExportPrivateKeyScreenLogic.ts

@@ -0,0 +1,64 @@
+import { useEffect, useState } from 'react'
+import { useI18n, useNavigation, useTools, useWallet } from 'src/context'
+
+type Status = '' | 'error' | 'warning' | undefined
+export function useExportPrivateKeyScreenLogic() {
+  const { t } = useI18n()
+
+  const nav = useNavigation()
+  const { account } = nav.getRouteState<'ExportPrivateKeyScreen'>()
+
+  const [password, setPassword] = useState('')
+  const [disabled, setDisabled] = useState(true)
+
+  const [privateKey, setPrivateKey] = useState({ hex: '', wif: '' })
+  const [status, setStatus] = useState<Status>('')
+  const [error, setError] = useState('')
+  const wallet = useWallet()
+  const tools = useTools()
+
+  const btnClick = async () => {
+    try {
+      const _res = await wallet.getPrivateKey(password, account)
+      setPrivateKey(_res)
+    } catch (e) {
+      setStatus('error')
+      setError((e as any).message)
+    }
+  }
+
+  const handleOnKeyUp = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if ('Enter' == e.key) {
+      btnClick()
+    }
+  }
+
+  useEffect(() => {
+    setDisabled(true)
+    if (password) {
+      setDisabled(false)
+      setStatus('')
+      setError('')
+    }
+  }, [password])
+
+  function copy(str: string) {
+    tools.copyToClipboard(str)
+  }
+
+  const onClickBack = () => {
+    nav.goBack()
+  }
+
+  return {
+    t,
+    setPassword,
+    disabled,
+    btnClick,
+    handleOnKeyUp,
+    privateKey,
+    error,
+    copy,
+    onClickBack,
+  }
+}