@unisat/wallet-state 1.0.0

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2024 UniSat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ADDITIONAL TERMS:
+This software is primarily intended for use with UniSat products and internal 
+development purposes. Third-party usage is at your own risk. UniSat does not 
+provide support or warranty for external usage of this toolkit.

package/README.md

@@ -0,0 +1,54 @@
+# @unisat/wallet-state
+
+Redux state management for UniSat wallet, designed to be shared between browser extension and mobile applications.
+
+## Features
+
+- 🔄 Cross-platform Redux store configuration
+- 🏪 Typed state slices for all wallet data
+- 🪝 Typed React hooks for state access
+- 🔧 Flexible middleware and persistence configuration
+
+## Usage
+
+```typescript
+import { createWalletStore, useAccountsState, useWalletDispatch } from '@unisat/wallet-state';
+
+// Create store with platform-specific persistence
+const store = createWalletStore({
+  persistedKeys: ['ui', 'settings'],
+  middleware: [/* platform-specific middleware */]
+});
+
+// Use in React components
+function WalletComponent() {
+  const accounts = useAccountsState();
+  const dispatch = useWalletDispatch();
+  
+  // Component logic...
+}
+```
+
+## Architecture
+
+This package contains the Redux state management logic extracted from the browser extension, designed to be reused in the mobile application.
+
+### Store
+- `createWalletStore()` - Configurable store factory with platform-specific options
+
+### Slices
+- `accounts` - Account and keyring data
+- `transactions` - Transaction history and pending transactions
+- `settings` - User preferences and configuration
+- `global` - Global application state
+- `keyrings` - Keyring management state
+- `ui` - UI-specific state (modals, navigation, etc.)
+
+### Hooks
+- Typed React hooks for each state slice
+- `useWalletDispatch` - Typed dispatch hook
+- `useWalletSelector` - Typed selector hook
+
+## Migration Notes
+
+The actual state structures and reducers are placeholders and will be populated by migrating the existing Redux logic from the extension and mobile applications.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@unisat/wallet-state",
+  "version": "1.0.0",
+  "description": "Redux state management for UniSat wallet, shared between platforms",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "peerDependencies": {
+    "@reduxjs/toolkit": "^1.9.0",
+    "react": "^18.0.0",
+    "react-redux": "^8.0.0",
+    "@unisat/wallet-types": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "eslint": "^8.0.0",
+    "tsup": "^7.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^0.34.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:cjs": "tsup --format cjs",
+    "build:esm": "tsup --format esm",
+    "build:typed": "tsc --declaration --declarationMap --emitDeclarationOnly --outDir lib",
+    "test": "vitest",
+    "lint": "eslint src"
+  }
+}

package/src/hooks/accounts.ts

