@otoplo/wallet-common 0.2.1 → 0.4.0

package/dist/types/state/slices/wallet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../../src/state/slices/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG5E,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,UAAU,oBAAoB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAgFD,eAAO,MAAM,aAAa;;sBAzFV,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eA4BI,aAAa,CAAC,OAAO,CAAC;;sBApCvC,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eA+BW,aAAa,CAAC,MAAM,CAAC;;sBAvC7C,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAkCA,aAAa,CAAC,OAAO,CAAC;;sBA1CnC,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAqCC,aAAa,CAAC,SAAS,CAAC;;sBA7CtC,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAwCQ,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;;sBAhDzE,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eA2CG,aAAa,CAAC,OAAO,CAAC;;sBAnDtC,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eA8CO,aAAa,CAAC,MAAM,CAAC;;sBAtDzC,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAiDU,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;;sBAzD9G,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAqDO,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;;sBA7D/D,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;;;sBARb,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;;;sBARb,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;;;sBARb,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAiEC,aAAa,CAAC,iBAAiB,CAAC;;sBAzE9C,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eAqEI,aAAa,CAAC,oBAAoB,CAAC;;sBA7EpD,OAAO;yBACJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjB,OAAO;kBACH,OAAO;yBACA,MAAM;2BACJ,MAAM;6BACJ,MAAM;eA2EI,aAAa,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;YAMrB,CAAC;AACjD,eAAO,MAAM,aAAa,sCAAsB,CAAC"}

package/dist/types/state/store.d.ts

@@ -1,26 +0,0 @@
-import { authReducer } from './slices/auth';
-import { dappModalReducer } from './slices/dapp';
-import { loaderReducer } from './slices/loader';
-import { marketReducer } from './slices/market';
-import { notificationsReducer } from './slices/notifications';
-import { statusReducer } from './slices/status';
-import { walletReducer } from './slices/wallet';
-export declare const sharedReducers: {
-    loader: import('redux').Reducer<import('./slices').LoaderState>;
-    dapp: import('redux').Reducer<import('./slices').DappModalState>;
-    status: import('redux').Reducer<import('./slices').StatusState>;
-    wallet: import('redux').Reducer<import('./slices').WalletState>;
-    auth: import('redux').Reducer<import('./slices').AuthState>;
-    notifications: import('redux').Reducer<import('./slices').NotificationsState>;
-    market: import('redux').Reducer<import('./slices/market').MarketState>;
-};
-export type SharedState = {
-    loader: ReturnType<typeof loaderReducer>;
-    dapp: ReturnType<typeof dappModalReducer>;
-    status: ReturnType<typeof statusReducer>;
-    wallet: ReturnType<typeof walletReducer>;
-    auth: ReturnType<typeof authReducer>;
-    notifications: ReturnType<typeof notificationsReducer>;
-    market: ReturnType<typeof marketReducer>;
-};
-//# sourceMappingURL=store.d.ts.map

package/dist/types/state/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/state/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,eAAO,MAAM,cAAc;;;;;;;;CAQ1B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;IACzC,IAAI,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IAC1C,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;IACzC,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;IACzC,IAAI,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACrC,aAAa,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IACvD,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;CAC1C,CAAC"}

package/src/persistence/datastore/index.ts

@@ -1,2 +0,0 @@
-export * from './db';
-export * from './kv';

package/src/persistence/datastore/kv.ts

