Restricted asset account

package.json

@@ -31,7 +31,8 @@
     "decimal.js": "^10.2.1",
     "formik": "^2.2.6",
     "google-protobuf": "^3.15.8",
-    "ldk": "^0.3.9",
+    "ldk": "^0.3.14",
+    "liquidjs-lib": "^5.2.2",
     "lodash.debounce": "^4.0.8",
     "lottie-web": "^5.7.8",
     "marina-provider": "^1.4.3",

src/application/redux/actions/action-types.ts

@@ -1,14 +1,14 @@
 // Wallet
 export const WALLET_SET_DATA = 'WALLET_SET_DATA';
+export const SET_RESTRICTED_ASSET_ACCOUNT = 'SET_RESTRICTED_ASSET_ACCOUNT';
 export const ADD_UTXO = 'ADD_UTXO';
 export const DELETE_UTXO = 'DELETE_UTXO';
 export const FLUSH_UTXOS = 'FLUSH_UTXOS';
-export const UPDATE_UTXOS = 'UPDATE_UTXOS';
 export const SET_DEEP_RESTORER_GAP_LIMIT = 'SET_DEEP_RESTORER_GAP_LIMIT';
 export const SET_DEEP_RESTORER_IS_LOADING = 'SET_DEEP_RESTORER_IS_LOADING';
 export const SET_DEEP_RESTORER_ERROR = 'SET_DEEP_RESTORER_ERROR';
-export const NEW_ADDRESS_SUCCESS = 'NEW_ADDRESS_SUCCESS';
-export const NEW_CHANGE_ADDRESS_SUCCESS = 'NEW_CHANGE_ADDRESS_SUCCESS';
+export const INCREMENT_EXTERNAL_ADDRESS_INDEX = 'INCREMENT_EXTERNAL_ADDRESS_INDEX';
+export const INCREMENT_INTERNAL_ADDRESS_INDEX = 'INCREMENT_INTERNAL_ADDRESS_INDEX';
 export const SET_VERIFIED = 'SET_VERIFIED';
 export const RESET_WALLET = 'RESET_WALLET';
 
@@ -27,9 +27,7 @@ export const ONBOARDING_FLUSH = 'ONBOARDING_FLUSH';
 export const ONBOARDING_SET_IS_FROM_POPUP_FLOW = 'ONBOARDING_SET_IS_FROM_POPUP_FLOW';
 
 // Transactions history
-export const UPDATE_TXS = 'UPDATE_TXS';
 export const ADD_TX = 'ADD_TX';
-export const RESET_TXS = 'RESET_TXS';
 
 // Pending transaction
 export const PENDING_TX_SET_ASSET = 'PENDING_TX_SET_ASSET';
@@ -51,6 +49,7 @@ export const SET_MSG = 'SET_MSG';
 export const FLUSH_MSG = 'FLUSH_MSG';
 export const SELECT_HOSTNAME = 'SELECT_HOSTNAME';
 export const FLUSH_SELECTED_HOSTNAME = 'FLUSH_SELECTED_HOSTNAME';
+export const SET_APPROVE_REQUEST_PARAM = 'SET_APPROVE_REQUEST_PARAM';
 export const RESET_CONNECT = 'RESET_CONNECT';
 
 // Taxi
@@ -66,3 +65,10 @@ export const START_DEEP_RESTORATION = 'START_DEEP_RESTORATION';
 
 // Reset
 export const RESET = 'RESET';
+
+// Updater
+export const PUSH_UPDATER_TASK = 'PUSH_UPDATER_TASK';
+export const POP_UPDATER_TASK = 'POP_UPDATER_TASK';
+
+// Allowance
+export const ALLOW_COIN = 'ALLOW_COIN';

src/application/redux/actions/allowance.ts

@@ -0,0 +1,25 @@
+import { Outpoint } from 'ldk';
+import { ActionWithPayload } from '../../../domain/common';
+import { AssetAmount } from '../../../domain/connect';
+import { ALLOW_COIN, SET_APPROVE_REQUEST_PARAM } from './action-types';
+
+export function addAllowedCoin(utxo: Outpoint): ActionWithPayload<Outpoint> {
+  return {
+    type: ALLOW_COIN,
+    payload: {
+      txid: utxo.txid,
+      vout: utxo.vout,
+    },
+  };
+}
+
+export function setApproveParams(
+  assetAmounts: AssetAmount[]
+): ActionWithPayload<{ assetAmounts: AssetAmount[] }> {
+  return {
+    type: SET_APPROVE_REQUEST_PARAM,
+    payload: {
+      assetAmounts,
+    },
+  };
+}

