@unisat/wallet-state 1.0.0

package/src/slices/transactions.ts

@@ -0,0 +1,255 @@
+import { Inscription } from '@/shared/types'
+import { createSlice } from '@reduxjs/toolkit'
+import { UnspentOutput } from '@unisat/tx-helpers/types'
+
+import { updateVersion } from '../global/actions'
+
+export interface BitcoinTx {
+  fromAddress: string
+  toAddress: string
+  toSatoshis: number
+  rawtx: string
+  txid: string
+  fee: number
+  estimateFee: number
+  changeSatoshis: number
+  sending: boolean
+  autoAdjust: boolean
+  psbtHex: string
+  feeRate: number
+  toDomain: string
+  enableRBF: boolean
+}
+
+export interface OrdinalsTx {
+  fromAddress: string
+  toAddress: string
+  inscription: Inscription
+  rawtx: string
+  txid: string
+  fee: number
+  estimateFee: number
+  changeSatoshis: number
+  sending: boolean
+  psbtHex: string
+  feeRate: number
+  toDomain: string
+  outputValue: number
+  enableRBF: boolean
+}
+
+export interface RunesTx {
+  fromAddress: string
+  toAddress: string
+  rawtx: string
+  txid: string
+  fee: number
+  estimateFee: number
+  changeSatoshis: number
+  sending: boolean
+  psbtHex: string
+  feeRate: number
+  toDomain: string
+  outputValue: number
+  enableRBF: boolean
+  runeid?: string
+  runeAmount?: string
+}
+
+export interface TransactionsState {
+  bitcoinTx: BitcoinTx
+  ordinalsTx: OrdinalsTx
+  runesTx: RunesTx
+  utxos: UnspentOutput[]
+  spendUnavailableUtxos: UnspentOutput[]
+  assetUtxos_inscriptions: UnspentOutput[]
+  assetUtxos_runes: UnspentOutput[]
+}
+
+export const initialState: TransactionsState = {
+  bitcoinTx: {
+    fromAddress: '',
+    toAddress: '',
+    toSatoshis: 0,
+    rawtx: '',
+    txid: '',
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    autoAdjust: false,
+    psbtHex: '',
+    feeRate: 5,
+    toDomain: '',
+    enableRBF: false,
+  },
+  ordinalsTx: {
+    fromAddress: '',
+    toAddress: '',
+    inscription: {
+      inscriptionId: '',
+      inscriptionNumber: 0,
+      address: '',
+      outputValue: 0,
+      preview: '',
+      content: '',
+      contentType: '',
+      contentLength: 0,
+      timestamp: 0,
+      genesisTransaction: '',
+      location: '',
+      output: '',
+      offset: 0,
+      contentBody: '',
+      utxoHeight: 0,
+      utxoConfirmation: 0,
+    },
+    rawtx: '',
+    txid: '',
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    psbtHex: '',
+    feeRate: 5,
+    toDomain: '',
+    outputValue: 10000,
+    enableRBF: false,
+  },
+
+  runesTx: {
+    fromAddress: '',
+    toAddress: '',
+    rawtx: '',
+    txid: '',
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    psbtHex: '',
+    feeRate: 5,
+    toDomain: '',
+    outputValue: 10000,
+    enableRBF: false,
+  },
+  utxos: [],
+  spendUnavailableUtxos: [],
+  assetUtxos_inscriptions: [],
+  assetUtxos_runes: [],
+}
+
+const slice = createSlice({
+  name: 'transactions',
+  initialState,
+  reducers: {
+    updateBitcoinTx(
+      state,
+      action: {
+        payload: {
+          fromAddress?: string
+          toAddress?: string
+          toSatoshis?: number
+          changeSatoshis?: number
+          rawtx?: string
+          txid?: string
+          fee?: number
+          estimateFee?: number
+          sending?: boolean
+          autoAdjust?: boolean
+          psbtHex?: string
+          feeRate?: number
+          toDomain?: string
+          enableRBF?: boolean
+        }
+      }
+    ) {
+      const { payload } = action
+      state.bitcoinTx = Object.assign({}, state.bitcoinTx, payload)
+    },
+    updateOrdinalsTx(
+      state,
+      action: {
+        payload: {
+          fromAddress?: string
+          toAddress?: string
+          inscription?: Inscription
+          changeSatoshis?: number
+          rawtx?: string
+          txid?: string
+          fee?: number
+          estimateFee?: number
+          sending?: boolean
+          psbtHex?: string
+          feeRate?: number
+          toDomain?: string
+          outputValue?: number
+          enableRBF?: boolean
+        }
+      }
+    ) {
+      const { payload } = action
+      state.ordinalsTx = Object.assign({}, state.ordinalsTx, payload)
+    },
+
+    updateRunesTx(
+      state,
+      action: {
+        payload: {
+          fromAddress?: string
+          toAddress?: string
+          changeSatoshis?: number
+          rawtx?: string
+          txid?: string
+          fee?: number
+          estimateFee?: number
+          sending?: boolean
+          psbtHex?: string
+          feeRate?: number
+          toDomain?: string
+          outputValue?: number
+          enableRBF?: boolean
+          runeid?: string
+          runeAmount?: string
+        }
+      }
+    ) {
+      const { payload } = action
+      state.runesTx = Object.assign({}, state.runesTx, payload)
+    },
+    setUtxos(state, action: { payload: UnspentOutput[] }) {
+      state.utxos = action.payload
+    },
+    setSpendUnavailableUtxos(state, action: { payload: UnspentOutput[] }) {
+      state.spendUnavailableUtxos = action.payload
+    },
+
+    setAssetUtxosInscriptions(state, action: { payload: UnspentOutput[] }) {
+      state.assetUtxos_inscriptions = action.payload
+    },
+    setAssetUtxosRunes(state, action: { payload: UnspentOutput[] }) {
+      state.assetUtxos_runes = action.payload
+    },
+    reset(state) {
+      return initialState
+    },
+  },
+
+  extraReducers: builder => {
+    builder.addCase(updateVersion, state => {
+      if (!state.assetUtxos_inscriptions) {
+        state.assetUtxos_inscriptions = []
+      }
+
+      if (!state.spendUnavailableUtxos) {
+        state.spendUnavailableUtxos = []
+      }
+
+      if (!state.assetUtxos_runes) {
+        state.assetUtxos_runes = []
+      }
+    })
+  },
+})
+
+export const transactionsActions = slice.actions
+export default slice.reducer