@@ -1,129 +0,0 @@
-import type { RostrumParams } from "../../types/rostrum.types";
-import { isNullOrEmpty, isTestnet } from "../../utils/common";
-
-export abstract class KVStore {
-  
-  public abstract getValue(key: string): Promise<string | null>;
-  public abstract setValue(key: string, value: string): Promise<void>;
-  public abstract removeValue(key: string): Promise<void>;
-  public abstract clearData(): Promise<void>;
-
-  protected getPrefix(): string {
-    return isTestnet() ? 'testnet-' : '';
-  }
-
-  public async getEncryptedSeed(): Promise<string | null> {
-    return this.getValue("seed");
-  }
-
-  public async saveEncryptedSeed(seed: string): Promise<void> {
-    return this.setValue('seed', seed);
-  }
-
-  public async getVersionCode(): Promise<string | null> {
-    return this.getValue("version-code");
-  }
-
-  public async setVersionCode(code: string): Promise<void> {
-    return this.setValue('version-code', code);
-  }
-
-  public async getReleaseNumber(): Promise<string | null> {
-    return this.getValue("release-number");
-  }
-
-  public async setReleaseNumber(release: string): Promise<void> {
-    return this.setValue('release-number', release);
-  }
-
-  public async getRostrumParams(): Promise<RostrumParams | undefined> {
-    const params = await this.getValue(this.getPrefix() + "rostrum-params");
-    if (params) {
-      return JSON.parse(params);
-    }
-  }
-
-  public async saveRostrumParams(params: RostrumParams): Promise<void> {
-    return this.setValue(this.getPrefix() + "rostrum-params", JSON.stringify(params));
-  }
-
-  public async removeRostrumParams(): Promise<void> {
-    return this.removeValue(this.getPrefix() + "rostrum-params");
-  }
-
-  public async setHideZeroTokenConfig(hide: boolean): Promise<void> {
-    return this.setValue("zero-tokens", JSON.stringify(hide));
-  }
-
-  public async getHideZeroTokenConfig(): Promise<boolean> {
-    const hide = await this.getValue("zero-tokens");
-    return hide === "true";
-  }
-
-  public async setHideZeroVaultsConfig(hide: boolean): Promise<void> {
-    return this.setValue("zero-vaults", JSON.stringify(hide));
-  }
-
-  public async getHideZeroVaultsConfig(): Promise<boolean> {
-    const hide = await this.getValue("zero-vaults");
-    return hide === "true";
-  }
-
-  public async getSelectedCurrency(): Promise<string> {
-    const value = await this.getValue('selectedCurrency');
-    return value || 'usd';
-  }
-
-  public async setSelectedCurrency(currency: string): Promise<void> {
-    return this.setValue('selectedCurrency', currency);
-  }
-
-  public async getUseBiometric(): Promise<boolean> {
-    const value = await this.getValue('biometrics');
-    return value === "true";
-  }
-
-  public async setUseBiometric(useBiometric: boolean): Promise<void> {
-    return this.setValue('biometrics', JSON.stringify(useBiometric));
-  }
-
-  public async getRequireAuth(): Promise<boolean> {
-    const value = await this.getValue('auth');
-    return isNullOrEmpty(value) || value === "true";
-  }
-
-  public async setRequireAuth(requireAuth: boolean): Promise<void> {
-    await this.setValue('auth', JSON.stringify(requireAuth));
-  }
-
-  public async getReleaseNotesTime(): Promise<number | undefined> {
-    const value = await this.getValue('show-notes');
-    return value ? Number(value) : undefined;
-  }
-
-  public async setReleaseNotesTime(time: string): Promise<void> {
-    if (isNullOrEmpty(time)) {
-      await this.removeValue('show-notes');
-    } else {
-      await this.setValue('show-notes', time);
-    }
-  }
-
-  public async getIsTestnet(): Promise<boolean> {
-    const value = await this.getValue('testnet');
-    return value === "1";
-  }
-
-  public async setIsTestnet(isTestnet: boolean): Promise<void> {
-    await this.setValue('testnet', isTestnet ? "1" : "0");
-  }
-
-  public async getAutoLockSeconds(): Promise<number> {
-    const value = await this.getValue('auto-lock');
-    return value ? parseInt(value) : 60;
-  }
-
-  public async setAutoLockSeconds(autoLock: number): Promise<void> {
-    await this.setValue('auto-lock', `${autoLock}`);
-  }
-}

package/src/state/hooks.ts