@@ -0,0 +1,244 @@
+import { useCallback } from 'react'
+
+import { Account, AddressType } from '@/shared/types'
+import { useWallet } from '@/ui/utils'
+import { KeyringType } from '@unisat/keyring-service/types'
+
+import { AppState } from '..'
+import { useAppDispatch, useAppSelector } from '../hooks'
+import { useCurrentKeyring } from '../keyrings/hooks'
+import { keyringsActions } from '../keyrings/reducer'
+import { settingsActions } from '../settings/reducer'
+import { accountActions } from './reducer'
+
+export function useAccountsState(): AppState['accounts'] {
+  return useAppSelector(state => state.accounts)
+}
+
+export function useCurrentAccount() {
+  const accountsState = useAccountsState()
+  return accountsState.current
+}
+
+export function useCurrentAddress() {
+  const accountsState = useAccountsState()
+  return accountsState.current.address
+}
+
+export function useAccounts() {
+  const accountsState = useAccountsState()
+  return accountsState.accounts
+}
+
+export function useAccountBalance() {
+  const accountsState = useAccountsState()
+  const currentAccount = useCurrentAccount()
+  return (
+    accountsState.balanceV2Map[currentAccount.address] || {
+      availableBalance: 0,
+      unavailableBalance: 0,
+      totalBalance: 0,
+    }
+  )
+}
+
+export function useAddressSummary() {
+  const accountsState = useAccountsState()
+  return accountsState.addressSummary
+}
+
+export function useAccountInscriptions() {
+  const accountsState = useAccountsState()
+  const currentAccount = useCurrentAccount()
+  return accountsState.inscriptionsMap[currentAccount.address] || { list: [], expired: true }
+}
+
+export function useInscriptionSummary() {
+  const accountsState = useAccountsState()
+  return accountsState.inscriptionSummary
+}
+
+export function useAppSummary() {
+  const accountsState = useAccountsState()
+  return accountsState.appSummary
+}
+
+export function useUnreadAppSummary() {
+  const accountsState = useAccountsState()
+  const summary = accountsState.appSummary
+  return summary.apps.find(w => w.time && summary.readTabTime && w.time > summary.readTabTime)
+}
+
+export function useReadTab() {
+  const wallet = useWallet()
+  const dispatch = useAppDispatch()
+  const appSummary = useAppSummary()
+  return useCallback(
+    async (name: 'app' | 'home' | 'settings') => {
+      await wallet.readTab(name)
+      if (name == 'app') {
+        const appSummary = await wallet.getAppSummary()
+        dispatch(accountActions.setAppSummary(appSummary))
+      }
+    },
+    [dispatch, wallet, appSummary]
+  )
+}
+
+export function useReadApp() {
+  const wallet = useWallet()
+  const dispatch = useAppDispatch()
+  const appSummary = useAppSummary()
+  return useCallback(
+    async (id: number) => {
+      await wallet.readApp(id)
+      const appSummary = await wallet.getAppSummary()
+      dispatch(accountActions.setAppSummary(appSummary))
+    },
+    [dispatch, wallet, appSummary]
+  )
+}
+
+export function useHistory() {
+  const accountsState = useAccountsState()
+  const address = useAccountAddress()
+  return accountsState.historyMap[address] || { list: [], expired: true }
+}
+
+export function useAccountAddress() {
+  const currentAccount = useCurrentAccount()
+  return currentAccount.address
+}
+
+export function useSetCurrentAccountCallback() {
+  const dispatch = useAppDispatch()
+  return useCallback(
+    (account: Account) => {
+      dispatch(accountActions.setCurrent(account))
+    },
+    [dispatch]
+  )
+}
+
+export function useImportAccountCallback() {
+  const wallet = useWallet()
+  const dispatch = useAppDispatch()
+  const currentKeyring = useCurrentKeyring()
+  return useCallback(
+    async (privateKey: string, addressType: AddressType) => {
+      let success = false
+      let error
+      try {
+        const alianName = await wallet.getNextAlianName(currentKeyring)
+        await wallet.createKeyringWithPrivateKey(privateKey, addressType, alianName)
+        const currentAccount = await wallet.getCurrentAccount()
+        dispatch(accountActions.setCurrent(currentAccount))
+
+        success = true
+      } catch (e) {
+        console.log(e)
+        error = (e as any).message
+      }
+      return { success, error }
+    },
+    [dispatch, wallet, currentKeyring]
+  )
+}
+
+export function useChangeAddressFlagCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  return useCallback(
+    async (isAdd: boolean, flag: number) => {
+      const account = isAdd
+        ? await wallet.addAddressFlag(currentAccount, flag)
+        : await wallet.removeAddressFlag(currentAccount, flag)
+      dispatch(accountActions.setCurrentAddressFlag(account.flag))
+    },
+    [dispatch, wallet, currentAccount]
+  )
+}
+
+// export function useFetchHistoryCallback() {
+//   const dispatch = useAppDispatch();
+//   const wallet = useWallet();
+//   const address = useAccountAddress();
+//   return useCallback(async () => {
+//     const _accountHistory = await wallet.getAddressHistory(address);
+//     dispatch(
+//       accountActions.setHistory({
+//         address: address,
+//         list: _accountHistory
+//       })
+//     );
+//   }, [dispatch, wallet, address]);
+// }
+
+export function useFetchBalanceCallback() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  const currentAccount = useCurrentAccount()
+  const balance = useAccountBalance()
+  return useCallback(async () => {
+    if (!currentAccount.address) return
+    // const cachedBalance = await wallet.getAddressCacheBalance(currentAccount.address);
+    // const _accountBalance = await wallet.getAddressBalance(currentAccount.address);
+    // dispatch(
+    //   accountActions.setBalance({
+    //     address: currentAccount.address,
+    //     amount: _accountBalance.amount,
+    //     btc_amount: _accountBalance.btc_amount,
+    //     inscription_amount: _accountBalance.inscription_amount,
+    //     confirm_btc_amount: _accountBalance.confirm_btc_amount,
+    //     pending_btc_amount: _accountBalance.pending_btc_amount
+    //   })
+    // );
+    // if (cachedBalance.amount !== _accountBalance.amount) {
+    //   wallet.expireUICachedData(currentAccount.address);
+    //   dispatch(accountActions.expireHistory());
+    // }
+
+    const summary = await wallet.getAddressSummary(currentAccount.address)
+    summary.address = currentAccount.address
+    dispatch(accountActions.setAddressSummary(summary))
+
+    const balanceV2 = await wallet.getAddressBalanceV2(currentAccount.address)
+    dispatch(
+      accountActions.setBalanceV2({
+        address: currentAccount.address,
+        balance: balanceV2,
+      })
+    )
+  }, [dispatch, wallet, currentAccount, balance])
+}
+
+export function useReloadAccounts() {
+  const dispatch = useAppDispatch()
+  const wallet = useWallet()
+  return useCallback(async () => {
+    const keyrings = await wallet.getKeyrings()
+    dispatch(keyringsActions.setKeyrings(keyrings))
+
+    const currentKeyring = await wallet.getCurrentKeyring()
+    dispatch(keyringsActions.setCurrent(currentKeyring))
+
+    const _accounts = await wallet.getAccounts()
+    dispatch(accountActions.setAccounts(_accounts))
+
+    const account = await wallet.getCurrentAccount()
+    dispatch(accountActions.setCurrent(account))
+
+    dispatch(accountActions.expireBalance())
+    dispatch(accountActions.expireInscriptions())
+
+    wallet.getWalletConfig().then(data => {
+      dispatch(settingsActions.updateSettings({ walletConfig: data }))
+    })
+  }, [dispatch, wallet])
+}
+
+export function useIsKeystoneWallet() {
+  const currentKeyring = useCurrentKeyring()
+  return currentKeyring.type === KeyringType.KeystoneKeyring
+}

