@otoplo/wallet-common 0.1.0

package/src/state/slices/auth.ts

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,32 @@
+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

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

package/src/state/slices/loader.ts

@@ -0,0 +1,31 @@
+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/notifications.ts

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,70 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
+import type { Price } from "../../types";
+import { getNexaPrices, initializePrices } from "../../utils";
+
+export interface StatusState {
+  status: "Online" | "Offline";
+  height: number;
+  price: Record<string, Price>;
+  hasNetwork: boolean;
+  isSuspended: boolean;
+}
+
+const initialState: StatusState = {
+  status: "Offline",
+  height: 0,
+  price: initializePrices(),
+  hasNetwork: true,
+  isSuspended: false,
+};
+
+export const fetchPrice = createAsyncThunk('status/fetchPrice', async () => {
+  const prices = initializePrices();
+  try {
+    const p = await getNexaPrices();
+    Object.keys(p).forEach(currency => {
+      prices[currency] = { 
+        value: p[currency],
+        change: p[`${currency}_24h_change`]
+      };
+    });
+  } catch {
+    // prices remain at 0
+  }
+  return prices ;
+});
+
+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;
+    }
+  },
+  extraReducers: (builder) => {
+    builder
+      .addCase(fetchPrice.fulfilled, (state, action) => {
+        state.price = action.payload;
+      })
+      .addCase(fetchPrice.rejected, (_, action) => {
+        console.error(action.error.message);
+      });
+  }
+});
+
+export const statusActions = statusSlice.actions;
+export const statusReducer = statusSlice.reducer;

package/src/state/slices/wallet.ts

@@ -0,0 +1,112 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+import type { Account, AssetEntity, 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;
+}
+
+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: {},
+      tokens: [],
+      sessions: {}
+    }
+  },
+  vaults: {},
+  sync: false,
+  initLoad: true,
+  txUpdateTrigger: 0,
+  nftsUpdateTrigger: 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;
+    },
+    setTokens: (state, action: PayloadAction<{ id: number, assets: AssetEntity[] }>) => {
+      state.accounts[action.payload.id].tokens = action.payload.assets;
+    },
+    addToken: (state, action: PayloadAction<{ id: number, asset: AssetEntity }>) => {
+      state.accounts[action.payload.id].tokens.unshift(action.payload.asset);
+    },
+    removeToken: (state, action: PayloadAction<{ id: number, tokenId: string }>) => {
+      state.accounts[action.payload.id].tokens = state.accounts[action.payload.id].tokens.filter(n => n.tokenIdHex !== action.payload.tokenId);
+    },
+    refreshTxs: (state) => {
+      state.txUpdateTrigger++;
+    },
+    refreshNfts: (state) => {
+      state.nftsUpdateTrigger++;
+    },
+    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

@@ -0,0 +1,24 @@
+import { authReducer } from "./slices/auth";
+import { dappModalReducer } from "./slices/dapp";
+import { loaderReducer } from "./slices/loader";
+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,
+};
+
+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>;
+};

package/src/types/dapp.types.ts

@@ -0,0 +1,21 @@
+import type { Transaction } from "libnexa-ts";
+import type { AssetInfo } from "./wallet.types";
+import type { SessionRequestType } from "../utils/enums";
+
+export interface DappRpcRequest {
+  type: SessionRequestType;
+  accountId: number;
+  sessionId: string;
+  request: any;
+}
+
+export interface TransactionDetails {
+  tx: Transaction;
+  send: MovementDetails[];
+  receive: MovementDetails[];
+}
+
+export interface MovementDetails {
+  asset?: AssetInfo;
+  amount: bigint;
+}

package/src/types/db.types.ts

