320 lines
11 KiB
TypeScript
320 lines
11 KiB
TypeScript
import { SagaIterator, delay, Task } from 'redux-saga';
|
|
import { apply, call, fork, put, select, takeEvery, take, cancel } from 'redux-saga/effects';
|
|
|
|
import { translateRaw } from 'translations';
|
|
import { INode } from 'libs/nodes/INode';
|
|
import { Wei } from 'libs/units';
|
|
import { Token } from 'types/network';
|
|
import {
|
|
IWallet,
|
|
MnemonicWallet,
|
|
getPrivKeyWallet,
|
|
getKeystoreWallet,
|
|
determineKeystoreType,
|
|
KeystoreTypes,
|
|
getUtcWallet,
|
|
signWrapper,
|
|
WalletConfig
|
|
} from 'libs/wallet';
|
|
import { loadWalletConfig, saveWalletConfig } from 'utils/localStorage';
|
|
import { AppState } from 'features/reducers';
|
|
import * as derivedSelectors from 'features/selectors';
|
|
import * as configMetaTypes from 'features/config/meta/types';
|
|
import * as configMetaSelectors from 'features/config/meta/selectors';
|
|
import * as configNodesSelectors from 'features/config/nodes/selectors';
|
|
import * as configSelectors from 'features/config/selectors';
|
|
import { notificationsActions } from 'features/notifications';
|
|
import { customTokensTypes, customTokensSelectors } from 'features/customTokens';
|
|
import * as types from './types';
|
|
import * as actions from './actions';
|
|
import * as selectors from './selectors';
|
|
|
|
export function* getTokenBalancesSaga(wallet: IWallet, tokens: Token[]) {
|
|
const node: INode = yield select(configNodesSelectors.getNodeLib);
|
|
const address: string = yield apply(wallet, wallet.getAddressString);
|
|
const tokenBalances: types.TokenBalance[] = yield apply(node, node.getTokenBalances, [
|
|
address,
|
|
tokens
|
|
]);
|
|
return tokens.reduce<{ [TokenSymbol: string]: types.TokenBalance }>((acc, t, i) => {
|
|
acc[t.symbol] = tokenBalances[i];
|
|
return acc;
|
|
}, {});
|
|
}
|
|
|
|
// Return an array of the tokens that meet any of the following conditions:
|
|
// 1. Non-zero balance
|
|
// 2. It was in the previous wallet's config
|
|
// 3. It's a custom token that the user added
|
|
export function* filterScannedTokenBalances(wallet: IWallet, balances: types.TokenBalanceLookup) {
|
|
const customTokens: AppState['customTokens'] = yield select(
|
|
customTokensSelectors.getCustomTokens
|
|
);
|
|
const oldConfig: WalletConfig = yield call(loadWalletConfig, wallet);
|
|
return Object.keys(balances).filter(symbol => {
|
|
if (balances[symbol] && !balances[symbol].balance.isZero()) {
|
|
return true;
|
|
}
|
|
if (oldConfig.tokens && oldConfig.tokens.includes(symbol)) {
|
|
return true;
|
|
}
|
|
if (customTokens.find(token => token.symbol === symbol)) {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
export function* updateAccountBalance(): SagaIterator {
|
|
try {
|
|
const isOffline = yield select(configMetaSelectors.getOffline);
|
|
if (isOffline) {
|
|
return;
|
|
}
|
|
|
|
yield put(actions.setBalancePending());
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
if (!wallet) {
|
|
return;
|
|
}
|
|
const node: INode = yield select(configNodesSelectors.getNodeLib);
|
|
const address: string = yield apply(wallet, wallet.getAddressString);
|
|
// network request
|
|
const balance: Wei = yield apply(node, node.getBalance, [address]);
|
|
yield put(actions.setBalanceFullfilled(balance));
|
|
} catch (error) {
|
|
yield put(actions.setBalanceRejected());
|
|
}
|
|
}
|
|
|
|
export function* retryTokenBalances(): SagaIterator {
|
|
const tokens: types.MergedToken[] = yield select(derivedSelectors.getWalletConfigTokens);
|
|
if (tokens && tokens.length) {
|
|
yield call(updateTokenBalances);
|
|
} else {
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
if (wallet) {
|
|
yield call(scanWalletForTokensSaga, wallet);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function* updateTokenBalances(): SagaIterator {
|
|
try {
|
|
const isOffline = yield select(configMetaSelectors.getOffline);
|
|
if (isOffline) {
|
|
return;
|
|
}
|
|
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
const tokens: types.MergedToken[] = yield select(derivedSelectors.getWalletConfigTokens);
|
|
if (!wallet || !tokens.length) {
|
|
return;
|
|
}
|
|
yield put(actions.setTokenBalancesPending());
|
|
const tokenBalances: types.TokenBalanceLookup = yield call(
|
|
getTokenBalancesSaga,
|
|
wallet,
|
|
tokens
|
|
);
|
|
yield put(actions.setTokenBalancesFulfilled(tokenBalances));
|
|
} catch (error) {
|
|
console.error('Failed to get token balances', error);
|
|
yield put(actions.setTokenBalancesRejected());
|
|
}
|
|
}
|
|
|
|
export function* updateTokenBalance(action: types.SetTokenBalancePendingAction): SagaIterator {
|
|
try {
|
|
const isOffline = yield select(configMetaSelectors.getOffline);
|
|
if (isOffline) {
|
|
return;
|
|
}
|
|
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
const { tokenSymbol } = action.payload;
|
|
const allTokens: Token[] = yield select(configSelectors.getAllTokens);
|
|
const token = allTokens.find(t => t.symbol === tokenSymbol);
|
|
|
|
if (!wallet) {
|
|
return;
|
|
}
|
|
|
|
if (!token) {
|
|
throw Error('Token not found');
|
|
}
|
|
|
|
const tokenBalances: types.TokenBalanceLookup = yield call(getTokenBalancesSaga, wallet, [
|
|
token
|
|
]);
|
|
|
|
yield put(actions.setTokenBalanceFulfilled(tokenBalances));
|
|
} catch (error) {
|
|
console.error('Failed to get token balance', error);
|
|
yield put(actions.setTokenBalanceRejected());
|
|
}
|
|
}
|
|
|
|
export function* handleScanWalletAction(action: types.ScanWalletForTokensAction): SagaIterator {
|
|
yield call(scanWalletForTokensSaga, action.payload);
|
|
}
|
|
|
|
export function* scanWalletForTokensSaga(wallet: IWallet): SagaIterator {
|
|
try {
|
|
const isOffline = yield select(configMetaSelectors.getOffline);
|
|
if (isOffline) {
|
|
return;
|
|
}
|
|
|
|
const tokens: types.MergedToken[] = yield select(derivedSelectors.getTokens);
|
|
yield put(actions.setTokenBalancesPending());
|
|
|
|
// Fetch all token balances, save ones we want to the config
|
|
const balances: types.TokenBalanceLookup = yield call(getTokenBalancesSaga, wallet, tokens);
|
|
const tokensToSave: string[] = yield call(filterScannedTokenBalances, wallet, balances);
|
|
const config: WalletConfig = yield call(saveWalletConfig, wallet, { tokens: tokensToSave });
|
|
yield put(actions.setWalletConfig(config));
|
|
|
|
yield put(actions.setTokenBalancesFulfilled(balances));
|
|
} catch (err) {
|
|
console.error('Failed to scan for tokens', err);
|
|
yield put(actions.setTokenBalancesRejected());
|
|
}
|
|
}
|
|
|
|
export function* handleSetWalletTokens(action: types.SetWalletTokensAction): SagaIterator {
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
if (!wallet) {
|
|
return;
|
|
}
|
|
|
|
const config: WalletConfig = yield call(saveWalletConfig, wallet, { tokens: action.payload });
|
|
yield put(actions.setWalletConfig(config));
|
|
}
|
|
|
|
export function* updateBalances(): SagaIterator {
|
|
const updateAccount = yield fork(updateAccountBalance);
|
|
const updateToken = yield fork(updateTokenBalances);
|
|
|
|
yield take(types.WalletActions.SET);
|
|
yield cancel(updateAccount);
|
|
yield cancel(updateToken);
|
|
}
|
|
|
|
export function* handleNewWallet(): SagaIterator {
|
|
yield call(updateWalletConfig);
|
|
yield fork(updateBalances);
|
|
}
|
|
|
|
export function* updateWalletConfig(): SagaIterator {
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
if (!wallet) {
|
|
return;
|
|
}
|
|
const config: WalletConfig = yield call(loadWalletConfig, wallet);
|
|
yield put(actions.setWalletConfig(config));
|
|
}
|
|
|
|
export function* unlockPrivateKeySaga(action: types.UnlockPrivateKeyAction): SagaIterator {
|
|
let wallet: IWallet | null = null;
|
|
const { key, password } = action.payload;
|
|
|
|
try {
|
|
wallet = getPrivKeyWallet(key, password);
|
|
} catch (e) {
|
|
yield put(notificationsActions.showNotification('danger', translateRaw('INVALID_PKEY')));
|
|
return;
|
|
}
|
|
yield put(actions.setWallet(wallet));
|
|
}
|
|
|
|
export function* startLoadingSpinner(): SagaIterator {
|
|
yield call(delay, 400);
|
|
yield put(actions.setWalletPending(true));
|
|
}
|
|
|
|
export function* stopLoadingSpinner(loadingFork: Task | null): SagaIterator {
|
|
if (loadingFork !== null && loadingFork !== undefined) {
|
|
yield cancel(loadingFork);
|
|
}
|
|
yield put(actions.setWalletPending(false));
|
|
}
|
|
|
|
export function* unlockKeystoreSaga(action: types.UnlockKeystoreAction): SagaIterator {
|
|
const { file, password } = action.payload;
|
|
let wallet: null | IWallet = null;
|
|
let spinnerTask: null | Task = null;
|
|
try {
|
|
if (determineKeystoreType(file) === KeystoreTypes.utc) {
|
|
spinnerTask = yield fork(startLoadingSpinner);
|
|
wallet = signWrapper(yield call(getUtcWallet, file, password));
|
|
} else {
|
|
wallet = getKeystoreWallet(file, password);
|
|
}
|
|
} catch (e) {
|
|
yield call(stopLoadingSpinner, spinnerTask);
|
|
if (
|
|
password === '' &&
|
|
e.message === 'Private key does not satisfy the curve requirements (ie. it is invalid)'
|
|
) {
|
|
yield put(actions.setPasswordPrompt());
|
|
} else {
|
|
yield put(notificationsActions.showNotification('danger', translateRaw('ERROR_6')));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// TODO: provide a more descriptive error than the two 'ERROR_6' (invalid pass) messages above
|
|
yield call(stopLoadingSpinner, spinnerTask);
|
|
yield put(actions.setWallet(wallet));
|
|
}
|
|
|
|
export function* unlockMnemonicSaga(action: types.UnlockMnemonicAction): SagaIterator {
|
|
let wallet;
|
|
const { phrase, pass, path, address } = action.payload;
|
|
|
|
try {
|
|
wallet = MnemonicWallet(phrase, pass, path, address);
|
|
} catch (err) {
|
|
// TODO: use better error than 'ERROR_14' (wallet not found)
|
|
yield put(notificationsActions.showNotification('danger', translateRaw('ERROR_14')));
|
|
return;
|
|
}
|
|
|
|
yield put(actions.setWallet(wallet));
|
|
}
|
|
|
|
export function* handleCustomTokenAdd(
|
|
action: customTokensTypes.AddCustomTokenAction
|
|
): SagaIterator {
|
|
// Add the custom token to our current wallet's config
|
|
const wallet: null | IWallet = yield select(selectors.getWalletInst);
|
|
if (!wallet) {
|
|
return;
|
|
}
|
|
const oldConfig: WalletConfig = yield call(loadWalletConfig, wallet);
|
|
const config: WalletConfig = yield call(saveWalletConfig, wallet, {
|
|
tokens: [...(oldConfig.tokens || []), action.payload.symbol]
|
|
});
|
|
yield put(actions.setWalletConfig(config));
|
|
|
|
// Update token balances
|
|
yield fork(updateTokenBalances);
|
|
}
|
|
|
|
export function* walletSaga(): SagaIterator {
|
|
yield [
|
|
takeEvery(types.WalletActions.UNLOCK_PRIVATE_KEY, unlockPrivateKeySaga),
|
|
takeEvery(types.WalletActions.UNLOCK_KEYSTORE, unlockKeystoreSaga),
|
|
takeEvery(types.WalletActions.UNLOCK_MNEMONIC, unlockMnemonicSaga),
|
|
takeEvery(types.WalletActions.SET, handleNewWallet),
|
|
takeEvery(types.WalletActions.SCAN_WALLET_FOR_TOKENS, handleScanWalletAction),
|
|
takeEvery(types.WalletActions.SET_WALLET_TOKENS, handleSetWalletTokens),
|
|
takeEvery(types.WalletActions.SET_TOKEN_BALANCE_PENDING, updateTokenBalance),
|
|
takeEvery(types.WalletActions.REFRESH_ACCOUNT_BALANCE, updateAccountBalance),
|
|
takeEvery(types.WalletActions.REFRESH_TOKEN_BALANCES, retryTokenBalances),
|
|
// Foreign actions
|
|
takeEvery(configMetaTypes.CONFIG_META.TOGGLE_OFFLINE, updateBalances),
|
|
takeEvery(customTokensTypes.CustomTokensActions.ADD, handleCustomTokenAdd)
|
|
];
|
|
}
|