package/src/hooks/global.ts

@@ -0,0 +1,7 @@
+import { useWalletSelector } from './index';
+
+export const useGlobalState = () => {
+  return useWalletSelector((state) => state.global);
+};
+
+// Additional global hooks will be migrated here

package/src/hooks/index.ts

@@ -0,0 +1,15 @@
+import { useDispatch, useSelector, TypedUseSelectorHook } from 'react-redux';
+import type { WalletDispatch } from '../store';
+import type { AppState } from '../types';
+
+// Typed hooks for the wallet store
+export const useWalletDispatch = () => useDispatch<WalletDispatch>();
+export const useWalletSelector: TypedUseSelectorHook<AppState> = useSelector;
+
+// Re-export common hooks that will be migrated from existing code
+export * from './accounts';
+export * from './transactions';
+export * from './settings';
+export * from './global';
+export * from './keyrings';
+export * from './ui';

package/src/hooks/keyrings.ts

@@ -0,0 +1,7 @@
+import { useWalletSelector } from './index';
+
+export const useKeyringsState = () => {
+  return useWalletSelector((state) => state.keyrings);
+};
+
+// Additional keyrings hooks will be migrated here

package/src/hooks/settings.ts

@@ -0,0 +1,7 @@
+import { useWalletSelector } from './index';
+
+export const useSettingsState = () => {
+  return useWalletSelector((state) => state.settings);
+};
+
+// Additional settings hooks will be migrated here