package/src/slices/ui.ts

@@ -0,0 +1,203 @@
+import { Inscription } from '@/shared/types'
+import { createSlice } from '@reduxjs/toolkit'
+
+import { updateVersion } from '../global/actions'
+
+export interface UIState {
+  assetTabKey: AssetTabKey
+  ordinalsAssetTabKey: OrdinalsAssetTabKey
+  catAssetTabKey: CATAssetTabKey
+  alkanesAssetTabKey: AlkanesAssetTabKey
+  uiTxCreateScreen: {
+    toInfo: {
+      address: string
+      domain: string
+      inscription?: Inscription
+    }
+    inputAmount: string
+    enableRBF: boolean
+    feeRate: number
+  }
+  babylonSendScreen: {
+    inputAmount: string
+    memo: string
+  }
+  navigationSource: NavigationSource
+  isBalanceHidden: boolean
+}
+
+export enum AssetTabKey {
+  ORDINALS = 0,
+  ATOMICALS = 1, // IGNORED
+  RUNES = 2,
+  CAT = 3,
+  ALKANES = 4,
+}
+
+export enum OrdinalsAssetTabKey {
+  ALL = 0,
+  BRC20 = 1,
+  BRC20_6BYTE = 2,
+}
+
+export enum CATAssetTabKey {
+  CAT20,
+  CAT721,
+  CAT20_V2,
+  CAT721_V2,
+}
+
+export enum AlkanesAssetTabKey {
+  TOKEN,
+  COLLECTION,
+}
+
+export enum NavigationSource {
+  BACK,
+  NORMAL,
+}
+
+export const initialState: UIState = {
+  assetTabKey: AssetTabKey.ORDINALS,
+  ordinalsAssetTabKey: OrdinalsAssetTabKey.ALL,
+  catAssetTabKey: CATAssetTabKey.CAT20,
+  alkanesAssetTabKey: AlkanesAssetTabKey.TOKEN,
+  uiTxCreateScreen: {
+    toInfo: {
+      address: '',
+      domain: '',
+      inscription: undefined,
+    },
+    inputAmount: '',
+    enableRBF: false,
+    feeRate: 1,
+  },
+  babylonSendScreen: {
+    inputAmount: '',
+    memo: '',
+  },
+  navigationSource: NavigationSource.NORMAL,
+  isBalanceHidden: false,
+}
+
+const slice = createSlice({
+  name: 'ui',
+  initialState,
+  reducers: {
+    reset(state) {
+      return initialState
+    },
+    updateAssetTabScreen(
+      state,
+      action: {
+        payload: {
+          assetTabKey?: AssetTabKey
+          ordinalsAssetTabKey?: OrdinalsAssetTabKey
+          catAssetTabKey?: CATAssetTabKey
+          alkanesAssetTabKey?: AlkanesAssetTabKey
+        }
+      }
+    ) {
+      const { payload } = action
+      if (payload.assetTabKey !== undefined) {
+        state.assetTabKey = payload.assetTabKey
+      }
+      if (payload.ordinalsAssetTabKey !== undefined) {
+        state.ordinalsAssetTabKey = payload.ordinalsAssetTabKey
+      }
+
+      if (payload.catAssetTabKey !== undefined) {
+        state.catAssetTabKey = payload.catAssetTabKey
+      }
+      if (payload.alkanesAssetTabKey !== undefined) {
+        state.alkanesAssetTabKey = payload.alkanesAssetTabKey
+      }
+      return state
+    },
+    updateTxCreateScreen(
+      state,
+      action: {
+        payload: {
+          toInfo?: {
+            address: string
+            domain: string
+            inscription?: Inscription
+          }
+          inputAmount?: string
+          enableRBF?: boolean
+          feeRate?: number
+        }
+      }
+    ) {
+      if (action.payload.toInfo !== undefined) {
+        state.uiTxCreateScreen.toInfo = action.payload.toInfo
+      }
+      if (action.payload.inputAmount !== undefined) {
+        state.uiTxCreateScreen.inputAmount = action.payload.inputAmount
+      }
+      if (action.payload.enableRBF !== undefined) {
+        state.uiTxCreateScreen.enableRBF = action.payload.enableRBF
+      }
+      if (action.payload.feeRate !== undefined) {
+        state.uiTxCreateScreen.feeRate = action.payload.feeRate
+      }
+    },
+    resetTxCreateScreen(state) {
+      state.uiTxCreateScreen = initialState.uiTxCreateScreen
+    },
+    updateBabylonSendScreen(
+      state,
+      action: {
+        payload: {
+          inputAmount?: string
+          memo?: string
+        }
+      }
+    ) {
+      if (action.payload.inputAmount !== undefined) {
+        state.babylonSendScreen.inputAmount = action.payload.inputAmount
+      }
+      if (action.payload.memo !== undefined) {
+        state.babylonSendScreen.memo = action.payload.memo
+      }
+    },
+    resetBabylonSendScreen(state) {
+      state.babylonSendScreen = initialState.babylonSendScreen
+    },
+    setNavigationSource(state, action: { payload: NavigationSource }) {
+      state.navigationSource = action.payload
+    },
+    setBalanceHidden(state, action: { payload: boolean }) {
+      state.isBalanceHidden = action.payload
+    },
+  },
+  extraReducers: builder => {
+    builder.addCase(updateVersion, state => {
+      // todo
+      if (!state.assetTabKey) {
+        state.assetTabKey = AssetTabKey.ORDINALS
+      }
+      if (!state.ordinalsAssetTabKey) {
+        state.ordinalsAssetTabKey = OrdinalsAssetTabKey.ALL
+      }
+      if (!state.catAssetTabKey) {
+        state.catAssetTabKey = CATAssetTabKey.CAT20
+      }
+      if (!state.alkanesAssetTabKey) {
+        state.alkanesAssetTabKey = AlkanesAssetTabKey.TOKEN
+      }
+      if (!state.uiTxCreateScreen) {
+        state.uiTxCreateScreen = initialState.uiTxCreateScreen
+      }
+      if (!state.babylonSendScreen) {
+        state.babylonSendScreen = initialState.babylonSendScreen
+      }
+      if (state.isBalanceHidden === undefined) {
+        state.isBalanceHidden = false
+      }
+    })
+  },
+})
+
+export const uiActions = slice.actions
+export default slice.reducer

