566 lines
20 KiB
TypeScript
566 lines
20 KiB
TypeScript
import { SagaIterator, delay } from 'redux-saga';
|
|
import {
|
|
call,
|
|
cancel,
|
|
apply,
|
|
cancelled,
|
|
fork,
|
|
put,
|
|
select,
|
|
take,
|
|
takeEvery,
|
|
race,
|
|
takeLatest
|
|
} from 'redux-saga/effects';
|
|
import moment from 'moment';
|
|
|
|
import { getOrderStatus, postOrder, getAllRates } from 'api/bity';
|
|
import shapeshift from 'api/shapeshift';
|
|
import * as configSelectors from 'features/config/selectors';
|
|
import {
|
|
transactionFieldsActions,
|
|
transactionMetaActions,
|
|
transactionTypes,
|
|
transactionActions
|
|
} from 'features/transaction';
|
|
import { walletTypes, walletActions, walletSelectors } from 'features/wallet';
|
|
import { notificationsActions } from 'features/notifications';
|
|
import * as types from './types';
|
|
import * as actions from './actions';
|
|
import * as selectors from './selectors';
|
|
|
|
//#region Lite Send
|
|
export function* configureLiteSendSaga(): SagaIterator {
|
|
const { amount, label }: types.SwapState['origin'] = yield select(selectors.getOrigin);
|
|
const paymentAddress: types.SwapState['paymentAddress'] = yield call(fetchPaymentAddress);
|
|
|
|
if (!paymentAddress) {
|
|
yield put(notificationsActions.showNotification('danger', 'Could not fetch payment address'));
|
|
return yield put(actions.showLiteSend(false));
|
|
}
|
|
|
|
const supportedUnit: boolean = yield select(configSelectors.isSupportedUnit, label);
|
|
if (!supportedUnit) {
|
|
return yield put(actions.showLiteSend(false));
|
|
}
|
|
|
|
const unlocked: boolean = yield select(walletSelectors.isUnlocked);
|
|
yield put(actions.showLiteSend(true));
|
|
|
|
// wait for wallet to be unlocked to continue
|
|
if (!unlocked) {
|
|
yield take(walletTypes.WalletActions.SET);
|
|
}
|
|
const isNetwrkUnit = yield select(configSelectors.isNetworkUnit, label);
|
|
//if it's a token, manually scan for that tokens balance and wait for it to resolve
|
|
if (!isNetwrkUnit) {
|
|
yield put(walletActions.setTokenBalancePending({ tokenSymbol: label }));
|
|
yield take([
|
|
walletTypes.WalletActions.SET_TOKEN_BALANCE_FULFILLED,
|
|
walletTypes.WalletActions.SET_TOKEN_BALANCE_REJECTED
|
|
]);
|
|
} else {
|
|
const etherBalanceResolving: boolean = yield select(walletSelectors.isEtherBalancePending);
|
|
if (etherBalanceResolving) {
|
|
yield take([
|
|
walletTypes.WalletActions.SET_BALANCE_FULFILLED,
|
|
walletTypes.WalletActions.SET_BALANCE_REJECTED
|
|
]);
|
|
}
|
|
}
|
|
|
|
yield put(transactionMetaActions.setUnitMeta(label));
|
|
yield put(transactionActions.setCurrentValue(amount.toString()));
|
|
yield put(transactionActions.setCurrentTo(paymentAddress));
|
|
}
|
|
|
|
export function* handleConfigureLiteSend(): SagaIterator {
|
|
while (true) {
|
|
const liteSendProc = yield fork(configureLiteSendSaga);
|
|
const result = yield race({
|
|
transactionReset: take(transactionTypes.TransactionActions.RESET_REQUESTED),
|
|
userNavigatedAway: take(walletTypes.WalletActions.RESET),
|
|
bityPollingFinished: take(types.SwapActions.STOP_POLL_BITY_ORDER_STATUS),
|
|
shapeshiftPollingFinished: take(types.SwapActions.STOP_POLL_SHAPESHIFT_ORDER_STATUS)
|
|
});
|
|
|
|
//if polling is finished we should clear state and hide this tab
|
|
if (result.bityPollingFinished || result.shapeshiftPollingFinished) {
|
|
//clear transaction state and cancel saga
|
|
yield cancel(liteSendProc);
|
|
yield put(actions.showLiteSend(false));
|
|
return yield put(transactionFieldsActions.resetTransactionRequested());
|
|
}
|
|
if (result.transactionReset) {
|
|
yield cancel(liteSendProc);
|
|
}
|
|
|
|
// if wallet reset is called, that means the user navigated away from the page, so we cancel everything
|
|
if (result.userNavigatedAway) {
|
|
yield cancel(liteSendProc);
|
|
yield put(actions.showLiteSend(false));
|
|
return yield put(actions.configureLiteSend());
|
|
}
|
|
// else the user just swapped to a new wallet, and we'll race against liteSend again to re-apply
|
|
// the same transaction parameters again
|
|
}
|
|
}
|
|
|
|
export function* fetchPaymentAddress(): SagaIterator {
|
|
const MAX_RETRIES = 5;
|
|
let currentTry = 0;
|
|
while (currentTry <= MAX_RETRIES) {
|
|
yield call(delay, 500);
|
|
const paymentAddress: types.SwapState['paymentAddress'] = yield select(
|
|
selectors.getPaymentAddress
|
|
);
|
|
if (paymentAddress) {
|
|
return paymentAddress;
|
|
}
|
|
currentTry++;
|
|
}
|
|
|
|
yield put(notificationsActions.showNotification('danger', 'Payment address not found'));
|
|
return false;
|
|
}
|
|
|
|
export function* swapLiteSendSaga(): SagaIterator {
|
|
yield takeEvery(types.SwapActions.CONFIGURE_LITE_SEND, handleConfigureLiteSend);
|
|
}
|
|
//#endregion Lite Send
|
|
|
|
//#region Orders
|
|
export const ONE_SECOND = 1000;
|
|
export const TEN_SECONDS = ONE_SECOND * 10;
|
|
export const ORDER_TIMEOUT_MESSAGE = `
|
|
Time has run out.
|
|
If you have already sent, please wait 1 hour.
|
|
If your order has not be processed after 1 hour,
|
|
please press the orange 'Issue with your Swap?' button.
|
|
`;
|
|
export const ORDER_RECEIVED_MESSAGE = `
|
|
The order was recieved.
|
|
It may take some time to process the transaction.
|
|
Please wait 1 hour. If your order has not been processed by then,
|
|
please press the orange 'Issue with your Swap?' button.
|
|
`;
|
|
|
|
export function* pollBityOrderStatus(): SagaIterator {
|
|
try {
|
|
let swap = yield select(selectors.getSwap);
|
|
while (true) {
|
|
yield put(actions.bityOrderStatusRequested());
|
|
const orderStatus = yield call(getOrderStatus, swap.orderId);
|
|
if (orderStatus.error) {
|
|
yield put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Bity Error: ${orderStatus.msg}`,
|
|
TEN_SECONDS
|
|
)
|
|
);
|
|
} else {
|
|
yield put(actions.bityOrderStatusSucceededSwap(orderStatus.data));
|
|
yield call(delay, ONE_SECOND * 5);
|
|
swap = yield select(selectors.getSwap);
|
|
if (swap === 'CANC') {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
if (yield cancelled()) {
|
|
// TODO - implement request cancel if needed
|
|
// yield put(actions.requestFailure('Request cancelled!'))
|
|
}
|
|
}
|
|
}
|
|
|
|
export function* pollShapeshiftOrderStatus(): SagaIterator {
|
|
try {
|
|
let swap = yield select(selectors.getSwap);
|
|
while (true) {
|
|
yield put(actions.shapeshiftOrderStatusRequested());
|
|
const orderStatus = yield apply(shapeshift, shapeshift.checkStatus, [swap.paymentAddress]);
|
|
if (orderStatus.status === 'failed') {
|
|
yield put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Shapeshift Error: ${orderStatus.error}`,
|
|
Infinity
|
|
)
|
|
);
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
} else {
|
|
yield put(actions.shapeshiftOrderStatusSucceededSwap(orderStatus));
|
|
yield call(delay, ONE_SECOND * 5);
|
|
swap = yield select(selectors.getSwap);
|
|
if (swap === 'CANC') {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
if (yield cancelled()) {
|
|
// Request canclled
|
|
}
|
|
}
|
|
}
|
|
|
|
export function* pollBityOrderStatusSaga(): SagaIterator {
|
|
while (yield take(types.SwapActions.START_POLL_BITY_ORDER_STATUS)) {
|
|
// starts the task in the background
|
|
const pollBityOrderStatusTask = yield fork(pollBityOrderStatus);
|
|
// wait for the user to get to point where refresh is no longer needed
|
|
yield take(types.SwapActions.STOP_POLL_BITY_ORDER_STATUS);
|
|
// cancel the background task
|
|
// this will cause the forked loadBityRates task to jump into its finally block
|
|
yield cancel(pollBityOrderStatusTask);
|
|
}
|
|
}
|
|
|
|
export function* pollShapeshiftOrderStatusSaga(): SagaIterator {
|
|
while (yield take(types.SwapActions.START_POLL_SHAPESHIFT_ORDER_STATUS)) {
|
|
const pollShapeshiftOrderStatusTask = yield fork(pollShapeshiftOrderStatus);
|
|
yield take(types.SwapActions.STOP_POLL_SHAPESHIFT_ORDER_STATUS);
|
|
yield cancel(pollShapeshiftOrderStatusTask);
|
|
}
|
|
}
|
|
|
|
export function* postBityOrderCreate(
|
|
action: types.BityOrderCreateRequestedSwapAction
|
|
): SagaIterator {
|
|
const payload = action.payload;
|
|
try {
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
const order = yield call(
|
|
postOrder,
|
|
payload.amount,
|
|
payload.destinationAddress,
|
|
payload.mode,
|
|
payload.pair
|
|
);
|
|
if (order.error) {
|
|
// TODO - handle better / like existing site?
|
|
yield put(
|
|
notificationsActions.showNotification('danger', `Bity Error: ${order.msg}`, TEN_SECONDS)
|
|
);
|
|
yield put(actions.bityOrderCreateFailedSwap());
|
|
} else {
|
|
yield put(actions.bityOrderCreateSucceededSwap(order.data));
|
|
yield put(actions.changeStepSwap(3));
|
|
// start countdown
|
|
yield put(actions.startOrderTimerSwap());
|
|
// start bity order status polling
|
|
yield put(actions.startPollBityOrderStatus());
|
|
}
|
|
} catch (e) {
|
|
const message =
|
|
'Connection Error. Please check the developer console for more details and/or contact support';
|
|
console.error(e);
|
|
yield put(notificationsActions.showNotification('danger', message, TEN_SECONDS));
|
|
yield put(actions.bityOrderCreateFailedSwap());
|
|
}
|
|
}
|
|
|
|
export function* postShapeshiftOrderCreate(
|
|
action: types.ShapeshiftOrderCreateRequestedSwapAction
|
|
): SagaIterator {
|
|
const payload = action.payload;
|
|
try {
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
const order = yield apply(shapeshift, shapeshift.sendAmount, [
|
|
payload.withdrawal,
|
|
payload.originKind,
|
|
payload.destinationKind,
|
|
payload.destinationAmount
|
|
]);
|
|
if (order.error) {
|
|
yield put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Shapeshift Error: ${order.error}`,
|
|
TEN_SECONDS
|
|
)
|
|
);
|
|
yield put(actions.shapeshiftOrderCreateFailedSwap());
|
|
} else {
|
|
yield put(actions.shapeshiftOrderCreateSucceededSwap(order.success));
|
|
yield put(actions.changeStepSwap(3));
|
|
// start countdown
|
|
yield put(actions.startOrderTimerSwap());
|
|
// start shapeshift order status polling
|
|
yield put(actions.startPollShapeshiftOrderStatus());
|
|
}
|
|
} catch (e) {
|
|
if (e && e.message) {
|
|
yield put(notificationsActions.showNotification('danger', e.message, TEN_SECONDS));
|
|
} else {
|
|
const message =
|
|
'Connection Error. Please check the developer console for more details and/or contact support';
|
|
console.error(e);
|
|
yield put(notificationsActions.showNotification('danger', message, TEN_SECONDS));
|
|
}
|
|
yield put(actions.shapeshiftOrderCreateFailedSwap());
|
|
}
|
|
}
|
|
|
|
export function* restartSwapSaga() {
|
|
yield put(walletActions.resetWallet());
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.loadShapeshiftRatesRequestedSwap());
|
|
}
|
|
|
|
export function* bityOrderTimeRemaining(): SagaIterator {
|
|
while (true) {
|
|
let hasShownNotification = false;
|
|
while (true) {
|
|
yield call(delay, ONE_SECOND);
|
|
const swap = yield select(selectors.getSwap);
|
|
const createdTimeStampMoment = moment(swap.orderTimestampCreatedISOString);
|
|
const validUntil = moment(createdTimeStampMoment).add(swap.validFor, 's');
|
|
const now = moment();
|
|
if (validUntil.isAfter(now)) {
|
|
const duration = moment.duration(validUntil.diff(now));
|
|
const seconds = duration.asSeconds();
|
|
yield put(actions.orderTimeSwap(parseInt(seconds.toString(), 10)));
|
|
|
|
switch (swap.bityOrderStatus) {
|
|
case 'CANC':
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'FILL':
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
break;
|
|
}
|
|
} else {
|
|
switch (swap.bityOrderStatus) {
|
|
case 'OPEN':
|
|
yield put(actions.orderTimeSwap(0));
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'CANC':
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'RCVE':
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('warning', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'FILL':
|
|
yield put(actions.stopPollBityOrderStatus());
|
|
yield put(actions.stopLoadBityRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
export function* shapeshiftOrderTimeRemaining(): SagaIterator {
|
|
while (true) {
|
|
let hasShownNotification = false;
|
|
while (true) {
|
|
yield call(delay, ONE_SECOND);
|
|
const swap = yield select(selectors.getSwap);
|
|
const createdTimeStampMoment = moment(swap.orderTimestampCreatedISOString);
|
|
const validUntil = moment(createdTimeStampMoment).add(swap.validFor, 's');
|
|
const now = moment();
|
|
if (validUntil.isAfter(now)) {
|
|
const duration = moment.duration(validUntil.diff(now));
|
|
const seconds = duration.asSeconds();
|
|
yield put(actions.orderTimeSwap(parseInt(seconds.toString(), 10)));
|
|
switch (swap.shapeshiftOrderStatus) {
|
|
case 'failed':
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'received':
|
|
yield put(actions.stopOrderTimerSwap());
|
|
break;
|
|
case 'complete':
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
break;
|
|
}
|
|
} else {
|
|
switch (swap.shapeshiftOrderStatus) {
|
|
case 'no_deposits':
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(actions.orderTimeSwap(0));
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'failed':
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
yield put(
|
|
notificationsActions.showNotification('danger', ORDER_TIMEOUT_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'received':
|
|
if (!hasShownNotification) {
|
|
hasShownNotification = true;
|
|
yield put(
|
|
notificationsActions.showNotification('warning', ORDER_RECEIVED_MESSAGE, Infinity)
|
|
);
|
|
}
|
|
break;
|
|
case 'complete':
|
|
yield put(actions.stopPollShapeshiftOrderStatus());
|
|
yield put(actions.stopLoadShapeshiftRatesSwap());
|
|
yield put(actions.stopOrderTimerSwap());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
export function* handleOrderTimeRemaining(): SagaIterator {
|
|
const swap = yield select(selectors.getSwap);
|
|
let orderTimeRemainingTask;
|
|
if (swap.provider === 'shapeshift') {
|
|
orderTimeRemainingTask = yield fork(shapeshiftOrderTimeRemaining);
|
|
} else {
|
|
orderTimeRemainingTask = yield fork(bityOrderTimeRemaining);
|
|
}
|
|
yield take(types.SwapActions.ORDER_STOP_TIMER);
|
|
yield cancel(orderTimeRemainingTask);
|
|
}
|
|
|
|
export function* swapOrdersSaga(): SagaIterator {
|
|
yield fork(handleOrderTimeRemaining);
|
|
yield fork(pollShapeshiftOrderStatusSaga);
|
|
yield fork(pollBityOrderStatusSaga);
|
|
yield takeEvery(types.SwapActions.BITY_ORDER_CREATE_REQUESTED, postBityOrderCreate);
|
|
yield takeEvery(types.SwapActions.SHAPESHIFT_ORDER_CREATE_REQUESTED, postShapeshiftOrderCreate);
|
|
yield takeEvery(types.SwapActions.ORDER_START_TIMER, handleOrderTimeRemaining);
|
|
yield takeEvery(types.SwapActions.RESTART, restartSwapSaga);
|
|
}
|
|
//#endregion Orders
|
|
|
|
//#region Rates
|
|
export const SHAPESHIFT_TIMEOUT = 10000;
|
|
export const POLLING_CYCLE = 30000;
|
|
|
|
export function* loadBityRates(): SagaIterator {
|
|
while (true) {
|
|
try {
|
|
const data = yield call(getAllRates);
|
|
yield put(actions.loadBityRatesSucceededSwap(data));
|
|
} catch (error) {
|
|
const hasNotified = yield select(selectors.getHasNotifiedRatesFailure);
|
|
if (!hasNotified) {
|
|
console.error('Failed to load rates from Bity:', error);
|
|
yield put(notificationsActions.showNotification('danger', error.message));
|
|
}
|
|
yield put(actions.loadBityRatesFailedSwap());
|
|
}
|
|
yield call(delay, POLLING_CYCLE);
|
|
}
|
|
}
|
|
|
|
export function* handleBityRates(): SagaIterator {
|
|
const loadBityRatesTask = yield fork(loadBityRates);
|
|
yield take(types.SwapActions.STOP_LOAD_BITY_RATES);
|
|
yield cancel(loadBityRatesTask);
|
|
}
|
|
|
|
export function* loadShapeshiftRates(): SagaIterator {
|
|
while (true) {
|
|
try {
|
|
// Race b/w api call and timeout
|
|
// getShapeShiftRates should be an api call that accepts a whitelisted arr of symbols
|
|
const { tokens } = yield race({
|
|
tokens: call(shapeshift.getAllRates),
|
|
timeout: call(delay, SHAPESHIFT_TIMEOUT)
|
|
});
|
|
// If tokens exist, put it into the redux state, otherwise switch to bity.
|
|
if (tokens) {
|
|
yield put(actions.loadShapeshiftRatesSucceededSwap(tokens));
|
|
} else {
|
|
throw new Error('ShapeShift rates request timed out.');
|
|
}
|
|
} catch (error) {
|
|
const hasNotified = yield select(selectors.getHasNotifiedRatesFailure);
|
|
if (!hasNotified) {
|
|
console.error('Failed to fetch rates from shapeshift:', error);
|
|
yield put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
'Failed to load swap rates from ShapeShift, please try again later'
|
|
)
|
|
);
|
|
}
|
|
yield put(actions.loadShapeshiftRatesFailedSwap());
|
|
}
|
|
yield call(delay, POLLING_CYCLE);
|
|
}
|
|
}
|
|
|
|
export function* handleShapeshiftRates(): SagaIterator {
|
|
const loadShapeshiftRatesTask = yield fork(loadShapeshiftRates);
|
|
yield take(types.SwapActions.STOP_LOAD_SHAPESHIFT_RATES);
|
|
yield cancel(loadShapeshiftRatesTask);
|
|
}
|
|
|
|
export function* swapProvider(action: types.ChangeProviderSwapAcion): SagaIterator {
|
|
const swap = yield select(selectors.getSwap);
|
|
if (swap.provider !== action.payload) {
|
|
yield put(actions.changeSwapProvider(action.payload));
|
|
}
|
|
}
|
|
|
|
export function* swapRatesSaga(): SagaIterator {
|
|
yield takeLatest(types.SwapActions.LOAD_BITY_RATES_REQUESTED, handleBityRates);
|
|
yield takeLatest(types.SwapActions.LOAD_SHAPESHIFT_RATES_REQUESTED, handleShapeshiftRates);
|
|
yield takeLatest(types.SwapActions.CHANGE_PROVIDER, swapProvider);
|
|
}
|
|
//#endregion Rates
|