@@ -1,47 +0,0 @@
-import { useSelector } from "react-redux";
-import type { SharedState } from "./store";
-import { createSelector } from "@reduxjs/toolkit";
-import type { AuthState } from "./slices";
-import type { Account, AppNotification, Balance, MarketData, SessionInfo, VaultInfo } from "../types";
-
-const useSharedSelector = useSelector.withTypes<SharedState>();
-
-export const useAuth = (): AuthState => useSharedSelector(state => state.auth);
-
-export const useMarketData = (tokenId: string): MarketData => useSharedSelector(state => state.market.data[tokenId]);
-
-export const useBlockHeight = (): number => useSharedSelector(state => state.status.height);
-
-export const useAccount = (id: number): Account => useSharedSelector(state => state.wallet.accounts[id]);
-export const useSelectedAccount = (): number => useSharedSelector(state => state.wallet.selectedAccount);
-export const useLastAccountId = (): number => useSharedSelector(state => Math.max(...Object.keys(state.wallet.accounts).map(Number)));
-
-export const useMainReceiveAddress = (account: number): string => useSharedSelector(state => state.wallet.accounts[account].address);
-
-export const useWalletBalance = (account: number): Balance => useSharedSelector(state => state.wallet.accounts[account].balance);
-export const useTokenBalance = (account: number, tokenIdHex: string): Balance => 
-  useSharedSelector(state => state.wallet.accounts[account].tokensBalance[tokenIdHex]);
-
-export const useDAppSession = (account: number, session: string): SessionInfo =>
-  useSharedSelector(state => state.wallet.accounts[account].sessions[session]);
-
-export const useVaults = (): Record<string, VaultInfo> => useSharedSelector(state => state.wallet.vaults);
-
-const selectWalletNotificationsArray = createSelector(
-  [(state: SharedState) => state.notifications.wallet],
-  (wallet) => Object.values(wallet).sort((a, b) => b.createdAt - a.createdAt)
-);
-
-const selectWeb3NotificationsArray = createSelector(
-  [(state: SharedState) => state.notifications.web3],
-  (web3) => Object.values(web3).sort((a, b) => b.createdAt - a.createdAt)
-);
-
-const selectAllNotificationsArray = createSelector(
-  [selectWalletNotificationsArray, selectWeb3NotificationsArray],
-  (wallet, web3) => [...wallet, ...web3].sort((a, b) => b.createdAt - a.createdAt)
-);
-
-export const useWalletNotifications = (): AppNotification[] => useSharedSelector(selectWalletNotificationsArray);
-export const useWeb3Notifications = (): AppNotification[] => useSharedSelector(selectWeb3NotificationsArray);
-export const useAllNotifications = (): AppNotification[] => useSharedSelector(selectAllNotificationsArray);

package/src/state/index.ts

@@ -1,3 +0,0 @@
-export * from './store';
-export * from './hooks';
-export * from './slices';

package/src/state/slices/auth.ts

@@ -1,28 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-
-export interface AuthState {
-  isWalletExist: boolean;
-  isAuthorized: boolean;
-}
-
-const initialState: AuthState = {
-  isWalletExist: false,
-  isAuthorized: false,
-};
-
-const authSlice = createSlice({
-  name: 'auth',
-  initialState,
-  reducers: {
-    setWalletExist: (state, action: PayloadAction<boolean>) => {
-      state.isWalletExist = action.payload;
-    },
-    setAuthorized: (state, action: PayloadAction<boolean>) => {
-      state.isAuthorized = action.payload;
-    }
-  }
-});
-
-export const authActions = authSlice.actions;
-export const authReducer = authSlice.reducer;

package/src/state/slices/dapp.ts

@@ -1,32 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-import type { SessionRequestType } from "../../utils";
-import type { DappRpcRequest } from "../../types";
-
-export interface DappModalState {
-  modalType: SessionRequestType | null;
-  currentRequest: DappRpcRequest | null;
-}
-
-const initialState: DappModalState = {
-  modalType: null,
-  currentRequest: null,
-};
-
-const dappModalSlice = createSlice({
-  name: 'dappModal',
-  initialState,
-  reducers: {
-    showRequest(state, action: PayloadAction<DappRpcRequest>) {
-      state.modalType = action.payload.type;
-      state.currentRequest = action.payload;
-    },
-    clear(state) {
-      state.modalType = null;
-      state.currentRequest = null;
-    },
-  },
-});
-
-export const dappModalActions = dappModalSlice.actions;
-export const dappModalReducer = dappModalSlice.reducer;

package/src/state/slices/index.ts

@@ -1,6 +0,0 @@
-export * from './loader';
-export * from './dapp';
-export * from './status';
-export * from './wallet';
-export * from './auth';
-export * from './notifications';

package/src/state/slices/loader.ts

@@ -1,31 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-
-export interface LoaderState {
-  counter: number
-  loading: boolean;
-  text?: string;
-}
-
-const initState: LoaderState = {
-  counter: 0,
-  loading: false
-}
-
-const loaderSlice = createSlice({
-  name: 'loader',
-  initialState: initState,
-  reducers: {
-    setLoader: (state, action: PayloadAction<Omit<LoaderState, 'counter'>>) => {
-      const counter = action.payload.loading
-        ? state.counter + 1
-        : Math.max(0, state.counter - 1);
-      state.counter = counter;
-      state.loading = counter > 0;
-      state.text = action.payload.text;
-    },
-  }
-});
-
-export const loaderActions = loaderSlice.actions;
-export const loaderReducer = loaderSlice.reducer;

package/src/state/slices/market.ts