@@ -0,0 +1,142 @@
+import type { AccountType, AssetType } from "../utils/enums";
+import type { Balance } from "./wallet.types";
+
+export interface AssetMovement {
+  address: string;
+  nexaAmount: string;
+  assetId: string;
+  assetAmount: string;
+}
+
+export type TransactionType = 'receive' | 'send' | 'swap' | 'self';
+
+export interface TransactionDTO {
+  accountId: number;
+  txIdem: string;
+  txId: string;
+  time: number;
+  height: number;
+  type: TransactionType;
+  fee: string;
+  othersOutputs: AssetMovement[];
+  myOutputs: AssetMovement[];
+  myInputs: AssetMovement[];
+}
+
+export interface TransactionEntity {
+  accountId: number;
+  txIdem: string;
+  txId: string;
+  time: number;
+  height: number;
+  type: TransactionType;
+  fee: string;
+  othersOutputs: string;
+  myOutputs: string;
+  myInputs: string;
+}
+
+export interface AssetTransactionEntity {
+  accountId: number;
+  assetId: string;
+  txIdem: string;
+  time: number;
+}
+
+export interface TokenEntity {
+  token: string;
+  tokenIdHex: string;
+  name: string;
+  ticker: string;
+  iconUrl: string;
+  decimals: number;
+  parentGroup: string;
+}
+
+export interface NftEntity {
+  token: string;
+  tokenIdHex: string;
+  parentGroup: string;
+  source: string;
+  collection: string;
+}
+
+export interface SessionEntity {
+  sessionId: string;
+  accountId: number;
+  uri: string;
+}
+
+export interface AccountDTO {
+  id: number;
+  name: string;
+  address: string;
+  height: number;
+  hidden: number;
+  statusHash: string;
+  balance: Balance;
+  tokensBalance: Record<string, Balance>;
+  type: AccountType;
+}
+
+export interface AccountEntity {
+  id: number;
+  name: string;
+  address: string;
+  height: number;
+  hidden: number;
+  statusHash: string;
+  balance: string;
+  tokensBalance: string;
+}
+
+export interface AssetEntity {
+  accountId: number;
+  tokenIdHex: string;
+  type: AssetType;
+  addedTime: number;
+}
+
+export interface AddressDTO {
+  address: string;
+  space: number;
+  idx: number;
+  used: boolean;
+  height: number;
+  statusHash: string;
+  balance: Balance;
+  tokensBalance: Record<string, Balance>;
+  type: AccountType;
+}
+
+export interface AddressEntity {
+  address: string;
+  space: number;
+  idx: number;
+  used: boolean;
+  height: number;
+  statusHash: string;
+  balance: string;
+  tokensBalance: string;
+}
+
+export interface VaultDTO {
+  address: string;
+  idx: number;
+  block: number;
+  height: number;
+  statusHash: string;
+  balance: Balance;
+  tokensBalance: Record<string, Balance>;
+  type: AccountType;
+}
+
+export interface VaultEntity {
+  address: string;
+  idx: number;
+  block: number;
+  height: number;
+  statusHash: string;
+  balance: string;
+  tokensBalance: string;
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export type * from './db.types';
+export type * from './wallet.types';
+export type * from './rostrum.types';
+export type * from './dapp.types';
+export type * from './notification.types';

package/src/types/notification.types.ts

@@ -0,0 +1,13 @@
+export type NotificationAction =
+  | { type: 'DAPP_REQUEST'; account: number; sessionId: string; payload: string; }
+  | { type: 'DISPATCH'; actionType: string; payload?: any }
+  | { type: 'NONE' };
+
+export interface AppNotification {
+  id: string;
+  type: 'wallet' | 'web3';
+  title: string;
+  message?: string;
+  createdAt: number;
+  action?: NotificationAction;
+}

package/src/types/rostrum.types.ts

@@ -0,0 +1,161 @@
+import type { TransportScheme } from "@otoplo/electrum-client";
+
+export interface RostrumParams {
+  scheme: TransportScheme;
+  host: string;
+  port: number;
+  label: string;
+}
+
+export interface ServerFeatures {
+  genesis_hash: string;
+  server_version: string;
+}
+
+export interface BlockTip {
+  height: number;
+  hex: string;
+}
+
+export interface IFirstUse {
+  block_hash: string;
+  block_height: number;
+  height: number;
+  tx_hash: string;
+}
+
+export interface ITokenGenesis {
+  decimal_places?: number,
+  document_hash?: string;
+  document_url?: string;
+  group: string;
+  height: number;
+  name?: string;
+  op_return?: string;
+  ticker?: string;
+  token_id_hex: string;
+  txid: string;
+  txidem: string;
+  op_return_id: number;
+}
+
+export interface ITokensBalance {
+  cursor?: any;
+  confirmed: Record<string, string | number>;
+  unconfirmed: Record<string, string | number>;
+}
+
+export interface ITokenListUnspent {
+  cursor?: any;
+  unspent: ITokenUtxo[];
+}
+
+export interface ITokenUtxo {
+  group: string;
+  height: number;
+  outpoint_hash: string;
+  token_amount: number | string;
+  token_id_hex: string;
+  tx_hash: string;
+  tx_pos: number;
+  value: number;
+}
+
+export interface IListUnspentRecord {
+  has_token: boolean;
+  height: number;
+  outpoint_hash: string;
+  tx_hash: string;
+  tx_pos: number;
+  value: number;
+}
+
+export interface IUtxo {
+  addresses: string[];
+  amount: number;
+  group: string;
+  group_authority: string | number;
+  group_quantity: string | number;
+  height: number;
+  scripthash: string;
+  scriptpubkey: string;
+  spent: ISpent;
+  status: string;
+  template_argumenthash: string;
+  template_scripthash: string;
+  token_id_hex: string;
+  tx_hash: string;
+  tx_idem: string;
+  tx_pos: number;
+}
+
+export interface ISpent {
+  height: number;
+  tx_hash: string;
+  tx_pos: number;
+}
+
+export interface ITransaction {
+  blockhash: string;
+  blocktime: number;
+  confirmations: number;
+  fee: number;
+  fee_satoshi: number;
+  hash: string;
+  height: number;
+  hex: string;
+  locktime: number;
+  size: number;
+  time: number;
+  txid: string;
+  txidem: string;
+  version: number;
+  vin: ITXInput[];
+  vout: ITXOutput[];
+}
+
+export interface ITXInput {
+  outpoint: string;
+  scriptSig: IScriptSig;
+  sequence: number;
+  value: number;
+  value_satoshi: string | number;
+  addresses: string[];
+  group: string;
+  groupAuthority: string | number;
+  groupQuantity: string | number;
+  token_id_hex?: string;
+}
+
+export interface ITXOutput {
+  n: number;
+  outpoint_hash: string;
+  scriptPubKey: IScriptPubKey;
+  type: number;
+  value: number;
+  value_satoshi: string | number;
+}
+
+export interface IScriptSig {
+  asm: string;
+  hex: string;
+}
+
+export interface IScriptPubKey {
+  addresses: string[];
+  argHash: string;
+  asm: string;
+  group: string;
+  groupAuthority: string | number;
+  groupQuantity: string | number;
+  hex: string;
+  scriptHash: string;
+  token_id_hex?: string;
+  type: string;
+}
+
+export interface ITXHistory {
+  fee?: number;
+  height: number;
+  tx_hash: string;
+}