src/application/redux/actions/transaction.ts

@@ -4,14 +4,15 @@ import {
   PENDING_TX_SET_ADDRESSES_AND_AMOUNT,
   PENDING_TX_SET_FEE_CHANGE_ADDRESS,
   PENDING_TX_SET_FEE_AMOUNT_AND_ASSET,
-  UPDATE_TXS,
   PENDING_TX_SET_PSET,
   ADD_TX,
 } from './action-types';
 import { AnyAction } from 'redux';
 import { Address } from '../../../domain/address';
 import { TxDisplayInterface } from '../../../domain/transaction';
 import { Network } from '../../../domain/network';
+import { AccountID } from '../../../domain/account';
+import { UtxoInterface } from 'ldk';
 
 export function setAsset(asset: string): AnyAction {
   return { type: PENDING_TX_SET_ASSET, payload: { asset } };
@@ -40,22 +41,16 @@ export function flushPendingTx(): AnyAction {
   return { type: PENDING_TX_FLUSH };
 }
 
-export function updateTxs(): AnyAction {
-  return {
-    type: UPDATE_TXS,
-  };
-}
-
-export function setPset(pset: string): AnyAction {
+export function setPset(pset: string, utxos: UtxoInterface[]): AnyAction {
   return {
     type: PENDING_TX_SET_PSET,
-    payload: { pset },
+    payload: { pset, utxos },
   };
 }
 
-export function addTx(tx: TxDisplayInterface, network: Network): AnyAction {
+export function addTx(accountID: AccountID, tx: TxDisplayInterface, network: Network): AnyAction {
   return {
     type: ADD_TX,
-    payload: { tx, network },
+    payload: { tx, network, accountID },
   };
 }

src/application/redux/actions/updater.ts

@@ -0,0 +1,27 @@
+import { AccountID } from '../../../domain/account';
+import { UpdaterTaskType } from '../reducers/updater-reducer';
+import { PUSH_UPDATER_TASK } from './action-types';
+
+export function utxosUpdateTask(accountID: AccountID) {
+  return {
+    type: PUSH_UPDATER_TASK,
+    payload: {
+      updaterTask: {
+        accountID,
+        type: UpdaterTaskType.UTXO,
+      },
+    },
+  };
+}
+
+export function txsUpdateTask(accountID: AccountID) {
+  return {
+    type: PUSH_UPDATER_TASK,
+    payload: {
+      updaterTask: {
+        accountID,
+        type: UpdaterTaskType.TX,
+      },
+    },
+  };
+}

src/application/redux/actions/utxos.ts

@@ -1,19 +1,16 @@
 import { UtxoInterface } from 'ldk';
 import { AnyAction } from 'redux';
-import { ADD_UTXO, DELETE_UTXO, FLUSH_UTXOS, UPDATE_UTXOS } from './action-types';
+import { AccountID } from '../../../domain/account';
+import { ADD_UTXO, DELETE_UTXO, FLUSH_UTXOS } from './action-types';
 
-export function updateUtxos(): AnyAction {
-  return { type: UPDATE_UTXOS };
+export function addUtxo(accountID: AccountID, utxo: UtxoInterface): AnyAction {
+  return { type: ADD_UTXO, payload: { accountID, utxo } };
 }
 
-export function addUtxo(utxo: UtxoInterface): AnyAction {
-  return { type: ADD_UTXO, payload: { utxo } };
+export function deleteUtxo(accountID: AccountID, txid: string, vout: number): AnyAction {
+  return { type: DELETE_UTXO, payload: { txid, vout, accountID } };
 }
 
-export function deleteUtxo(txid: string, vout: number): AnyAction {
-  return { type: DELETE_UTXO, payload: { txid, vout } };
-}
-
-export function flushUtxos(): AnyAction {
-  return { type: FLUSH_UTXOS };
+export function flushUtxos(accountID: AccountID): AnyAction {
+  return { type: FLUSH_UTXOS, payload: { accountID } };
 }

src/application/redux/actions/wallet.ts

@@ -4,13 +4,25 @@ import {
   SET_DEEP_RESTORER_GAP_LIMIT,
   SET_DEEP_RESTORER_ERROR,
   START_DEEP_RESTORATION,
-  NEW_ADDRESS_SUCCESS,
-  NEW_CHANGE_ADDRESS_SUCCESS,
+  INCREMENT_EXTERNAL_ADDRESS_INDEX,
+  INCREMENT_INTERNAL_ADDRESS_INDEX,
   SET_VERIFIED,
+  SET_RESTRICTED_ASSET_ACCOUNT,
 } from './action-types';
 import { AnyAction } from 'redux';
 import { WalletData } from '../../utils/wallet';
 import { extractErrorMessage } from '../../../presentation/utils/error';
+import { AccountID, MultisigAccountData } from '../../../domain/account';
+import { CosignerExtraData } from '../../../domain/wallet';
+
+export function setRestrictedAssetData(
+  multisigAccountData: MultisigAccountData<CosignerExtraData>
+) {
+  return {
+    type: SET_RESTRICTED_ASSET_ACCOUNT,
+    payload: { multisigAccountData },
+  };
+}
 
 export function setWalletData(walletData: WalletData): AnyAction {
   return {
@@ -19,12 +31,12 @@ export function setWalletData(walletData: WalletData): AnyAction {
   };
 }
 
-export function incrementAddressIndex(): AnyAction {
-  return { type: NEW_ADDRESS_SUCCESS };
+export function incrementAddressIndex(accountID: AccountID): AnyAction {
+  return { type: INCREMENT_EXTERNAL_ADDRESS_INDEX, payload: { accountID } };
 }
 
-export function incrementChangeAddressIndex(): AnyAction {
-  return { type: NEW_CHANGE_ADDRESS_SUCCESS };
+export function incrementChangeAddressIndex(accountID: AccountID): AnyAction {
+  return { type: INCREMENT_INTERNAL_ADDRESS_INDEX, payload: { accountID } };
 }
 
 export function setDeepRestorerIsLoading(isLoading: boolean): AnyAction {

src/application/redux/containers/address-amount.container.ts

@@ -1,19 +1,19 @@
 import { connect } from 'react-redux';
+import { MainAccountID, RestrictedAssetAccountID } from '../../../domain/account';
 import { assetGetterFromIAssets } from '../../../domain/assets';
 import { RootReducerState } from '../../../domain/common';
 import AddressAmountView, {
   AddressAmountProps,
 } from '../../../presentation/wallet/send/address-amount';
-import { balancesSelector } from '../selectors/balance.selector';
-import { masterPubKeySelector, restorerOptsSelector } from '../selectors/wallet.selector';
+import { selectBalances } from '../selectors/balance.selector';
+import { selectMainAccount } from '../selectors/wallet.selector';
 
 const mapStateToProps = (state: RootReducerState): AddressAmountProps => ({
+  account: selectMainAccount(state),
   network: state.app.network,
   transaction: state.transaction,
   assets: state.assets,
-  balances: balancesSelector(state),
-  masterPubKey: masterPubKeySelector(state),
-  restorerOpts: restorerOptsSelector(state),
+  balances: selectBalances(MainAccountID, RestrictedAssetAccountID)(state),
   transactionAsset: assetGetterFromIAssets(state.assets)(state.transaction.sendAsset),
 });
 

src/application/redux/containers/choose-fee.container.ts

@@ -1,23 +1,23 @@
 import { connect } from 'react-redux';
+import { MainAccountID, RestrictedAssetAccountID } from '../../../domain/account';
 import { RootReducerState } from '../../../domain/common';
 import ChooseFeeView, { ChooseFeeProps } from '../../../presentation/wallet/send/choose-fee';
 import { lbtcAssetByNetwork } from '../../utils';
-import { balancesSelector } from '../selectors/balance.selector';
-import { masterPubKeySelector, restorerOptsSelector } from '../selectors/wallet.selector';
+import { selectBalances } from '../selectors/balance.selector';
+import { selectMainAccount, selectUtxos } from '../selectors/wallet.selector';
 
 const mapStateToProps = (state: RootReducerState): ChooseFeeProps => ({
-  wallet: state.wallet,
   network: state.app.network,
   assets: state.assets,
-  balances: balancesSelector(state),
+  balances: selectBalances(MainAccountID, RestrictedAssetAccountID)(state),
   taxiAssets: state.taxi.taxiAssets,
   lbtcAssetHash: lbtcAssetByNetwork(state.app.network),
-  masterPubKey: masterPubKeySelector(state),
-  restorerOpts: restorerOptsSelector(state),
   sendAddress: state.transaction.sendAddress,
   changeAddress: state.transaction.changeAddress,
   sendAsset: state.transaction.sendAsset,
   sendAmount: state.transaction.sendAmount,
+  account: selectMainAccount(state),
+  utxos: selectUtxos(MainAccountID, RestrictedAssetAccountID)(state),
 });
 
 const ChooseFee = connect(mapStateToProps)(ChooseFeeView);

src/application/redux/containers/cosigners.container.ts

@@ -0,0 +1,15 @@
+import { connect } from 'react-redux';
+import { RootReducerState } from '../../../domain/common';
+import SettingsCosignersView, {
+  SettingsCosignersProps,
+} from '../../../presentation/settings/cosigners';
+
+const SettingsCosigner = connect(
+  (state: RootReducerState): SettingsCosignersProps => ({
+    multisigAccountsData: state.wallet.restrictedAssetAccount
+      ? [state.wallet.restrictedAssetAccount]
+      : [],
+  })
+)(SettingsCosignersView);
+
+export default SettingsCosigner;

src/application/redux/containers/end-of-flow.container.ts

@@ -2,14 +2,14 @@ import { connect } from 'react-redux';
 import { RootReducerState } from '../../../domain/common';
 import EndOfFlow, { EndOfFlowProps } from '../../../presentation/wallet/send/end-of-flow';
 import { getExplorerURLSelector } from '../selectors/app.selector';
+import { selectAllAccounts } from '../selectors/wallet.selector';
 
 const mapStateToProps = (state: RootReducerState): EndOfFlowProps => ({
-  wallet: state.wallet,
-  network: state.app.network,
-  restorerOpts: state.wallet.restorerOpts,
+  accounts: selectAllAccounts(state),
   pset: state.transaction.pset,
   explorerURL: getExplorerURLSelector(state),
   recipientAddress: state.transaction.sendAddress?.value,
+  selectedUtxos: state.transaction.selectedUtxos ?? [],
 });
 
 const SendEndOfFlow = connect(mapStateToProps)(EndOfFlow);

src/application/redux/containers/home.container.ts

@@ -1,15 +1,16 @@
 import { RootReducerState } from './../../../domain/common';
 import { connect } from 'react-redux';
 import HomeView, { HomeProps } from '../../../presentation/wallet/home';
-import { balancesSelector } from '../selectors/balance.selector';
+import { selectBalances } from '../selectors/balance.selector';
 import { assetGetterFromIAssets } from '../../../domain/assets';
 import { lbtcAssetByNetwork } from '../../utils';
+import { MainAccountID, RestrictedAssetAccountID } from '../../../domain/account';
 
 const mapStateToProps = (state: RootReducerState): HomeProps => ({
   lbtcAssetHash: lbtcAssetByNetwork(state.app.network),
   network: state.app.network,
   transactionStep: state.transaction.step,
-  assetsBalance: balancesSelector(state),
+  assetsBalance: selectBalances(MainAccountID, RestrictedAssetAccountID)(state),
   getAsset: assetGetterFromIAssets(state.assets),
   isWalletVerified: state.wallet.isVerified,
 });

src/application/redux/containers/pair.container.ts

@@ -0,0 +1,14 @@
+import { connect } from 'react-redux';
+import { RootReducerState } from '../../../domain/common';
+import PairCosignerView, { PairCosignerProps } from '../../../presentation/cosigner/pair';
+import { getExplorerURLSelector } from '../selectors/app.selector';
+
+const mapStateToProps = (state: RootReducerState): PairCosignerProps => ({
+  encryptedMnemonic: state.wallet.mainAccount.encryptedMnemonic,
+  explorerURL: getExplorerURLSelector(state),
+  network: state.app.network,
+});
+
+const PairCosigner = connect(mapStateToProps)(PairCosignerView);
+
+export default PairCosigner;

src/application/redux/containers/receive-select-asset.container.ts

@@ -1,17 +1,19 @@
 import { connect } from 'react-redux';
+import { MainAccountID, RestrictedAssetAccountID } from '../../../domain/account';
 import { assetGetterFromIAssets } from '../../../domain/assets';
 import { RootReducerState } from '../../../domain/common';
 import ReceiveSelectAssetView, {
   ReceiveSelectAssetProps,
 } from '../../../presentation/wallet/receive/receive-select-asset';
-import { balancesSelector } from '../selectors/balance.selector';
+import { selectBalances } from '../selectors/balance.selector';
 
 const mapStateToProps = (state: RootReducerState): ReceiveSelectAssetProps => {
-  const balances = balancesSelector(state);
+  const balances = selectBalances(MainAccountID, RestrictedAssetAccountID)(state);
   const getAsset = assetGetterFromIAssets(state.assets);
   return {
     network: state.app.network,
     assets: Object.keys(balances).map(getAsset),
+    restrictedAssetSetup: state.wallet.restrictedAssetAccount !== undefined,
   };
 };