Connor Bryan e761b9d1fb Refactor redux pattern from top-level to ducks (#1936)
* Add a new route for AddressBook

* Further templating of the AddressBook view

* Add initial functionality to handle a table of existing address labels

* Make the linter happy

* Adjust paths

* Factor out TableRow and add common functionality

* Add initial Redux boilerplate for addressBook | fix minor linting issues

* Swap out terminology and types

* Connect up to Redux

* Connect data for AddressBookTable to Redux

* Use temporary fields for addition

* Remove alignment and index column

* Stopping point

* Adjust the sizing of rows to be consistent

* Initial implementation of a dropdown for the address field

* Minor styling to dropdown

* Stopping point

* Apply a focus concept onto the factory

* Add keyboard controls for the address field dropdown

* Adjust label of address field when it matches an addressBook entry

* Properly handle attempting to blur a non-existent component

* Minor styling changes on dropdown box

* Standardize address casing, add accessibility to dropdown

* Create an addressLabel component

* Pass refs correctly and fix some typings

* Exact version

* Add module name mapping for shared/keycodes

* addressBook reducer tests

* Add functionality to DeterministicModal

* Minor changes / Add test for addressBook selectors

* Move out AddressBookTable to a component

* Typing, translation and restructuring

* More typing and translation fixes

* More linting fixes

* More type changes

* Variable name for dropdown background

* Fix TS type errors, lint errors, remove unused props

* Used a different selector and removed method: AddressBookTable

* Linter was mad

* Linter mad again :(

* Add a translation and adjust styling of AddressBookTable

* Move the onBlur to a class method

* Prevent the default behavior of up/down/enter for dropdown

* Let's do it this way instead

* Adjust the styling on DeterministicWalletModal labels

* Change `AddressBookTable` into a pseudo-table using section and div

* Use readable keys vs. keycodes

* Put the dropdown in InputFactory and position it correctly

* Sanitation of label adding and changing

* Prevent duplicate labels in AddressBook and Row

* Add a box shadow and use `invalid` class insted of custom

* Use emphasis vs strong for address in dropdown

* Display the label undernearth the input vs. changing it

* Isolate AccountAddress into its own component

* Introduce interactivity to AccountAddress

* Fully incorporate with Redux

* Validation for AccountAddress

* Add validation notifications for address field on AddressBookTable

* Minor formatting

* Adjust wrappage for optimal flexboxxing

* Make AddressBookTable responsive

* Show an invalid input in "real time" instead of only on submit

* Real time input validation for AddressBookTableRow

* Responsive-ize the To address dropdown

* Hide identicons instead at small enough screen sizes

* Fix repsonsiveness of dropdown further

* Fix responsiveness of table rows and inputs

* Truncate account info and switch identicons to the right for consistency

* Use classnames instead of targetting element directly for DWM

* Display a notice if the entered query doesnt match a label and isnt an addr

* Don't show an error on the To address if its a label entry

* Display an error under AddressBookTableRow in real time

* Display errors in real time for AddressBookTable temp inputs

* Add realtime validation to AccountAddress

* Ensure toChecksumAddress is used when entering labels to address manager

* Show errors even after blurring.

* Create a ducks/ implementation for addressBook

* Duck-ize notifications

* Duck-ize customTokens

* Duck-ize deterministicWallets

* Only show errors on address/label entry if they have been blurred

* On certain inputs, show an invalid input immediately

* spec files in same directory

* Rename top-level redux directory

* Duck-ize gas

* Add displayed errors for labels with 0x and labels containing ens

* Move ENS checking validation out

* Add a saga for addLabelForAddress

* Completely revamp the redux side of Address Manager and test it all

* Adjust components to use new redux addressBook

* Incorporate new redux into AddressBookTableRow and clean up for linter

* Make linter and tests happy

* Another reduxy overhaul

* Still fixing it

* More redux updates

* Finalize redux stuff.

* Incorporate new reduxy way into AddressBookTable & Row

* Incorporate redux changes into Account Address

* Small tests fix

* Add and fix some selector tests

* Addressing Will's comments

* Shortened visibility class for line length reasons.

* Incorporate ducks pattern on updates addressBook

* Fix typeerror

* Migrate messages to ducks

* For Henry

* Duckify onboardStatus

* Duckify paritySigner

* Duckify rates

* Duckify transactions

* Duckerize wallet

* Reduckerate config

* Adjust exports and tests of every duck so far

* Duckify ENS

* Duckerificate schedule

* Duckificate swap

* Actually use the new sagas;  fix a circular dependency problem.

* Duckify transaction (phew)

* Add basics to redux/ directory

* Remove non-ducked redux stuff

* First sweep of redux/ directory

* Combine redundant imports

* Fix more linting stuff.

* A few more type fixes

* Welp... now I know not to use index.

* Sweep components/

* Sweep through containers/

* Im really starting to get frustrated

* The dawn of a new age.

* Linter fixes.

* De-flatten config/ reducers

* Do my thang on config selectors

* Adjust all references to config

* Split up ens reducers

* Wrap up de-nesting ENS

* Big boy refactor

* Split transaction into its reducers

* Fix reducers in transaction/

* Stopping point

* Adjust references to transaction from components

* Fix references to selectors

* Nest broadcast actions

* Nest field actions

* Nest meta actions

* Nest network actions

* Nest sign actions

* Nest broadcast types

* Nested fields types

* Nest meta types

* Nested network types

* Nested sign types

* Implement transaction saga changes

* Huh? No prepush problems?

* Update snappshot

* Reintroduce deleted tests

* A few missing tests found

* Found three missing transaction tests

* Found more tests

* Found the rest of the tests, woohoo.

* Renamed TypeKeys in TRANSACTION

* Specify TRANSACTION_BROADCAST

* Pretty up these imports

* Specify TRANSACTION_FIELDS

* Specify TRANSACTION_META

* Specify TRANSACTION_NETWORK

* Specify TRANSACTION_SIGN

* Adjust imports and add translations

* Update config snapshot

* Post-merge

* Temporary fix for DW/Config sagas so Daniel can continue smoke testing

* Remove first circulat dependency

* Fix more circular dependencies

* Properly structure config indices

* Further restructure config

* Prepare for idea

* Target directly from within features/

* Remove that circular dependency -- woohoo

* Remove the circular dependency from Web3Wallet, temporarily comment some tests pending assistance

* Un-comment the component-in-redux phenomenon

* Move onLoad to the store file

* Adjust addressBook imports/exports

* Adjusted imports/exports for customTokens

* Adjust imports/exports of deterministicWallets

* Adjust imports/exports of ens

* Restructure imports/exports of gas

* Restructure imports/exports for message

* Adjust imports/exports of notifications

* Restructure onboardStatus imports/exports

* Restructure paritySigner imports/exports

* Restructure rates imports/exports

* Restructure schedule imports/exports

* Fix broadcastweb3handler test

* Restructure swap imports/exports/

* Restructure transactionS imports/exports

* Restructured wallet imports and exports

* Hoist all necessary selectors aside from config/**/* and transaction/**/*

* Hoist all top-level selectors from transaction

* [Fix] Estimate Gas on Value Field Change (#1942) @ skubakdj

* Implement right-click context menu (#1780) @ bryanwb

* No Private Keys Online (#1466) @ wbobeirne

* Fix Stuck Node on Metamask Logout (#1951) @ wbobeirne

* [Fix] Make ENS Value Consistent (#1956) @ skubakdj

* Auto token add (#1808) @ HenryNguyen5

* Electron Ledger + Trezor Support (#1836) @ wbobeirne

* Fix Context Menu Popup Parameters (#1957)

* Add RSK network w/ network agnostic refactors (#1939) @ wbobeirne

* Change displayed notification back in helpers.tsx

* Remove newline on shell files

* Re-add newlines

* Remove newling on .travis.yml

* Prettier two files

* Re-add index.scss import in OnboardModal

* Restructure transaction subdirectories

* Everything in transaction/ except for sagas

* Restructure transaction imports/exports

* Nest broadcast sagas

* Nest fields

* Nest meta

* Nest network

* Nest sign

* Use generic names for reduxy stuff in the same directory to save space

* Do everything every in the whole wide world
2018-06-17 20:53:00 -05:00

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