@@ -1,47 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
-import type { MarketData } from "../../types";
-import type { CurrencyCode} from "../../utils";
-import { getMarketData } from "../../utils";
-import type { SharedState } from "../store";
-
-export interface MarketState {
-  currency: CurrencyCode;
-  data: Record<string, MarketData>;
-}
-
-const initialState: MarketState = {
-  currency: 'usd',
-  data: {}
-};
-
-const updateMarketData = createAsyncThunk('market/updateMarketData', async (_, thunkAPI) => {
-  const state = thunkAPI.getState() as SharedState;
-  return await getMarketData(state.market.currency);
-});
-
-const marketSlice = createSlice({
-  name: 'market',
-  initialState,
-  reducers: {
-    setCurrency: (state, action: PayloadAction<CurrencyCode>) => {
-      state.currency = action.payload;
-    },
-    setMarketData: (state, action: PayloadAction<Record<string, MarketData>>) => {
-      state.data = action.payload;
-    }
-  },
-  extraReducers: (builder) => {
-    builder
-      .addCase(updateMarketData.fulfilled, (state, action) => {
-        state.data = action.payload;
-      })
-      .addCase(updateMarketData.rejected, (_, action) => {
-        console.error(action.error.message);
-      });
-  }
-});
-
-export const marketThunks = { updateMarketData };
-export const marketActions = marketSlice.actions;
-export const marketReducer = marketSlice.reducer;

package/src/state/slices/notifications.ts

@@ -1,44 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-import type { AppNotification } from "../../types";
-
-export interface NotificationsState {
-  wallet: Record<string, AppNotification>;
-  web3: Record<string, AppNotification>;
-}
-
-const initialState: NotificationsState = {
-  wallet: {},
-  web3: {}
-};
-
-const notificationsSlice = createSlice({
-  name: 'notifications',
-  initialState,
-  reducers: {
-    addNotification: (state, action: PayloadAction<AppNotification>) => {
-      if (action.payload.type == 'wallet') {
-        state.wallet[action.payload.id] = action.payload;
-      } else if (action.payload.type == 'web3') {
-        state.web3[action.payload.id] = action.payload;
-      }
-    },
-    removeNotification: (state, action: PayloadAction<string>) => {
-      delete state.wallet[action.payload];
-      delete state.web3[action.payload];
-    },
-    clearAll: (state, action: PayloadAction<'wallet' | 'web3' | 'all'>) => {
-      if (action.payload === 'wallet') {
-        state.wallet = {};
-      } else if (action.payload === 'web3') {
-        state.web3 = {};
-      } else if (action.payload === 'all') {
-        state.wallet = {};
-        state.web3 = {};
-      }
-    }
-  }
-});
-
-export const notificationsActions = notificationsSlice.actions;
-export const notificationsReducer = notificationsSlice.reducer;

package/src/state/slices/status.ts

@@ -1,41 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-
-export interface StatusState {
-  status: "Online" | "Offline";
-  height: number;
-  hasNetwork: boolean;
-  isSuspended: boolean;
-}
-
-const initialState: StatusState = {
-  status: "Offline",
-  height: 0,
-  hasNetwork: true,
-  isSuspended: false,
-};
-
-const statusSlice = createSlice({
-  name: 'status',
-  initialState,
-  reducers: {
-    setHeight: (state, action: PayloadAction<number>) => {
-      if (action.payload > 0) {
-        state.status = "Online";
-      }
-      state.height = action.payload;
-    },
-    setOffline: (state) => {
-      state.status = "Offline";
-    },
-    setHasNetwork: (state, action: PayloadAction<boolean>) => {
-      state.hasNetwork = action.payload;
-    },
-    setIsSuspended: (state, action: PayloadAction<boolean>) => {
-      state.isSuspended = action.payload;
-    }
-  }
-});
-
-export const statusActions = statusSlice.actions;
-export const statusReducer = statusSlice.reducer;

package/src/state/slices/wallet.ts

