@unisat/wallet-state 1.0.5 → 1.2.0

package/src/context/WalletContext.tsx

@@ -1,4 +1,6 @@
-import { createContext, ReactNode, useContext } from 'react'
+import React, { ReactNode, useContext } from 'react'
+
+import { BabylonConfigV2 } from '@unisat/babylon-service/types'
 
 import {
   Account,
@@ -6,49 +8,57 @@ import {
   AddressCAT20TokenSummary,
   AddressCAT20UtxoSummary,
   AddressCAT721CollectionSummary,
+  AddressFlagType,
   AddressRunesTokenSummary,
   AddressSummary,
   AddressTokenSummary,
   AlkanesBalance,
   AlkanesCollection,
   AlkanesInfo,
+  Announcement,
   AppInfo,
+  AppExtra,
   AppSummary,
+  BRC20HistoryItem,
   BabylonAddressSummary,
   BitcoinBalance,
   BitcoinBalanceV2,
-  BRC20HistoryItem,
   BtcChannelItem,
   CAT20Balance,
   CAT20MergeOrder,
   CAT721Balance,
   CoinPrice,
+  ConnectedSite,
   CosmosBalance,
   CosmosSignDataType,
   DecodedPsbt,
+  DummyTxType,
   FeeSummary,
   InscribeOrder,
   Inscription,
   InscriptionSummary,
+  LocalPsbtSummary,
+  RateUsStatus,
   RuneBalance,
   SignPsbtOptions,
+  SignedData,
+  SignedMessage,
+  StoredNotification,
   TickPriceItem,
+  ToSignData,
+  ToSignInput,
+  ToSignMessage,
   TokenBalance,
   TokenTransfer,
   TxHistoryItem,
-  UserToSignInput,
   UTXO,
   UTXO_Detail,
+  UnspentOutput,
   VersionDetail,
   WalletConfig,
   WalletKeyring,
   WebsiteResult,
-  ToSignInput,
-  UnspentOutput,
-  AddressFlagType,
-  ConnectedSite,
 } from '@unisat/wallet-shared'
-import { BabylonConfigV2 } from '@unisat/babylon-service/types'
 import { AddressType, ChainType, NetworkType } from '@unisat/wallet-types'
 
 interface ContactBookItem {
@@ -65,7 +75,13 @@ export interface WalletController {
   openapi: {
     [key: string]: (...params: any) => Promise<any>
   }
+  // for development use only
+  requestMethod: (...params: any) => Promise<any>
 
+  setBackgroundInited(value: boolean): Promise<void>
+  getBackgroundInited(): Promise<boolean>
+
+  getDesc: () => string
   boot(password: string): Promise<void>
   isBooted(): Promise<boolean>
 
@@ -75,7 +91,7 @@ export interface WalletController {
 
   hasVault(): Promise<boolean>
 
-  verifyPassword(password: string): Promise<void>
+  verifyPassword(password: string): Promise<boolean>
   changePassword: (password: string, newPassword: string) => Promise<void>
 
   unlock(password: string): Promise<void>
@@ -143,7 +159,8 @@ export interface WalletController {
     hdPath: string,
     passphrase: string,
     addressType: AddressType,
-    accountCount: number
+    accountCount: number,
+    accountIndexDerivation?: boolean
   ): Promise<{ address: string; type: string }[]>
   createKeyringWithKeystone(
     urType: string,
@@ -186,8 +203,26 @@ export interface WalletController {
     hdPath: string,
     passphrase: string,
     addressType: AddressType,
-    accountCount?: number
+    accountCount?: number,
+    accountIndexDerivation?: boolean
+  ): Promise<WalletKeyring>
+
+  createTmpKeyringWithMnemonics2(
+    mnemonic: string,
+    passphrase: string,
+    hdPaths: string[],
+    addressTypes: AddressType[]
+  ): Promise<WalletKeyring[]>
+
+  createTmpKeyringWithMnemonicsScan(
+    mnemonic: string,
+    hdPath: string,
+    passphrase: string,
+    addressType: AddressType,
+    accountCount: number,
+    accountIndexDerivation?: boolean
   ): Promise<WalletKeyring>
+
   removeKeyring(keyring: WalletKeyring): Promise<WalletKeyring>
   deriveNewAccountFromMnemonic(keyring: WalletKeyring, alianName?: string): Promise<string[]>
   getAccountsCount(): Promise<number>
@@ -200,74 +235,51 @@ export interface WalletController {
 
   getCurrentKeyringAccounts(): Promise<Account[]>
 
-  signPsbtWithHex(
-    psbtHex: string,
-    toSignInputs: ToSignInput[],
-    autoFinalized: boolean
-  ): Promise<string>
+  signPsbtV2(toSignData: ToSignData): Promise<SignedData>
+
+  signMessage(params: ToSignMessage): Promise<SignedMessage>
 
-  sendBTC(data: {
+  createSendBTCPsbt(data: {
     to: string
     amount: number
     btcUtxos: UnspentOutput[]
     feeRate: number
-    enableRBF: boolean
+    enableRBF?: boolean
     memo?: string
     memos?: string[]
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+  }): Promise<ToSignData>
 
-  sendAllBTC(data: {
+  createSendAllBTCPsbt(data: {
     to: string
     btcUtxos: UnspentOutput[]
     feeRate: number
-    enableRBF: boolean
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
-  sendOrdinalsInscription(data: {
+  createSendInscriptionPsbt(data: {
     to: string
     inscriptionId: string
     feeRate: number
     outputValue?: number
-    enableRBF: boolean
     btcUtxos: UnspentOutput[]
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
-  sendOrdinalsInscriptions(data: {
+  createSendMultipleInscriptionsPsbt(data: {
     to: string
     inscriptionIds: string[]
     feeRate: number
-    enableRBF: boolean
     btcUtxos: UnspentOutput[]
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
-  splitOrdinalsInscription(data: {
+  createSplitInscriptionPsbt(data: {
     inscriptionId: string
     feeRate: number
     outputValue: number
-    enableRBF: boolean
     btcUtxos: UnspentOutput[]
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-    splitedCount: number
-  }>
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
   pushTx(rawtx: string): Promise<string>
 
@@ -287,9 +299,11 @@ export interface WalletController {
   getConnectedSites(): Promise<ConnectedSite[]>
   removeConnectedSite(origin: string): Promise<void>
   getCurrentConnectedSite(id: string): Promise<ConnectedSite>
+  updateConnectSite(origin: string, data: Partial<ConnectedSite>): Promise<void>
 
   getCurrentKeyring(): Promise<WalletKeyring>
   getKeyrings(): Promise<WalletKeyring[]>
+  getTotalKeyringCount(): Promise<number>
   changeKeyring(keyring: WalletKeyring, accountIndex?: number): Promise<void>
   getAllAddresses(keyring: WalletKeyring, index: number): Promise<string[]>
 
@@ -298,6 +312,7 @@ export interface WalletController {
 
   setAccountAlianName(account: Account, name: string): Promise<Account>
   getFeeSummary(): Promise<FeeSummary>
+  getLowFeeSummary(): Promise<FeeSummary>
   getCoinPrice(): Promise<CoinPrice>
   getBrc20sPrice(ticks: string[]): Promise<{ [tick: string]: TickPriceItem }>
   getRunesPrice(ticks: string[]): Promise<{ [tick: string]: TickPriceItem }>
@@ -320,6 +335,7 @@ export interface WalletController {
   getInscribeResult(orderId: string): Promise<TokenTransfer>
 
   decodePsbt(psbtHex: string, website: string): Promise<DecodedPsbt>
+  analyzeLocalPsbts(toSignDatas: ToSignData[]): Promise<LocalPsbtSummary>
 
   decodeContracts(contracts: any[], account: any): Promise<any[]>
 
@@ -329,24 +345,39 @@ export interface WalletController {
     pageSize: number
   ): Promise<{ currentPage: number; pageSize: number; total: number; list: Inscription[] }>
 
-  getBRC20List(
-    address: string,
-    currentPage: number,
+  getBRC20List({
+    address,
+    currentPage,
+    pageSize,
+  }: {
+    address: string
+    currentPage: number
     pageSize: number
-  ): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenBalance[] }>
+  }): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenBalance[] }>
 
-  getBRC20ProgList(
-    address: string,
-    currentPage: number,
+  getBRC20ProgList({
+    address,
+    currentPage,
+    pageSize,
+  }: {
+    address: string
+    currentPage: number
     pageSize: number
-  ): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenBalance[] }>
-
-  getBRC20TransferableList(
-    address: string,
-    ticker: string,
-    currentPage: number,
+  }): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenBalance[] }>
+
+  getBRC20TransferableList({
+    address,
+    ticker,
+    tickerHex,
+    currentPage,
+    pageSize,
+  }: {
+    address: string
+    ticker: string
+    tickerHex: string
+    currentPage: number
     pageSize: number
-  ): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenTransfer[] }>
+  }): Promise<{ currentPage: number; pageSize: number; total: number; list: TokenTransfer[] }>
 
   getOrdinalsInscriptions(
     address: string,
@@ -354,7 +385,13 @@ export interface WalletController {
     pageSize: number
   ): Promise<{ currentPage: number; pageSize: number; total: number; list: Inscription[] }>
 
-  getBRC20Summary(address: string, ticker: string): Promise<AddressTokenSummary>
+  getBRC20Summary({
+    address,
+    ticker,
+  }: {
+    address: string
+    ticker: string
+  }): Promise<AddressTokenSummary>
 
   expireUICachedData(address: string): Promise<void>
 
@@ -429,20 +466,16 @@ export interface WalletController {
 
   getAddressRunesTokenSummary(address: string, runeid: string): Promise<AddressRunesTokenSummary>
 
-  sendRunes(data: {
+  createSendRunesPsbt(data: {
     to: string
     runeid: string
     runeAmount: string
     feeRate: number
-    enableRBF: boolean
     btcUtxos?: UnspentOutput[]
     assetUtxos?: UnspentOutput[]
     outputValue?: number
-  }): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
   setAutoLockTimeId(timeId: number): Promise<void>
   getAutoLockTimeId(): Promise<number>
@@ -475,18 +508,16 @@ export interface WalletController {
     tokenId: string,
     tokenAmount: string,
     feeRate: number
-  ): Promise<{ id: string; commitTx: string; toSignInputs: UserToSignInput[]; feeRate: number }>
+  ): Promise<{ id: string; feeRate: number; toSignData: ToSignData }>
   transferCAT20Step2(
     version: 'v1' | 'v2',
     transferId: string,
-    commitTx: string,
-    toSignInputs: UserToSignInput[]
-  ): Promise<{ revealTx: string; toSignInputs: UserToSignInput[] }>
+    psbtHex: string
+  ): Promise<{ toSignData: ToSignData }>
   transferCAT20Step3(
     version: 'v1' | 'v2',
     transferId: string,
-    revealTx: string,
-    toSignInputs: UserToSignInput[]
+    psbtHex: string
   ): Promise<{ txid: string }>
 
   mergeCAT20Prepare(
@@ -498,10 +529,11 @@ export interface WalletController {
   transferCAT20Step1ByMerge(
     version: 'v1' | 'v2',
     mergeId: string
-  ): Promise<{ id: string; commitTx: string; toSignInputs: UserToSignInput[]; feeRate: number }>
+  ): Promise<{ id: string; feeRate: number; toSignData: ToSignData }>
   getMergeCAT20Status(version: 'v1' | 'v2', mergeId: string): Promise<any>
 
   getAppList(): Promise<{ tab: string; items: AppInfo[] }[]>
+  getAppExtra(id: string | number, locale?: string): Promise<AppExtra>
   getBannerList(): Promise<{ id: string; img: string; link: string }[]>
   getBlockActiveInfo(): Promise<{ allTransactions: number; allAddrs: number }>
 
@@ -524,18 +556,16 @@ export interface WalletController {
     collectionId: string,
     localId: string,
     feeRate: number
-  ): Promise<{ id: string; commitTx: string; toSignInputs: UserToSignInput[]; feeRate: number }>
+  ): Promise<{ id: string; feeRate: number; toSignData: ToSignData }>
   transferCAT721Step2(
     version: 'v1' | 'v2',
     transferId: string,
-    commitTx: string,
-    toSignInputs: UserToSignInput[]
-  ): Promise<{ revealTx: string; toSignInputs: UserToSignInput[] }>
+    psbtHex: string
+  ): Promise<{ toSignData: ToSignData }>
   transferCAT721Step3(
     version: 'v1' | 'v2',
     transferId: string,
-    revealTx: string,
-    toSignInputs: UserToSignInput[]
+    psbtHex: string
   ): Promise<{ txid: string }>
 
   getBuyCoinChannelList(coin: string): Promise<BtcChannelItem[]>
@@ -593,23 +623,16 @@ export interface WalletController {
     feeRate: number
   }): Promise<{
     orderId: string
-    psbtHex: string
-    toSignInputs: UserToSignInput[]
+    toSignData: ToSignData
   }>
 
-  singleStepTransferBRC20Step2(params: {
-    orderId: string
-    commitTx: string
-    toSignInputs: UserToSignInput[]
-  }): Promise<{
-    psbtHex: string
-    toSignInputs: UserToSignInput[]
+  singleStepTransferBRC20Step2(params: { orderId: string; commitTx: string }): Promise<{
+    toSignData: ToSignData
   }>
 
   singleStepTransferBRC20Step3(params: {
     orderId: string
     revealTx: string
-    toSignInputs: UserToSignInput[]
   }): Promise<{ txid: string }>
 
   setLastActiveTime(): void
@@ -617,14 +640,11 @@ export interface WalletController {
   getOpenInSidePanel(): Promise<boolean>
   setOpenInSidePanel(openInSidePanel: boolean): Promise<void>
 
-  sendCoinBypassHeadOffsets(
+  createSendBTCOffsetPsbt(
     tos: { address: string; satoshis: number }[],
-    feeRate: number
-  ): Promise<{
-    psbtHex: string
-    rawtx: string
-    fee: number
-  }>
+    feeRate: number,
+    enableRBF?: boolean
+  ): Promise<ToSignData>
 
   getAlkanesList(
     address: string,
@@ -640,30 +660,14 @@ export interface WalletController {
     fetchAvailable: boolean
   ): Promise<AddressAlkanesTokenSummary>
 
-  createAlkanesSendTx(params: {
-    userAddress: string
-    userPubkey: string
-    receiver: string
-    alkaneid: string
-    amount: string
-    feeRate: number
-  }): Promise<{
-    psbtHex: string
-    toSignInputs: UserToSignInput[]
-  }>
-
-  signAlkanesSendTx(params: {
-    commitTx: string
-    toSignInputs: ToSignInput[]
-  }): Promise<{ txid: string }>
-
-  sendAlkanes(params: {
+  createSendAlkanesPsbt(params: {
     to: string
     alkaneid: string
     amount: string
     feeRate: number
-    enableRBF: boolean
-  }): Promise<string>
+    type: 'ft' | 'nft'
+    enableRBF?: boolean
+  }): Promise<ToSignData>
 
   getAlkanesCollectionList(
     address: string,
@@ -678,9 +682,49 @@ export interface WalletController {
   ): Promise<{ currentPage: number; pageSize: number; list: AlkanesInfo[]; total: number }>
 
   getBRC20RecentHistory(address: string, ticker: string): Promise<BRC20HistoryItem[]>
+
+  resetAllData(): Promise<void>
+
+  getGuideReaded(): Promise<boolean>
+  setGuideReaded(): Promise<void>
+
+  getRateUsStatus(): Promise<RateUsStatus>
+
+  setHasRated(hasRated: boolean): Promise<void>
+  setRatePromptDismissedAt(timestamp: number | null): Promise<void>
+  setHasShownSecondPrompt(hasShown: boolean): Promise<void>
+  resetRateUsStatus(): Promise<void>
+  getAnnouncements(
+    cursor: number,
+    size: number
+  ): Promise<{
+    hasMore: boolean
+    list: Announcement[]
+  }>
+
+  getNotifications(): Promise<StoredNotification[]>
+  readNotification(id: string): Promise<void>
+  readAllNotifications(): Promise<void>
+  deleteNotification(id: string): Promise<void>
+  getNotificationUnreadCount(): Promise<number>
+
+  getAcceptLowFeeMode(): Promise<boolean>
+  setAcceptLowFeeMode(accept: boolean): Promise<void>
+  getEnableRBF(): Promise<boolean>
+  setEnableRBF(enableRBF: boolean): Promise<void>
+
+  createTmpKeyringWithPublicKey(publicKey: string, addressType: AddressType): Promise<WalletKeyring>
+
+  createKeyringWithPublicKey(data: string, addressType: AddressType): Promise<void>
+
+  createTmpKeyringWithAddress(address: string): Promise<WalletKeyring>
+
+  createKeyringWithAddress(address: string): Promise<void>
+
+  createDummyPsbt(params: { txType: DummyTxType }): Promise<ToSignData>
 }
 
-const WalletContext = createContext<{
+const WalletContext = React.createContext<{
   wallet: WalletController
 } | null>(null)
 
@@ -700,4 +744,4 @@ const useWallet = () => {
   return wallet
 }
 
-export { useWallet, WalletProvider }
+export { WalletProvider, useWallet }

package/src/context/index.ts

@@ -1,3 +1,18 @@
-export { I18nProvider } from './I18nContext'
+export { ApprovalContext, useApproval, type ApprovalContextType } from './ApprovalContext'
+export { DeviceContext, useDevice, type DeviceContextType } from './DeviceContext'
+export { I18nContext, useI18n, type I18nContextType } from './I18nContext'
+export {
+  NavigationContext,
+  useNavigation,
+  type NavigationContextType,
+  type RouteTypes,
+} from './NavigationContext'
+export { PriceProvider, usePrice } from './PriceContext'
+export {
+  createStorageProvider,
+  StorageContext,
+  useStorage,
+  type StorageContextType,
+} from './StorageContext'
+export { ToolsContext, useTools, type ToolsContextType } from './ToolsContext'
 export { useWallet, WalletProvider } from './WalletContext'
-export { usePrice, PriceProvider } from './PriceContext'

package/src/hooks/accounts.ts

@@ -2,16 +2,16 @@ import { useCallback } from 'react'
 
 import { Account } from '@unisat/wallet-shared'
 
-import { AddressType } from '@unisat/wallet-types'
 import { KeyringType } from '@unisat/keyring-service/types'
+import { AddressType, ChainType } from '@unisat/wallet-types'
 
 import { AppState } from '..'
-import { useAppDispatch, useAppSelector } from './base'
-import { useCurrentKeyring } from './keyrings'
+import { useWallet } from '../context/WalletContext'
+import { accountActions } from '../reducers/accounts'
 import { keyringsActions } from '../reducers/keyrings'
 import { settingsActions } from '../reducers/settings'
-import { accountActions } from '../reducers/accounts'
-import { useWallet } from '../context/WalletContext'
+import { useAppDispatch, useAppSelector } from './base'
+import { useCurrentKeyring } from './keyrings'
 
 export function useAccountsState(): AppState['accounts'] {
   return useAppSelector(state => state.accounts)
@@ -40,6 +40,7 @@ export function useAccountBalance() {
       availableBalance: 0,
       unavailableBalance: 0,
       totalBalance: 0,
+      chainType: ChainType.BITCOIN_MAINNET,
     }
   )
 }
@@ -210,6 +211,7 @@ export function useFetchBalanceCallback() {
       accountActions['setBalanceV2']!({
         address: currentAccount.address,
         balance: balanceV2,
+        chainType: balanceV2.chainType,
       })
     )
   }, [dispatch, wallet, currentAccount, balance])
@@ -244,3 +246,7 @@ export function useIsKeystoneWallet() {
   const currentKeyring = useCurrentKeyring()
   return currentKeyring.type === KeyringType.KeystoneKeyring
 }
+export function useModelPopover() {
+  const modelState = useAccountsState()
+  return modelState.molelsPopover
+}

package/src/hooks/browser.ts

@@ -0,0 +1,11 @@
+import { AppState } from '..'
+import { useAppSelector } from '../hooks'
+
+export function useBrowserState(): AppState['browser'] {
+  return useAppSelector(state => state.browser)
+}
+
+export function useWalletTabScreenState() {
+  const state = useBrowserState()
+  return state.walletTabScreen
+}