package/src/store/index.ts

@@ -0,0 +1,43 @@
+import { configureStore } from '@reduxjs/toolkit';
+import type { AppState } from '../types';
+
+// Import reducers (to be implemented)
+// import { accountsReducer } from '../slices/accounts';
+// import { transactionsReducer } from '../slices/transactions';
+// import { settingsReducer } from '../slices/settings';
+// import { globalReducer } from '../slices/global';
+// import { keyringsReducer } from '../slices/keyrings';
+// import { uiReducer } from '../slices/ui';
+
+/**
+ * Create store with platform-specific middleware and persistence
+ */
+export function createWalletStore(options?: {
+  persistedKeys?: string[];
+  middleware?: any[];
+}) {
+  return configureStore({
+    reducer: {
+      // accounts: accountsReducer,
+      // transactions: transactionsReducer,
+      // settings: settingsReducer,
+      // global: globalReducer,
+      // keyrings: keyringsReducer,
+      // ui: uiReducer,
+    },
+    middleware: (getDefaultMiddleware) => {
+      let middleware = getDefaultMiddleware({ thunk: true });
+      
+      if (options?.middleware) {
+        middleware = middleware.concat(options.middleware);
+      }
+      
+      return middleware;
+    },
+    // Platform-specific preloaded state will be handled by the consuming app
+  });
+}
+
+export type WalletStore = ReturnType<typeof createWalletStore>;
+export type WalletDispatch = WalletStore['dispatch'];
+export type { AppState };

package/src/types/index.ts

@@ -0,0 +1,37 @@
+// Redux state types
+export interface AppState {
+  accounts: AccountsState;
+  transactions: TransactionsState;
+  settings: SettingsState;
+  global: GlobalState;
+  keyrings: KeyringsState;
+  ui: UIState;
+}
+
+// Individual state slice types (to be populated from existing code)
+export interface AccountsState {
+  // To be populated with actual account state structure
+}
+
+export interface TransactionsState {
+  // To be populated with actual transaction state structure
+}
+
+export interface SettingsState {
+  // To be populated with actual settings state structure
+}
+
+export interface GlobalState {
+  // To be populated with actual global state structure
+}
+
+export interface KeyringsState {
+  // To be populated with actual keyrings state structure
+}
+
+export interface UIState {
+  // To be populated with actual UI state structure
+}
+
+// Re-export common types
+export * from '@unisat/wallet-types';