@@ -1,107 +0,0 @@
-import type { PayloadAction } from "@reduxjs/toolkit";
-import { createSlice } from "@reduxjs/toolkit";
-import type { Account, Balance, SessionInfo, VaultInfo } from "../../types";
-import { MAIN_WALLET_ID } from "../../utils";
-
-interface AddSessionPayload {
-  accountId: number;
-  sessionInfo: SessionInfo;
-}
-
-interface RemoveSessionPayload {
-  accountId: number;
-  sessionId: string;
-}
-
-export interface WalletState {
-  isAuthorized: boolean;
-  selectedAccount: number;
-  accounts: Record<number, Account>;
-  vaults: Record<string, VaultInfo>;
-  sync: boolean;
-  initLoad: boolean;
-  txUpdateTrigger: number;
-  nftsUpdateTrigger: number;
-  tokensUpdateTrigger: number;
-}
-
-const initialState: WalletState = {
-  isAuthorized: false,
-  selectedAccount: MAIN_WALLET_ID,
-  accounts: {
-    "-1": {
-      id: MAIN_WALLET_ID,
-      name: 'Main Wallet',
-      address: '',
-      balance: {confirmed: "0", unconfirmed: "0"},
-      tokensBalance: {},
-      sessions: {}
-    }
-  },
-  vaults: {},
-  sync: false,
-  initLoad: true,
-  txUpdateTrigger: 0,
-  nftsUpdateTrigger: 0,
-  tokensUpdateTrigger: 0
-}
-
-const walletSlice = createSlice({
-  name: 'wallet',
-  initialState,
-  reducers: {
-    setInitLoad: (state, action: PayloadAction<boolean>) => {
-      state.initLoad = action.payload;
-    },
-    setSelectedAccount: (state, action: PayloadAction<number>) => {
-      state.selectedAccount = action.payload;
-    },
-    setSync: (state, action: PayloadAction<boolean>) => {
-      state.sync = action.payload;
-    },
-    setVault: (state, action: PayloadAction<VaultInfo>) => {
-      state.vaults[action.payload.address] = action.payload;
-    },
-    setVaultBalance: (state, action: PayloadAction<{ address: string, balance: Balance }>) => {
-      state.vaults[action.payload.address].balance = action.payload.balance;
-    },
-    setAccount: (state, action: PayloadAction<Account>) => {
-      state.accounts[action.payload.id] = action.payload;
-    },
-    setMainAddress: (state, action: PayloadAction<string>) => {
-      state.accounts[MAIN_WALLET_ID].address = action.payload;
-    },
-    setAccountBalance: (state, action: PayloadAction<{ id: number, balance: Balance, tokensBalance: Record<string, Balance> }>) => {
-      state.accounts[action.payload.id].balance = action.payload.balance;
-      state.accounts[action.payload.id].tokensBalance = action.payload.tokensBalance;
-    },
-    setAccountName: (state, action: PayloadAction<{ id: number, name: string }>) => {
-      state.accounts[action.payload.id].name = action.payload.name;
-    },
-    refreshTxs: (state) => {
-      state.txUpdateTrigger++;
-    },
-    refreshNfts: (state) => {
-      state.nftsUpdateTrigger++;
-    },
-    refreshTokens: (state) => {
-      state.tokensUpdateTrigger++;
-    },
-    addSession(state, action: PayloadAction<AddSessionPayload>) {
-      const { accountId, sessionInfo } = action.payload;
-      state.accounts[accountId].sessions[sessionInfo.details.sessionId] = sessionInfo;
-    },
-    removeSession(state, action: PayloadAction<RemoveSessionPayload>) {
-      const { accountId, sessionId } = action.payload;
-      if (state.accounts[accountId].sessions[sessionId]) {
-        delete state.accounts[accountId].sessions[sessionId];
-      }
-    },
-    clearSessions(state, action: PayloadAction<{ accountId: number }>) {
-      state.accounts[action.payload.accountId].sessions = {};
-    }
-  }
-});
-
-export const walletActions = walletSlice.actions;
-export const walletReducer = walletSlice.reducer;

package/src/state/store.ts

@@ -1,27 +0,0 @@
-import { authReducer } from "./slices/auth";
-import { dappModalReducer } from "./slices/dapp";
-import { loaderReducer } from "./slices/loader";
-import { marketReducer } from "./slices/market";
-import { notificationsReducer } from "./slices/notifications";
-import { statusReducer } from "./slices/status";
-import { walletReducer } from "./slices/wallet";
-
-export const sharedReducers = {
-  loader: loaderReducer,
-  dapp: dappModalReducer,
-  status: statusReducer,
-  wallet: walletReducer,
-  auth: authReducer,
-  notifications: notificationsReducer,
-  market: marketReducer,
-};
-
-export type SharedState = {
-  loader: ReturnType<typeof loaderReducer>;
-  dapp: ReturnType<typeof dappModalReducer>;
-  status: ReturnType<typeof statusReducer>;
-  wallet: ReturnType<typeof walletReducer>;
-  auth: ReturnType<typeof authReducer>;
-  notifications: ReturnType<typeof notificationsReducer>;
-  market: ReturnType<typeof marketReducer>;
-};