diff --git a/web/cashtab/src/components/Common/Ticker.js b/web/cashtab/src/components/Common/Ticker.js
index fd7febde4..7f777df44 100644
--- a/web/cashtab/src/components/Common/Ticker.js
+++ b/web/cashtab/src/components/Common/Ticker.js
@@ -1,140 +1,141 @@
 import mainLogo from '@assets/12-bitcoin-cash-square-crop.svg';
 import tokenLogo from '@assets/simple-ledger-protocol-logo.png';
 import cashaddr from 'cashaddrjs';
 import BigNumber from 'bignumber.js';
 
 export const currency = {
     name: 'Bitcoin ABC',
     ticker: 'BCHA',
     logo: mainLogo,
     legacyPrefix: 'bitcoincash',
     prefixes: ['bitcoincash', 'ecash'],
     coingeckoId: 'bitcoin-cash-abc-2',
     defaultFee: 5.01,
     dust: '0.00000546', // The minimum amount of BCHA that can be sent by the app
+    cashDecimals: 8,
     blockExplorerUrl: 'https://explorer.bitcoinabc.org',
     blockExplorerUrlTestnet: 'https://texplorer.bitcoinabc.org',
     tokenName: 'Bitcoin ABC SLP',
     tokenTicker: 'SLPA',
     tokenLogo: tokenLogo,
     tokenPrefixes: ['simpleledger', 'etoken'],
     tokenIconsUrl: '', //https://tokens.bitcoin.com/32 for BCH SLP
     useBlockchainWs: false,
 };
 
 export function isValidCashPrefix(addressString) {
     // Note that this function validates prefix only
     // Check for prefix included in currency.prefixes array
     // For now, validation is handled by converting to bitcoincash: prefix and checksum
     // and relying on legacy validation methods of bitcoincash: prefix addresses
 
     // Also accept an address with no prefix, as some exchanges provide these
     for (let i = 0; i < currency.prefixes.length; i += 1) {
         // If the addressString being tested starts with an accepted prefix or no prefix at all
         if (
             addressString.startsWith(currency.prefixes[i] + ':') ||
             !addressString.includes(':')
         ) {
             return true;
         }
     }
     return false;
 }
 
 export function isValidTokenPrefix(addressString) {
     // Check for prefix included in currency.tokenPrefixes array
     // For now, validation is handled by converting to simpleledger: prefix and checksum
     // and relying on legacy validation methods of simpleledger: prefix addresses
 
     // For token addresses, do not accept an address with no prefix
     for (let i = 0; i < currency.tokenPrefixes.length; i += 1) {
         if (addressString.startsWith(currency.tokenPrefixes[i] + ':')) {
             return true;
         }
     }
     return false;
 }
 
 export function toLegacy(address) {
     let testedAddress;
     let legacyAddress;
 
     try {
         if (isValidCashPrefix(address)) {
             // Prefix-less addresses may be valid, but the cashaddr.decode function used below
             // will throw an error without a prefix. Hence, must ensure prefix to use that function.
             const hasPrefix = address.includes(':');
             if (!hasPrefix) {
                 testedAddress = currency.legacyPrefix + ':' + address;
             } else {
                 testedAddress = address;
             }
 
             // Note: an `ecash:` checksum address with no prefix will not be validated by
             // parseAddress in Send.js
 
             // Only handle the case of prefixless address that is valid `bitcoincash:` address
 
             const { type, hash } = cashaddr.decode(testedAddress);
             legacyAddress = cashaddr.encode(currency.legacyPrefix, type, hash);
         } else {
             console.log(`Error: ${address} is not a cash address`);
             throw new Error(
                 'Address prefix is not a valid cash address with a prefix from the Ticker.prefixes array',
             );
         }
     } catch (err) {
         return err;
     }
     return legacyAddress;
 }
 
 export function parseAddress(BCH, addressString) {
     // Build return obj
     const addressInfo = {
         address: '',
         isValid: false,
         queryString: null,
         amount: null,
     };
     // Parse address string for parameters
     const paramCheck = addressString.split('?');
 
     let cleanAddress = paramCheck[0];
     addressInfo.address = cleanAddress;
 
     // Validate address
     let isValidAddress;
     try {
         isValidAddress = BCH.Address.isCashAddress(cleanAddress);
     } catch (err) {
         isValidAddress = false;
     }
 
     addressInfo.isValid = isValidAddress;
 
     // Check for parameters
     // only the amount param is currently supported
     let queryString = null;
     let amount = null;
     if (paramCheck.length > 1) {
         queryString = paramCheck[1];
         addressInfo.queryString = queryString;
 
         const addrParams = new URLSearchParams(queryString);
 
         if (addrParams.has('amount')) {
             // Amount in satoshis
             try {
                 amount = new BigNumber(parseInt(addrParams.get('amount')))
                     .div(1e8)
                     .toString();
             } catch (err) {
                 amount = null;
             }
         }
     }
 
     addressInfo.amount = amount;
     return addressInfo;
 }
diff --git a/web/cashtab/src/components/Send/Send.js b/web/cashtab/src/components/Send/Send.js
index 234429687..174e56218 100644
--- a/web/cashtab/src/components/Send/Send.js
+++ b/web/cashtab/src/components/Send/Send.js
@@ -1,529 +1,531 @@
 import React, { useState, useEffect } from 'react';
 import styled from 'styled-components';
 import { WalletContext } from '@utils/context';
 import { Form, notification, message, Spin, Modal, Alert } from 'antd';
 import { CashLoader, CashLoadingIcon } from '@components/Common/CustomIcons';
 import { Row, Col } from 'antd';
 import Paragraph from 'antd/lib/typography/Paragraph';
 import PrimaryButton, {
     SecondaryButton,
 } from '@components/Common/PrimaryButton';
 import {
     SendBchInput,
     FormItemWithQRCodeAddon,
 } from '@components/Common/EnhancedInputs';
 import useBCH from '@hooks/useBCH';
 import useWindowDimensions from '@hooks/useWindowDimensions';
 import { isMobile, isIOS, isSafari } from 'react-device-detect';
 import {
     currency,
     isValidTokenPrefix,
     parseAddress,
     toLegacy,
 } from '@components/Common/Ticker.js';
 import { Event } from '@utils/GoogleAnalytics';
 import { fiatToCrypto, shouldRejectAmountInput } from '@utils/validation';
 export const BalanceHeader = styled.div`
     p {
         color: #777;
         width: 100%;
         font-size: 14px;
         margin-bottom: 0px;
     }
 
     h3 {
         color: #444;
         width: 100%;
         font-size: 26px;
         font-weight: bold;
         margin-bottom: 0px;
     }
 `;
 
 export const BalanceHeaderFiat = styled.div`
     color: #444;
     width: 100%;
     font-size: 18px;
     margin-bottom: 20px;
     font-weight: bold;
     @media (max-width: 768px) {
         font-size: 16px;
     }
 `;
 
 export const ZeroBalanceHeader = styled.div`
     color: #444;
     width: 100%;
     font-size: 14px;
     margin-bottom: 20px;
 `;
 
 const ConvertAmount = styled.div`
     color: #777;
     width: 100%;
     font-size: 14px;
     margin-bottom: 10px;
     font-weight: bold;
     @media (max-width: 768px) {
         font-size: 12px;
     }
 `;
 
 const SendBCH = ({ filledAddress, callbackTxId }) => {
     const {
         wallet,
         fiatPrice,
         balances,
         slpBalancesAndUtxos,
         apiError,
     } = React.useContext(WalletContext);
 
     // Get device window width
     // If this is less than 769, the page will open with QR scanner open
     const { width } = useWindowDimensions();
     // Load with QR code open if device is mobile and NOT iOS + anything but safari
     const scannerSupported = width < 769 && isMobile && !(isIOS && !isSafari);
 
     const [formData, setFormData] = useState({
         dirty: true,
         value: '',
         address: filledAddress || '',
     });
     const [loading, setLoading] = useState(false);
     const [queryStringText, setQueryStringText] = useState(null);
     const [sendBchAddressError, setSendBchAddressError] = useState(false);
     const [sendBchAmountError, setSendBchAmountError] = useState(false);
     const [selectedCurrency, setSelectedCurrency] = useState(currency.ticker);
 
     // Support cashtab button from web pages
     const [txInfoFromUrl, setTxInfoFromUrl] = useState(false);
 
     // Show a confirmation modal on transactions created by populating form from web page button
     const [isModalVisible, setIsModalVisible] = useState(false);
 
     const showModal = () => {
         setIsModalVisible(true);
     };
 
     const handleOk = () => {
         setIsModalVisible(false);
         submit();
     };
 
     const handleCancel = () => {
         setIsModalVisible(false);
     };
 
     const { getBCH, getRestUrl, sendBch, calcFee } = useBCH();
     const BCH = getBCH();
 
     // If the balance has changed, unlock the UI
     // This is redundant, if backend has refreshed in 1.75s timeout below, UI will already be unlocked
     useEffect(() => {
         setLoading(false);
     }, [balances.totalBalance]);
 
     useEffect(() => {
         // Manually parse for txInfo object on page load when Send.js is loaded with a query string
 
         // Do not set txInfo in state if query strings are not present
         if (
             !window.location ||
             !window.location.hash ||
             window.location.hash === '#/send'
         ) {
             return;
         }
 
         const txInfoArr = window.location.hash.split('?')[1].split('&');
 
         // Iterate over this to create object
         const txInfo = {};
         for (let i = 0; i < txInfoArr.length; i += 1) {
             let txInfoKeyValue = txInfoArr[i].split('=');
             let key = txInfoKeyValue[0];
             let value = txInfoKeyValue[1];
             txInfo[key] = value;
         }
         console.log(`txInfo from page params`, txInfo);
         setTxInfoFromUrl(txInfo);
         populateFormsFromUrl(txInfo);
     }, []);
 
     function populateFormsFromUrl(txInfo) {
         if (txInfo && txInfo.address && txInfo.value) {
             setFormData({ address: txInfo.address, value: txInfo.value });
         }
     }
 
     async function submit() {
         setFormData({
             ...formData,
             dirty: false,
         });
 
         if (
             !formData.address ||
             !formData.value ||
             Number(formData.value) <= 0
         ) {
             return;
         }
 
         // Event("Category", "Action", "Label")
         // Track number of BCHA send transactions and whether users
         // are sending BCHA or USD
         Event('Send.js', 'Send', selectedCurrency);
 
         setLoading(true);
         const { address, value } = formData;
 
         // Get the param-free address
         let cleanAddress = address.split('?')[0];
 
         // Ensure address has bitcoincash: prefix and checksum
         cleanAddress = toLegacy(cleanAddress);
 
         let hasValidCashPrefix;
         try {
             hasValidCashPrefix = cleanAddress.startsWith(
                 currency.legacyPrefix + ':',
             );
         } catch (err) {
             hasValidCashPrefix = false;
             console.log(`toLegacy() returned an error:`, cleanAddress);
         }
 
         if (!hasValidCashPrefix) {
             // set loading to false and set address validation to false
             // Now that the no-prefix case is handled, this happens when user tries to send
             // BCHA to an SLPA address
             setLoading(false);
             setSendBchAddressError(
                 `Destination is not a valid ${currency.ticker} address`,
             );
             return;
         }
 
         // Calculate the amount in BCH
         let bchValue = value;
 
         if (selectedCurrency === 'USD') {
             bchValue = fiatToCrypto(value, fiatPrice);
         }
 
         try {
             const link = await sendBch(
                 BCH,
                 wallet,
                 slpBalancesAndUtxos.nonSlpUtxos,
                 {
                     addresses: [filledAddress || cleanAddress],
                     values: [bchValue],
                 },
                 callbackTxId,
             );
 
             notification.success({
                 message: 'Success',
                 description: (
                     <a href={link} target="_blank" rel="noopener noreferrer">
                         <Paragraph>
                             Transaction successful. Click or tap here for more
                             details
                         </Paragraph>
                     </a>
                 ),
                 duration: 5,
             });
         } catch (e) {
             // Set loading to false here as well, as balance may not change depending on where error occured in try loop
             setLoading(false);
             let message;
 
             if (!e.error && !e.message) {
                 message = `Transaction failed: no response from ${getRestUrl()}.`;
             } else if (
                 /Could not communicate with full node or other external service/.test(
                     e.error,
                 )
             ) {
                 message = 'Could not communicate with API. Please try again.';
             } else if (
                 e.error &&
                 e.error.includes(
                     'too-long-mempool-chain, too many unconfirmed ancestors [limit: 50] (code 64)',
                 )
             ) {
                 message = `The ${currency.ticker} you are trying to send has too many unconfirmed ancestors to send (limit 50). Sending will be possible after a block confirmation. Try again in about 10 minutes.`;
             } else {
                 message = e.message || e.error || JSON.stringify(e);
             }
 
             notification.error({
                 message: 'Error',
                 description: message,
                 duration: 5,
             });
             console.error(e);
         }
     }
 
     const handleAddressChange = e => {
         const { value, name } = e.target;
         let error = false;
         let addressString = value;
 
         // parse address
         const addressInfo = parseAddress(BCH, addressString);
         /*
         Model
 
         addressInfo = 
         {
             address: '',
             isValid: false,
             queryString: '',
             amount: null,
         };
         */
 
         const { address, isValid, queryString, amount } = addressInfo;
 
         // If query string,
         // Show an alert that only amount and currency.ticker are supported
         setQueryStringText(queryString);
 
         // Is this valid address?
         if (!isValid) {
             error = 'Address is not a valid cash address';
             // If valid address but token format
             if (isValidTokenPrefix(address)) {
                 error = `Token addresses are not supported for ${currency.ticker} sends`;
             }
         }
         setSendBchAddressError(error);
 
         // Set amount if it's in the query string
         if (amount !== null) {
             // Set currency to BCHA
             setSelectedCurrency(currency.ticker);
 
             // Use this object to mimic user input and get validation for the value
             let amountObj = { target: { name: 'value', value: amount } };
             handleBchAmountChange(amountObj);
             setFormData({
                 ...formData,
                 value: amount,
             });
         }
 
         // Set address field to user input
         setFormData(p => ({
             ...p,
             [name]: value,
         }));
     };
 
     const handleSelectedCurrencyChange = e => {
         setSelectedCurrency(e);
         // Clear input field to prevent accidentally sending 1 BCH instead of 1 USD
         setFormData(p => ({ ...p, value: '' }));
     };
 
     const handleBchAmountChange = e => {
         const { value, name } = e.target;
         let bchValue = value;
         const error = shouldRejectAmountInput(
             bchValue,
             selectedCurrency,
             fiatPrice,
             balances.totalBalance,
         );
         setSendBchAmountError(error);
 
         setFormData(p => ({ ...p, [name]: value }));
     };
 
     const onMax = async () => {
         // Clear amt error
         setSendBchAmountError(false);
         // Set currency to BCH
         setSelectedCurrency(currency.ticker);
         try {
             const txFeeSats = calcFee(BCH, slpBalancesAndUtxos.nonSlpUtxos);
 
-            const txFeeBch = txFeeSats / 1e8;
+            const txFeeBch = txFeeSats / 10 ** currency.cashDecimals;
             let value =
                 balances.totalBalance - txFeeBch >= 0
-                    ? (balances.totalBalance - txFeeBch).toFixed(8)
+                    ? (balances.totalBalance - txFeeBch).toFixed(
+                          currency.cashDecimals,
+                      )
                     : 0;
 
             setFormData({
                 ...formData,
                 value,
             });
         } catch (err) {
             console.log(`Error in onMax:`);
             console.log(err);
             message.error(
                 'Unable to calculate the max value due to network errors',
             );
         }
     };
     // Display price in USD below input field for send amount, if it can be calculated
     let fiatPriceString = '';
     if (fiatPrice !== null && !isNaN(formData.value)) {
         if (selectedCurrency === currency.ticker) {
             fiatPriceString = `$ ${(fiatPrice * Number(formData.value)).toFixed(
                 2,
             )} USD`;
         } else {
             fiatPriceString = `${
                 formData.value ? fiatToCrypto(formData.value, fiatPrice) : '0'
             } ${currency.ticker}`;
         }
     }
 
     return (
         <>
             <Modal
                 title="Confirm Send"
                 visible={isModalVisible}
                 onOk={handleOk}
                 onCancel={handleCancel}
             >
                 <p>
                     Are you sure you want to send {formData.value}{' '}
                     {currency.ticker} to {formData.address}?
                 </p>
             </Modal>
             {!balances.totalBalance ? (
                 <ZeroBalanceHeader>
                     You currently have 0 {currency.ticker}
                     <br />
                     Deposit some funds to use this feature
                 </ZeroBalanceHeader>
             ) : (
                 <>
                     <BalanceHeader>
                         <p>Available balance</p>
                         <h3>
                             {balances.totalBalance} {currency.ticker}
                         </h3>
                     </BalanceHeader>
                     {fiatPrice !== null && (
                         <BalanceHeaderFiat>
                             ${(balances.totalBalance * fiatPrice).toFixed(2)}{' '}
                             USD
                         </BalanceHeaderFiat>
                     )}
                 </>
             )}
 
             <Row type="flex">
                 <Col span={24}>
                     <Spin spinning={loading} indicator={CashLoadingIcon}>
                         <Form style={{ width: 'auto' }}>
                             <FormItemWithQRCodeAddon
                                 loadWithCameraOpen={scannerSupported}
                                 disabled={Boolean(filledAddress)}
                                 validateStatus={
                                     sendBchAddressError ? 'error' : ''
                                 }
                                 help={
                                     sendBchAddressError
                                         ? sendBchAddressError
                                         : ''
                                 }
                                 onScan={result =>
                                     handleAddressChange({
                                         target: {
                                             name: 'address',
                                             value: result,
                                         },
                                     })
                                 }
                                 inputProps={{
                                     disabled: Boolean(filledAddress),
                                     placeholder: `${currency.ticker} Address`,
                                     name: 'address',
                                     onChange: e => handleAddressChange(e),
                                     required: true,
                                     value: filledAddress || formData.address,
                                 }}
                             ></FormItemWithQRCodeAddon>
                             <SendBchInput
                                 validateStatus={
                                     sendBchAmountError ? 'error' : ''
                                 }
                                 help={
                                     sendBchAmountError ? sendBchAmountError : ''
                                 }
                                 onMax={onMax}
                                 inputProps={{
                                     name: 'value',
                                     dollar: selectedCurrency === 'USD' ? 1 : 0,
                                     placeholder: 'Amount',
                                     onChange: e => handleBchAmountChange(e),
                                     required: true,
                                     value: formData.value,
                                 }}
                                 selectProps={{
                                     value: selectedCurrency,
                                     disabled: queryStringText !== null,
                                     onChange: e =>
                                         handleSelectedCurrencyChange(e),
                                 }}
                             ></SendBchInput>
                             <ConvertAmount>= {fiatPriceString}</ConvertAmount>
                             <div style={{ paddingTop: '12px' }}>
                                 {!balances.totalBalance ||
                                 apiError ||
                                 sendBchAmountError ||
                                 sendBchAddressError ? (
                                     <SecondaryButton>Send</SecondaryButton>
                                 ) : (
                                     <>
                                         {txInfoFromUrl ? (
                                             <PrimaryButton
                                                 onClick={() => showModal()}
                                             >
                                                 Send
                                             </PrimaryButton>
                                         ) : (
                                             <PrimaryButton
                                                 onClick={() => submit()}
                                             >
                                                 Send
                                             </PrimaryButton>
                                         )}
                                     </>
                                 )}
                             </div>
                             {queryStringText && (
                                 <Alert
                                     message={`You are sending a transaction to an address including query parameters "${queryStringText}." Only the "amount" parameter, in units of ${currency.ticker} satoshis, is currently supported.`}
                                     type="warning"
                                 />
                             )}
                             {apiError && (
                                 <>
                                     <CashLoader />
                                     <p style={{ color: 'red' }}>
                                         <b>
                                             An error occured on our end.
                                             Reconnecting...
                                         </b>
                                     </p>
                                 </>
                             )}
                         </Form>
                     </Spin>
                 </Col>
             </Row>
         </>
     );
 };
 
 export default SendBCH;
diff --git a/web/cashtab/src/hooks/useWallet.js b/web/cashtab/src/hooks/useWallet.js
index b5c2d1fd2..ee8d2cca7 100644
--- a/web/cashtab/src/hooks/useWallet.js
+++ b/web/cashtab/src/hooks/useWallet.js
@@ -1,1236 +1,1236 @@
 /* eslint-disable react-hooks/exhaustive-deps */
 
 import React, { useState, useEffect } from 'react';
 import Paragraph from 'antd/lib/typography/Paragraph';
 import { notification } from 'antd';
 import useAsyncTimeout from '@hooks/useAsyncTimeout';
 import usePrevious from '@hooks/usePrevious';
 import useBCH from '@hooks/useBCH';
 import BigNumber from 'bignumber.js';
 import localforage from 'localforage';
 import { currency } from '@components/Common/Ticker';
 import _ from 'lodash';
 
 const useWallet = () => {
     const [wallet, setWallet] = useState(false);
     const [fiatPrice, setFiatPrice] = useState(null);
     const [ws, setWs] = useState(null);
     const [apiError, setApiError] = useState(false);
     const [walletState, setWalletState] = useState({
         balances: {},
         tokens: [],
         slpBalancesAndUtxos: [],
         txHistory: [],
     });
     const {
         getBCH,
         getUtxos,
         getHydratedUtxoDetails,
         getSlpBalancesAndUtxos,
         getTxHistory,
     } = useBCH();
     const [loading, setLoading] = useState(true);
     const [apiIndex, setApiIndex] = useState(0);
     const [BCH, setBCH] = useState(getBCH(apiIndex));
     const [utxos, setUtxos] = useState(null);
     const { balances, tokens, slpBalancesAndUtxos, txHistory } = walletState;
     const previousBalances = usePrevious(balances);
     const previousTokens = usePrevious(tokens);
     const previousWallet = usePrevious(wallet);
     const previousUtxos = usePrevious(utxos);
 
     // If you catch API errors, call this function
     const tryNextAPI = () => {
         let currentApiIndex = apiIndex;
         // How many APIs do you have?
         const apiString = process.env.REACT_APP_BCHA_APIS;
 
         const apiArray = apiString.split(',');
 
         console.log(`You have ${apiArray.length} APIs to choose from`);
         console.log(`Current selection: ${apiIndex}`);
         // If only one, exit
         if (apiArray.length === 0) {
             console.log(
                 `There are no backup APIs, you are stuck with this error`,
             );
             return;
         } else if (currentApiIndex < apiArray.length - 1) {
             currentApiIndex += 1;
             console.log(
                 `Incrementing API index from ${apiIndex} to ${currentApiIndex}`,
             );
         } else {
             // Otherwise use the first option again
             console.log(`Retrying first API index`);
             currentApiIndex = 0;
         }
         //return setApiIndex(currentApiIndex);
         console.log(`Setting Api Index to ${currentApiIndex}`);
         setApiIndex(currentApiIndex);
         return setBCH(getBCH(currentApiIndex));
         // If you have more than one, use the next one
         // If you are at the "end" of the array, use the first one
     };
 
     const normalizeSlpBalancesAndUtxos = (slpBalancesAndUtxos, wallet) => {
         const Accounts = [wallet.Path245, wallet.Path145, wallet.Path1899];
         slpBalancesAndUtxos.nonSlpUtxos.forEach(utxo => {
             const derivatedAccount = Accounts.find(
                 account => account.cashAddress === utxo.address,
             );
             utxo.wif = derivatedAccount.fundingWif;
         });
 
         return slpBalancesAndUtxos;
     };
 
     const normalizeBalance = slpBalancesAndUtxos => {
         const totalBalanceInSatoshis = slpBalancesAndUtxos.nonSlpUtxos.reduce(
             (previousBalance, utxo) => previousBalance + utxo.value,
             0,
         );
         return {
             totalBalanceInSatoshis,
             totalBalance: BCH.BitcoinCash.toBitcoinCash(totalBalanceInSatoshis),
         };
     };
 
     const deriveAccount = async (BCH, { masterHDNode, path }) => {
         const node = BCH.HDNode.derivePath(masterHDNode, path);
         const cashAddress = BCH.HDNode.toCashAddress(node);
         const slpAddress = BCH.SLP.Address.toSLPAddress(cashAddress);
 
         return {
             cashAddress,
             slpAddress,
             fundingWif: BCH.HDNode.toWIF(node),
             fundingAddress: BCH.SLP.Address.toSLPAddress(cashAddress),
             legacyAddress: BCH.SLP.Address.toLegacyAddress(cashAddress),
         };
     };
 
     const haveUtxosChanged = (utxos, previousUtxos) => {
         // Relevant points for this array comparing exercise
         // https://stackoverflow.com/questions/13757109/triple-equal-signs-return-false-for-arrays-in-javascript-why
         // https://stackoverflow.com/questions/7837456/how-to-compare-arrays-in-javascript
 
         // If this is initial state
         if (utxos === null) {
             // Then make sure to get slpBalancesAndUtxos
             return true;
         }
         // If this is the first time the wallet received utxos
         if (
             typeof previousUtxos === 'undefined' ||
             typeof utxos === 'undefined'
         ) {
             // Then they have certainly changed
             return true;
         }
         // return true for empty array, since this means you definitely do not want to skip the next API call
         if (utxos && utxos.length === 0) {
             return true;
         }
 
         // Compare utxo sets
         const utxoArraysUnchanged = _.isEqual(utxos, previousUtxos);
 
         // If utxos are not the same as previousUtxos
         if (utxoArraysUnchanged) {
             // then utxos have not changed
             return false;
             // otherwise,
         } else {
             // utxos have changed
             return true;
         }
     };
 
     const update = async ({ wallet, setWalletState }) => {
         //console.log(`tick()`);
         //console.time("update");
         try {
             if (!wallet) {
                 return;
             }
             const cashAddresses = [
                 wallet.Path245.cashAddress,
                 wallet.Path145.cashAddress,
                 wallet.Path1899.cashAddress,
             ];
 
             const utxos = await getUtxos(BCH, cashAddresses);
 
             // If an error is returned or utxos from only 1 address are returned
             if (!utxos || _.isEmpty(utxos) || utxos.error || utxos.length < 2) {
                 // Throw error here to prevent more attempted api calls
                 // as you are likely already at rate limits
                 throw new Error('Error fetching utxos');
             }
             setUtxos(utxos);
 
             const utxosHaveChanged = haveUtxosChanged(utxos, previousUtxos);
 
             // If the utxo set has not changed,
             if (!utxosHaveChanged) {
                 // remove api error here; otherwise it will remain if recovering from a rate
                 // limit error with an unchanged utxo set
                 setApiError(false);
                 // then walletState has not changed and does not need to be updated
                 //console.timeEnd("update");
                 return;
             }
 
             const hydratedUtxoDetails = await getHydratedUtxoDetails(
                 BCH,
                 utxos,
             );
 
             const slpBalancesAndUtxos = await getSlpBalancesAndUtxos(
                 hydratedUtxoDetails,
             );
             const txHistory = await getTxHistory(BCH, cashAddresses);
 
             console.log(`slpBalancesAndUtxos`, slpBalancesAndUtxos);
             if (typeof slpBalancesAndUtxos === 'undefined') {
                 console.log(`slpBalancesAndUtxos is undefined`);
                 throw new Error('slpBalancesAndUtxos is undefined');
             }
             const { tokens } = slpBalancesAndUtxos;
 
             const newState = {
                 balances: {},
                 tokens: [],
                 slpBalancesAndUtxos: [],
             };
 
             newState.slpBalancesAndUtxos = normalizeSlpBalancesAndUtxos(
                 slpBalancesAndUtxos,
                 wallet,
             );
 
             newState.balances = normalizeBalance(slpBalancesAndUtxos);
 
             newState.tokens = tokens;
 
             newState.txHistory = txHistory;
 
             setWalletState(newState);
 
             // If everything executed correctly, remove apiError
             setApiError(false);
         } catch (error) {
             console.log(`Error in update({wallet, setWalletState})`);
             console.log(error);
             // Set this in state so that transactions are disabled until the issue is resolved
             setApiError(true);
             //console.timeEnd("update");
             // Try another endpoint
             console.log(`Trying next API...`);
             tryNextAPI();
         }
         //console.timeEnd("update");
     };
 
     const getActiveWalletFromLocalForage = async () => {
         let wallet;
         try {
             wallet = await localforage.getItem('wallet');
         } catch (err) {
             console.log(`Error in getActiveWalletFromLocalForage`, err);
             wallet = null;
         }
         return wallet;
     };
 
     /*
     const getSavedWalletsFromLocalForage = async () => {
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(`Error in getSavedWalletsFromLocalForage`, err);
             savedWallets = null;
         }
         return savedWallets;
     };
     */
 
     const getWallet = async () => {
         let wallet;
         let existingWallet;
         try {
             existingWallet = await getActiveWalletFromLocalForage();
             // existing wallet will be
             // 1 - the 'wallet' value from localForage, if it exists
             // 2 - false if it does not exist in localForage
             // 3 - null if error
 
             // If the wallet does not have Path1899, add it
             if (existingWallet && !existingWallet.Path1899) {
                 console.log(`Wallet does not have Path1899`);
                 existingWallet = await migrateLegacyWallet(BCH, existingWallet);
             }
             // If not in localforage then existingWallet = false, check localstorage
             if (!existingWallet) {
                 console.log(`no existing wallet, checking local storage`);
                 existingWallet = JSON.parse(
                     window.localStorage.getItem('wallet'),
                 );
                 console.log(`existingWallet from localStorage`, existingWallet);
                 // If you find it here, move it to indexedDb
                 if (existingWallet !== null) {
                     wallet = await getWalletDetails(existingWallet);
                     await localforage.setItem('wallet', wallet);
                     return wallet;
                 }
             }
         } catch (err) {
             console.log(`Error in getWallet()`, err);
             /* 
             Error here implies problem interacting with localForage or localStorage API
             
             Have not seen this error in testing
 
             In this case, you still want to return 'wallet' using the logic below based on 
             the determination of 'existingWallet' from the logic above
             */
         }
 
         if (existingWallet === null || !existingWallet) {
             wallet = await getWalletDetails(existingWallet);
             await localforage.setItem('wallet', wallet);
         } else {
             wallet = existingWallet;
         }
         return wallet;
     };
 
     const migrateLegacyWallet = async (BCH, wallet) => {
         console.log(`migrateLegacyWallet`);
         console.log(`legacyWallet`, wallet);
         const NETWORK = process.env.REACT_APP_NETWORK;
         const mnemonic = wallet.mnemonic;
         const rootSeedBuffer = await BCH.Mnemonic.toSeed(mnemonic);
 
         let masterHDNode;
 
         if (NETWORK === `mainnet`) {
             masterHDNode = BCH.HDNode.fromSeed(rootSeedBuffer);
         } else {
             masterHDNode = BCH.HDNode.fromSeed(rootSeedBuffer, 'testnet');
         }
         const Path1899 = await deriveAccount(BCH, {
             masterHDNode,
             path: "m/44'/1899'/0'/0/0",
         });
 
         wallet.Path1899 = Path1899;
 
         try {
             await localforage.setItem('wallet', wallet);
         } catch (err) {
             console.log(
                 `Error setting wallet to wallet indexedDb in migrateLegacyWallet()`,
             );
             console.log(err);
         }
 
         return wallet;
     };
 
     const getWalletDetails = async wallet => {
         if (!wallet) {
             return false;
         }
         // Since this info is in localforage now, only get the var
         const NETWORK = process.env.REACT_APP_NETWORK;
         const mnemonic = wallet.mnemonic;
         const rootSeedBuffer = await BCH.Mnemonic.toSeed(mnemonic);
         let masterHDNode;
 
         if (NETWORK === `mainnet`) {
             masterHDNode = BCH.HDNode.fromSeed(rootSeedBuffer);
         } else {
             masterHDNode = BCH.HDNode.fromSeed(rootSeedBuffer, 'testnet');
         }
 
         const Path245 = await deriveAccount(BCH, {
             masterHDNode,
             path: "m/44'/245'/0'/0/0",
         });
         const Path145 = await deriveAccount(BCH, {
             masterHDNode,
             path: "m/44'/145'/0'/0/0",
         });
         const Path1899 = await deriveAccount(BCH, {
             masterHDNode,
             path: "m/44'/1899'/0'/0/0",
         });
 
         let name = Path1899.cashAddress.slice(12, 17);
         // Only set the name if it does not currently exist
         if (wallet && wallet.name) {
             name = wallet.name;
         }
 
         return {
             mnemonic: wallet.mnemonic,
             name,
             Path245,
             Path145,
             Path1899,
         };
     };
 
     const getSavedWallets = async activeWallet => {
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
             if (savedWallets === null) {
                 savedWallets = [];
             }
         } catch (err) {
             console.log(`Error in getSavedWallets`);
             console.log(err);
             savedWallets = [];
         }
         // Even though the active wallet is still stored in savedWallets, don't return it in this function
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (
                 typeof activeWallet !== 'undefined' &&
                 activeWallet.name &&
                 savedWallets[i].name === activeWallet.name
             ) {
                 savedWallets.splice(i, 1);
             }
         }
         return savedWallets;
     };
 
     const activateWallet = async walletToActivate => {
         /*
     If the user is migrating from old version to this version, make sure to save the activeWallet
 
     1 - check savedWallets for the previously active wallet
     2 - If not there, add it
     */
         let currentlyActiveWallet;
         try {
             currentlyActiveWallet = await localforage.getItem('wallet');
         } catch (err) {
             console.log(
                 `Error in localforage.getItem("wallet") in activateWallet()`,
             );
             return false;
         }
         // Get savedwallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(
                 `Error in localforage.getItem("savedWallets") in activateWallet()`,
             );
             return false;
         }
         /*
         When a legacy user runs cashtabapp.com/, their active wallet will be migrated to Path1899 by 
         the getWallet function
 
         Wallets in savedWallets are migrated when they are activated, in this function
 
         Two cases to handle
 
         1 - currentlyActiveWallet has Path1899, but its stored keyvalue pair in savedWallets does not
             > Update savedWallets so that Path1899 is added to currentlyActiveWallet
         
         2 - walletToActivate does not have Path1899
             > Update walletToActivate with Path1899 before activation
         */
 
         // Check savedWallets for currentlyActiveWallet
         let walletInSavedWallets = false;
         let walletUnmigrated = false;
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (savedWallets[i].name === currentlyActiveWallet.name) {
                 walletInSavedWallets = true;
                 // Check savedWallets for unmigrated currentlyActiveWallet
                 if (!savedWallets[i].Path1899) {
                     // Case 1, described above
                     console.log(
                         `Case 1: Wallet migration in saved wallets still pending, adding Path1899`,
                     );
                     savedWallets[i].Path1899 = currentlyActiveWallet.Path1899;
                     walletUnmigrated = true;
                 }
             }
         }
 
         // Case 1
         if (walletUnmigrated) {
             // resave savedWallets
             try {
                 // Set walletName as the active wallet
                 await localforage.setItem('savedWallets', savedWallets);
             } catch (err) {
                 console.log(
                     `Error in localforage.setItem("savedWallets") in activateWallet() for unmigrated wallet`,
                 );
             }
         }
 
         if (!walletInSavedWallets) {
             console.log(`Wallet is not in saved Wallets, adding`);
             savedWallets.push(currentlyActiveWallet);
             // resave savedWallets
             try {
                 // Set walletName as the active wallet
                 await localforage.setItem('savedWallets', savedWallets);
             } catch (err) {
                 console.log(
                     `Error in localforage.setItem("savedWallets") in activateWallet()`,
                 );
             }
         }
         // If wallet does not have Path1899, add it
 
         if (!walletToActivate.Path1899) {
             // Case 2, described above
             console.log(`Case 2: Wallet to activate does not have Path1899`);
             console.log(
                 `Wallet to activate from SavedWallets does not have Path1899`,
             );
             console.log(`walletToActivate`, walletToActivate);
             walletToActivate = await migrateLegacyWallet(BCH, walletToActivate);
         } else {
             // Otherwise activate it as normal
             // Now that we have verified the last wallet was saved, we can activate the new wallet
             try {
                 await localforage.setItem('wallet', walletToActivate);
             } catch (err) {
                 console.log(
                     `Error in localforage.setItem("wallet", walletToActivate) in activateWallet()`,
                 );
                 return false;
             }
         }
 
         return walletToActivate;
     };
 
     const renameWallet = async (oldName, newName) => {
         // Load savedWallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(
                 `Error in await localforage.getItem("savedWallets") in renameWallet`,
             );
             console.log(err);
             return false;
         }
         // Verify that no existing wallet has this name
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (savedWallets[i].name === newName) {
                 // return an error
                 return false;
             }
         }
 
         // change name of desired wallet
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (savedWallets[i].name === oldName) {
                 // Replace the name of this entry with the new name
                 savedWallets[i].name = newName;
             }
         }
         // resave savedWallets
         try {
             // Set walletName as the active wallet
             await localforage.setItem('savedWallets', savedWallets);
         } catch (err) {
             console.log(
                 `Error in localforage.setItem("savedWallets", savedWallets) in renameWallet()`,
             );
             return false;
         }
         return true;
     };
 
     const deleteWallet = async walletToBeDeleted => {
         // delete a wallet
         // returns true if wallet is successfully deleted
         // otherwise returns false
         // Load savedWallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(
                 `Error in await localforage.getItem("savedWallets") in deleteWallet`,
             );
             console.log(err);
             return false;
         }
         // Iterate over to find the wallet to be deleted
         // Verify that no existing wallet has this name
         let walletFoundAndRemoved = false;
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (savedWallets[i].name === walletToBeDeleted.name) {
                 // Verify it has the same mnemonic too, that's a better UUID
                 if (savedWallets[i].mnemonic === walletToBeDeleted.mnemonic) {
                     // Delete it
                     savedWallets.splice(i, 1);
                     walletFoundAndRemoved = true;
                 }
             }
         }
         // If you don't find the wallet, return false
         if (!walletFoundAndRemoved) {
             return false;
         }
 
         // Resave savedWallets less the deleted wallet
         try {
             // Set walletName as the active wallet
             await localforage.setItem('savedWallets', savedWallets);
         } catch (err) {
             console.log(
                 `Error in localforage.setItem("savedWallets", savedWallets) in deleteWallet()`,
             );
             return false;
         }
         return true;
     };
 
     const addNewSavedWallet = async importMnemonic => {
         // Add a new wallet to savedWallets from importMnemonic or just new wallet
         const lang = 'english';
         // create 128 bit BIP39 mnemonic
         const Bip39128BitMnemonic = importMnemonic
             ? importMnemonic
             : BCH.Mnemonic.generate(128, BCH.Mnemonic.wordLists()[lang]);
         const newSavedWallet = await getWalletDetails({
             mnemonic: Bip39128BitMnemonic.toString(),
         });
         // Get saved wallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
             // If this doesn't exist yet, savedWallets === null
             if (savedWallets === null) {
                 savedWallets = [];
             }
         } catch (err) {
             console.log(
                 `Error in savedWallets = await localforage.getItem("savedWallets") in addNewSavedWallet()`,
             );
             console.log(err);
             console.log(`savedWallets in error state`, savedWallets);
         }
         // If this wallet is from an imported mnemonic, make sure it does not already exist in savedWallets
         if (importMnemonic) {
             for (let i = 0; i < savedWallets.length; i += 1) {
                 // Check for condition "importing new wallet that is already in savedWallets"
                 if (savedWallets[i].mnemonic === importMnemonic) {
                     // set this as the active wallet to keep name history
                     console.log(
                         `Error: this wallet already exists in savedWallets`,
                     );
                     console.log(`Wallet not being added.`);
                     return false;
                 }
             }
         }
         // add newSavedWallet
         savedWallets.push(newSavedWallet);
         // update savedWallets
         try {
             await localforage.setItem('savedWallets', savedWallets);
         } catch (err) {
             console.log(
                 `Error in localforage.setItem("savedWallets", activeWallet) called in createWallet with ${importMnemonic}`,
             );
             console.log(`savedWallets`, savedWallets);
             console.log(err);
         }
         return true;
     };
 
     const createWallet = async importMnemonic => {
         const lang = 'english';
         // create 128 bit BIP39 mnemonic
         const Bip39128BitMnemonic = importMnemonic
             ? importMnemonic
             : BCH.Mnemonic.generate(128, BCH.Mnemonic.wordLists()[lang]);
         const wallet = await getWalletDetails({
             mnemonic: Bip39128BitMnemonic.toString(),
         });
 
         try {
             await localforage.setItem('wallet', wallet);
         } catch (err) {
             console.log(
                 `Error setting wallet to wallet indexedDb in createWallet()`,
             );
             console.log(err);
         }
         // Since this function is only called from OnBoarding.js, also add this to the saved wallet
         try {
             await localforage.setItem('savedWallets', [wallet]);
         } catch (err) {
             console.log(
                 `Error setting wallet to savedWallets indexedDb in createWallet()`,
             );
             console.log(err);
         }
         return wallet;
     };
 
     const validateMnemonic = (
         mnemonic,
         wordlist = BCH.Mnemonic.wordLists().english,
     ) => {
         let mnemonicTestOutput;
 
         try {
             mnemonicTestOutput = BCH.Mnemonic.validate(mnemonic, wordlist);
 
             if (mnemonicTestOutput === 'Valid mnemonic') {
                 return true;
             } else {
                 return false;
             }
         } catch (err) {
             console.log(err);
             return false;
         }
     };
 
     const handleUpdateWallet = async setWallet => {
         const wallet = await getWallet();
         setWallet(wallet);
     };
 
     // Parse for incoming BCH transactions
     // Only notify if websocket is not connected
     if (
         (ws === null || ws.readyState !== 1) &&
         previousBalances &&
         balances &&
         'totalBalance' in previousBalances &&
         'totalBalance' in balances &&
         new BigNumber(balances.totalBalance)
             .minus(previousBalances.totalBalance)
             .gt(0)
     ) {
         notification.success({
             message: 'Transaction received',
             description: (
                 <Paragraph>
                     You received{' '}
                     {Number(
                         balances.totalBalance - previousBalances.totalBalance,
-                    ).toFixed(8)}{' '}
+                    ).toFixed(currency.cashDecimals)}{' '}
                     BCH!
                 </Paragraph>
             ),
             duration: 3,
         });
     }
 
     // Parse for incoming SLP transactions
     if (
         tokens &&
         tokens[0] &&
         tokens[0].balance &&
         previousTokens &&
         previousTokens[0] &&
         previousTokens[0].balance
     ) {
         // If tokens length is greater than previousTokens length, a new token has been received
         // Note, a user could receive a new token, AND more of existing tokens in between app updates
         // In this case, the app will only notify about the new token
         // TODO better handling for all possible cases to cover this
         // TODO handle with websockets for better response time, less complicated calc
         if (tokens.length > previousTokens.length) {
             // Find the new token
             const tokenIds = tokens.map(({ tokenId }) => tokenId);
             const previousTokenIds = previousTokens.map(
                 ({ tokenId }) => tokenId,
             );
             //console.log(`tokenIds`, tokenIds);
             //console.log(`previousTokenIds`, previousTokenIds);
 
             // An array with the new token Id
             const newTokenIdArr = tokenIds.filter(
                 tokenId => !previousTokenIds.includes(tokenId),
             );
             // It's possible that 2 new tokens were received
             // To do, handle this case
             const newTokenId = newTokenIdArr[0];
             //console.log(newTokenId);
 
             // How much of this tokenId did you get?
             // would be at
 
             // Find where the newTokenId is
             const receivedTokenObjectIndex = tokens.findIndex(
                 x => x.tokenId === newTokenId,
             );
             //console.log(`receivedTokenObjectIndex`, receivedTokenObjectIndex);
             // Calculate amount received
             //console.log(`receivedTokenObject:`, tokens[receivedTokenObjectIndex]);
 
             const receivedSlpQty = tokens[
                 receivedTokenObjectIndex
             ].balance.toString();
             const receivedSlpTicker =
                 tokens[receivedTokenObjectIndex].info.tokenTicker;
             const receivedSlpName =
                 tokens[receivedTokenObjectIndex].info.tokenName;
             //console.log(`receivedSlpQty`, receivedSlpQty);
 
             // Notification if you received SLP
             if (receivedSlpQty > 0) {
                 notification.success({
                     message: `${currency.tokenTicker} Transaction received: ${receivedSlpTicker}`,
                     description: (
                         <Paragraph>
                             You received {receivedSlpQty} {receivedSlpName}
                         </Paragraph>
                     ),
                     duration: 5,
                 });
             }
 
             //
         } else {
             // If tokens[i].balance > previousTokens[i].balance, a new SLP tx of an existing token has been received
             // Note that tokens[i].balance is of type BigNumber
             for (let i = 0; i < tokens.length; i += 1) {
                 if (tokens[i].balance.gt(previousTokens[i].balance)) {
                     // Received this token
                     // console.log(`previousTokenId`, previousTokens[i].tokenId);
                     // console.log(`currentTokenId`, tokens[i].tokenId);
 
                     if (previousTokens[i].tokenId !== tokens[i].tokenId) {
                         console.log(
                             `TokenIds do not match, breaking from SLP notifications`,
                         );
                         // Then don't send the notification
                         // Also don't 'continue' ; this means you have sent a token, just stop iterating through
                         break;
                     }
                     const receivedSlpQty = tokens[i].balance.minus(
                         previousTokens[i].balance,
                     );
 
                     const receivedSlpTicker = tokens[i].info.tokenTicker;
                     const receivedSlpName = tokens[i].info.tokenName;
 
                     notification.success({
                         message: `SLP Transaction received: ${receivedSlpTicker}`,
                         description: (
                             <Paragraph>
                                 You received {receivedSlpQty.toString()}{' '}
                                 {receivedSlpName}
                             </Paragraph>
                         ),
                         duration: 5,
                     });
                 }
             }
         }
     }
 
     //  Update price every 1 min
     useAsyncTimeout(async () => {
         fetchBchPrice();
     }, 60000);
 
     // Update wallet every 10s
     useAsyncTimeout(async () => {
         const wallet = await getWallet();
         update({
             wallet,
             setWalletState,
         }).finally(() => {
             setLoading(false);
         });
     }, 10000);
 
     const initializeWebsocket = (cashAddress, slpAddress) => {
         // console.log(`initializeWebsocket(${cashAddress}, ${slpAddress})`);
         // This function parses 3 cases
         // 1: edge case, websocket is in state but not properly connected
         //    > Remove it from state and forget about it, fall back to normal notifications
         // 2: edge-ish case, websocket is in state and connected but user has changed wallet
         //    > Unsubscribe from old addresses and subscribe to new ones
         // 3: most common: app is opening, creating websocket with existing addresses
 
         // If the websocket is already in state but is not properly connected
         if (ws !== null && ws.readyState !== 1) {
             // Forget about it and use conventional notifications
 
             // Close
             ws.close();
             // Remove from state
             setWs(null);
         }
         // If the websocket is in state and connected
         else if (ws !== null) {
             // console.log(`Websocket already in state`);
             // console.log(`ws,`, ws);
             // instead of initializing websocket, unsubscribe from old addresses and subscribe to new ones
             const previousWsCashAddress = previousWallet.Path145.legacyAddress;
             const previousWsSlpAddress = previousWallet.Path245.legacyAddress;
             try {
                 // Unsubscribe from previous addresses
                 ws.send(
                     JSON.stringify({
                         op: 'addr_unsub',
                         addr: previousWsCashAddress,
                     }),
                 );
                 console.log(
                     `Unsubscribed from BCH address at ${previousWsCashAddress}`,
                 );
                 ws.send(
                     JSON.stringify({
                         op: 'addr_unsub',
                         addr: previousWsSlpAddress,
                     }),
                 );
                 console.log(
                     `Unsubscribed from SLP address at ${previousWsSlpAddress}`,
                 );
 
                 // Subscribe to new addresses
                 ws.send(
                     JSON.stringify({
                         op: 'addr_sub',
                         addr: cashAddress,
                     }),
                 );
                 console.log(`Subscribed to BCH address at ${cashAddress}`);
                 // Subscribe to SLP address
                 ws.send(
                     JSON.stringify({
                         op: 'addr_sub',
                         addr: slpAddress,
                     }),
                 );
                 console.log(`Subscribed to SLP address at ${slpAddress}`);
                 // Reset onmessage; it was previously set with the old addresses
                 // Note this code is exactly identical to lines 431-490
                 // TODO put in function
                 ws.onmessage = e => {
                     // TODO handle case where receive multiple messages on one incoming transaction
                     //console.log(`ws msg received`);
                     const incomingTx = JSON.parse(e.data);
                     console.log(incomingTx);
 
                     let bchSatsReceived = 0;
                     // First, check the inputs
                     // If cashAddress or slpAddress are in the inputs, then this is a sent tx and should be ignored for notifications
                     if (
                         incomingTx &&
                         incomingTx.x &&
                         incomingTx.x.inputs &&
                         incomingTx.x.out
                     ) {
                         const inputs = incomingTx.x.inputs;
                         // Iterate over inputs and see if this transaction was sent by the active wallet
                         for (let i = 0; i < inputs.length; i += 1) {
                             if (
                                 inputs[i].prev_out.addr === cashAddress ||
                                 inputs[i].prev_out.addr === slpAddress
                             ) {
                                 // console.log(`Found a sending tx, not notifying`);
                                 // This is a sent transaction and should be ignored by notification handlers
                                 return;
                             }
                         }
                         // Iterate over outputs to determine receiving address
                         const outputs = incomingTx.x.out;
 
                         for (let i = 0; i < outputs.length; i += 1) {
                             if (outputs[i].addr === cashAddress) {
                                 // console.log(`BCH transaction received`);
                                 bchSatsReceived += outputs[i].value;
                                 // handle
                             }
                             if (outputs[i].addr === slpAddress) {
                                 console.log(`SLP transaction received`);
                                 //handle
                                 // you would want to get the slp info using this endpoint:
                                 // https://rest.kingbch.com/v3/slp/txDetails/cb39dd04e07e172a37addfcb1d6e167dc52c01867ba21c9bf8b5acf4dd969a3f
                                 // But it does not work for unconfirmed txs
                                 // Hold off on slp tx notifications for now
                             }
                         }
                     }
                     // parse for receiving address
                     // if received at cashAddress, parse for BCH amount, notify BCH received
                     // if received at slpAddress, parse for token, notify SLP received
                     // if those checks fail, could be from a 'sent' tx, ignore
 
                     // Note, when you send an SLP tx, you get SLP change to SLP address and BCH change to BCH address
 
                     // Also note, when you send an SLP tx, you often have inputs from both BCH and SLP addresses
 
                     // This causes a sent SLP tx to register 4 times from the websocket
 
                     // Best way to ignore this is to ignore any incoming utx.x with BCH or SLP address in the inputs
 
                     // Notification for received BCH
                     if (bchSatsReceived > 0) {
                         notification.success({
                             message: 'Transaction received',
                             description: (
                                 <Paragraph>
                                     You received {bchSatsReceived / 1e8} BCH!
                                 </Paragraph>
                             ),
                             duration: 3,
                         });
                     }
                 };
             } catch (err) {
                 console.log(
                     `Error attempting to configure websocket for new wallet`,
                 );
                 console.log(err);
                 console.log(`Closing connection`);
                 ws.close();
                 setWs(null);
             }
         } else {
             // If there is no websocket, create one, subscribe to addresses, and add notifications for incoming BCH transactions
 
             let newWs = new WebSocket('wss://ws.blockchain.info/bch/inv');
 
             newWs.onopen = () => {
                 console.log(`Connected to bchWs`);
 
                 // Subscribe to BCH address
                 newWs.send(
                     JSON.stringify({
                         op: 'addr_sub',
                         addr: cashAddress,
                     }),
                 );
 
                 console.log(`Subscribed to BCH address at ${cashAddress}`);
                 // Subscribe to SLP address
                 newWs.send(
                     JSON.stringify({
                         op: 'addr_sub',
                         addr: slpAddress,
                     }),
                 );
                 console.log(`Subscribed to SLP address at ${slpAddress}`);
             };
             newWs.onerror = e => {
                 // close and set to null
                 console.log(`Error in websocket connection for ${newWs}`);
                 console.log(e);
                 setWs(null);
             };
             newWs.onclose = () => {
                 console.log(`Websocket connection closed`);
                 // Unsubscribe on close to prevent double subscribing
                 //{"op":"addr_unsub", "addr":"$bitcoin_address"}
                 newWs.send(
                     JSON.stringify({
                         op: 'addr_unsub',
                         addr: cashAddress,
                     }),
                 );
                 console.log(`Unsubscribed from BCH address at ${cashAddress}`);
                 newWs.send(
                     JSON.stringify({
                         op: 'addr_sub',
                         addr: slpAddress,
                     }),
                 );
                 console.log(`Unsubscribed from SLP address at ${slpAddress}`);
             };
             newWs.onmessage = e => {
                 // TODO handle case where receive multiple messages on one incoming transaction
                 //console.log(`ws msg received`);
                 const incomingTx = JSON.parse(e.data);
                 console.log(incomingTx);
 
                 let bchSatsReceived = 0;
                 // First, check the inputs
                 // If cashAddress or slpAddress are in the inputs, then this is a sent tx and should be ignored for notifications
                 if (
                     incomingTx &&
                     incomingTx.x &&
                     incomingTx.x.inputs &&
                     incomingTx.x.out
                 ) {
                     const inputs = incomingTx.x.inputs;
                     // Iterate over inputs and see if this transaction was sent by the active wallet
                     for (let i = 0; i < inputs.length; i += 1) {
                         if (
                             inputs[i].prev_out.addr === cashAddress ||
                             inputs[i].prev_out.addr === slpAddress
                         ) {
                             // console.log(`Found a sending tx, not notifying`);
                             // This is a sent transaction and should be ignored by notification handlers
                             return;
                         }
                     }
                     // Iterate over outputs to determine receiving address
                     const outputs = incomingTx.x.out;
 
                     for (let i = 0; i < outputs.length; i += 1) {
                         if (outputs[i].addr === cashAddress) {
                             // console.log(`BCH transaction received`);
                             bchSatsReceived += outputs[i].value;
                             // handle
                         }
                         if (outputs[i].addr === slpAddress) {
                             console.log(`SLP transaction received`);
                             //handle
                             // you would want to get the slp info using this endpoint:
                             // https://rest.kingbch.com/v3/slp/txDetails/cb39dd04e07e172a37addfcb1d6e167dc52c01867ba21c9bf8b5acf4dd969a3f
                             // But it does not work for unconfirmed txs
                             // Hold off on slp tx notifications for now
                         }
                     }
                 }
                 // parse for receiving address
                 // if received at cashAddress, parse for BCH amount, notify BCH received
                 // if received at slpAddress, parse for token, notify SLP received
                 // if those checks fail, could be from a 'sent' tx, ignore
 
                 // Note, when you send an SLP tx, you get SLP change to SLP address and BCH change to BCH address
 
                 // Also note, when you send an SLP tx, you often have inputs from both BCH and SLP addresses
 
                 // This causes a sent SLP tx to register 4 times from the websocket
 
                 // Best way to ignore this is to ignore any incoming utx.x with BCH or SLP address in the inputs
 
                 // Notification for received BCH
                 if (bchSatsReceived > 0) {
                     notification.success({
                         message: 'Transaction received',
                         description: (
                             <Paragraph>
                                 You received {bchSatsReceived / 1e8} BCH!
                             </Paragraph>
                         ),
                         duration: 3,
                     });
                 }
             };
 
             setWs(newWs);
         }
     };
 
     const fetchBchPrice = async () => {
         // Split this variable out in case coingecko changes
         const cryptoId = currency.coingeckoId;
         // Keep currency as a variable as eventually it will be a user setting
         const fiatCode = 'usd';
         // Keep this in the code, because different URLs will have different outputs require different parsing
         const priceApiUrl = `https://api.coingecko.com/api/v3/simple/price?ids=${cryptoId}&vs_currencies=${fiatCode}&include_last_updated_at=true`;
         let bchPrice;
         let bchPriceJson;
         try {
             bchPrice = await fetch(priceApiUrl);
             //console.log(`bchPrice`, bchPrice);
         } catch (err) {
             console.log(`Error fetching BCH Price`);
             console.log(err);
         }
         try {
             bchPriceJson = await bchPrice.json();
             //console.log(`bchPriceJson`, bchPriceJson);
             const bchPriceInFiat = bchPriceJson[cryptoId][fiatCode];
             //console.log(`bchPriceInFiat`, bchPriceInFiat);
             setFiatPrice(bchPriceInFiat);
         } catch (err) {
             console.log(`Error parsing price API response to JSON`);
             console.log(err);
         }
     };
 
     useEffect(() => {
         handleUpdateWallet(setWallet);
         fetchBchPrice();
     }, []);
 
     useEffect(() => {
         if (
             wallet &&
             wallet.Path145 &&
             wallet.Path145.cashAddress &&
             wallet.Path245 &&
             wallet.Path245.cashAddress
         ) {
             if (currency.useBlockchainWs) {
                 initializeWebsocket(
                     wallet.Path145.legacyAddress,
                     wallet.Path245.legacyAddress,
                 );
             }
         }
     }, [wallet]);
 
     return {
         BCH,
         wallet,
         fiatPrice,
         slpBalancesAndUtxos,
         balances,
         tokens,
         txHistory,
         loading,
         apiError,
         getActiveWalletFromLocalForage,
         getWallet,
         validateMnemonic,
         getWalletDetails,
         getSavedWallets,
         migrateLegacyWallet,
         update: async () =>
             update({
                 wallet: await getWallet(),
                 setLoading,
                 setWalletState,
             }),
         createWallet: async importMnemonic => {
             setLoading(true);
             const newWallet = await createWallet(importMnemonic);
             setWallet(newWallet);
             update({
                 wallet: newWallet,
                 setWalletState,
             }).finally(() => setLoading(false));
         },
         activateWallet: async walletToActivate => {
             setLoading(true);
             const newWallet = await activateWallet(walletToActivate);
             setWallet(newWallet);
             update({
                 wallet: newWallet,
                 setWalletState,
             }).finally(() => setLoading(false));
         },
         addNewSavedWallet,
         renameWallet,
         deleteWallet,
     };
 };
 
 export default useWallet;
diff --git a/web/cashtab/src/utils/__tests__/validation.test.js b/web/cashtab/src/utils/__tests__/validation.test.js
index 8d5d965da..b644dcd18 100644
--- a/web/cashtab/src/utils/__tests__/validation.test.js
+++ b/web/cashtab/src/utils/__tests__/validation.test.js
@@ -1,82 +1,82 @@
 import { shouldRejectAmountInput, fiatToCrypto } from '../validation';
 import { currency } from '@components/Common/Ticker.js';
 
 describe('Validation utils', () => {
     it(`Returns 'false' if ${currency.ticker} send amount is a valid send amount`, () => {
         expect(shouldRejectAmountInput('10', currency.ticker, 20.0, 300)).toBe(
             false,
         );
     });
     it(`Returns 'false' if ${currency.ticker} send amount is a valid send amount in USD`, () => {
         // Here, user is trying to send $170 USD, where 1 BCHA = $20 USD, and the user has a balance of 15 BCHA or $300
         expect(shouldRejectAmountInput('170', 'USD', 20.0, 15)).toBe(false);
     });
     it(`Returns not a number if ${currency.ticker} send amount is not a number`, () => {
         const expectedValidationError = `Amount must be a number`;
         expect(
             shouldRejectAmountInput('Not a number', currency.ticker, 20.0, 3),
         ).toBe(expectedValidationError);
     });
     it(`Returns amount must be greater than 0 if ${currency.ticker} send amount is 0`, () => {
         const expectedValidationError = `Amount must be greater than 0`;
         expect(shouldRejectAmountInput('0', currency.ticker, 20.0, 3)).toBe(
             expectedValidationError,
         );
     });
     it(`Returns amount must be greater than 0 if ${currency.ticker} send amount is less than 0`, () => {
         const expectedValidationError = `Amount must be greater than 0`;
         expect(
             shouldRejectAmountInput('-0.031', currency.ticker, 20.0, 3),
         ).toBe(expectedValidationError);
     });
     it(`Returns balance error if ${currency.ticker} send amount is greater than user balance`, () => {
         const expectedValidationError = `Amount cannot exceed your ${currency.ticker} balance`;
         expect(shouldRejectAmountInput('17', currency.ticker, 20.0, 3)).toBe(
             expectedValidationError,
         );
     });
     it(`Returns balance error if ${currency.ticker} send amount is greater than user balance`, () => {
         const expectedValidationError = `Amount cannot exceed your ${currency.ticker} balance`;
         expect(shouldRejectAmountInput('17', currency.ticker, 20.0, 3)).toBe(
             expectedValidationError,
         );
     });
     it(`Returns error if ${currency.ticker} send amount is less than ${currency.dust} minimum`, () => {
         const expectedValidationError = `Send amount must be at least ${currency.dust} ${currency.ticker}`;
         expect(
             shouldRejectAmountInput(
                 (currency.dust - 0.00000001).toString(),
                 currency.ticker,
                 20.0,
                 3,
             ),
         ).toBe(expectedValidationError);
     });
     it(`Returns error if ${currency.ticker} send amount is less than ${currency.dust} minimum in fiat currency`, () => {
         const expectedValidationError = `Send amount must be at least ${currency.dust} ${currency.ticker}`;
         expect(
             shouldRejectAmountInput('0.0000005', 'USD', 14.63, 0.52574662),
         ).toBe(expectedValidationError);
     });
     it(`Returns balance error if ${currency.ticker} send amount is greater than user balance with fiat currency selected`, () => {
         const expectedValidationError = `Amount cannot exceed your ${currency.ticker} balance`;
         // Here, user is trying to send $170 USD, where 1 BCHA = $20 USD, and the user has a balance of 5 BCHA or $100
         expect(shouldRejectAmountInput('170', 'USD', 20.0, 5)).toBe(
             expectedValidationError,
         );
     });
-    it(`Returns precision error if ${currency.ticker} send amount has more than 8 decimal places`, () => {
-        const expectedValidationError = `${currency.ticker} transactions do not support more than 8 decimal places`;
+    it(`Returns precision error if ${currency.ticker} send amount has more than ${currency.cashDecimals} decimal places`, () => {
+        const expectedValidationError = `${currency.ticker} transactions do not support more than ${currency.cashDecimals} decimal places`;
         expect(
             shouldRejectAmountInput('17.123456789', currency.ticker, 20.0, 35),
         ).toBe(expectedValidationError);
     });
-    it(`Returns expected crypto amount with 8 decimals of precision even if inputs have higher precision`, () => {
+    it(`Returns expected crypto amount with ${currency.cashDecimals} decimals of precision even if inputs have higher precision`, () => {
         expect(fiatToCrypto('10.97231694823432', 20.3231342349234234)).toBe(
             '0.53989295',
         );
     });
-    it(`Returns expected crypto amount with 8 decimals of precision even if inputs have lower precision`, () => {
+    it(`Returns expected crypto amount with ${currency.cashDecimals} decimals of precision even if inputs have lower precision`, () => {
         expect(fiatToCrypto('10.94', 10)).toBe('1.09400000');
     });
 });
diff --git a/web/cashtab/src/utils/validation.js b/web/cashtab/src/utils/validation.js
index 43a716f0c..893d77098 100644
--- a/web/cashtab/src/utils/validation.js
+++ b/web/cashtab/src/utils/validation.js
@@ -1,44 +1,45 @@
 import BigNumber from 'bignumber.js';
 import { currency } from '@components/Common/Ticker.js';
 
 // Validate cash amount
 export const shouldRejectAmountInput = (
     cashAmount,
     selectedCurrency,
     fiatPrice,
     totalCashBalance,
 ) => {
     // Take cashAmount as input, a string from form input
     let error = false;
     let testedAmount = new BigNumber(cashAmount);
 
     if (selectedCurrency === 'USD') {
         // Ensure no more than 8 decimal places
         testedAmount = new BigNumber(fiatToCrypto(cashAmount, fiatPrice));
     }
 
     // Validate value for > 0
     if (isNaN(testedAmount)) {
         error = 'Amount must be a number';
     } else if (testedAmount.lte(0)) {
         error = 'Amount must be greater than 0';
     } else if (testedAmount.lt(currency.dust)) {
         error = `Send amount must be at least ${currency.dust} ${currency.ticker}`;
     } else if (testedAmount.gt(totalCashBalance)) {
         error = `Amount cannot exceed your ${currency.ticker} balance`;
     } else if (!isNaN(testedAmount) && testedAmount.toString().includes('.')) {
-        if (testedAmount.toString().split('.')[1].length > 8) {
-            error = `${currency.ticker} transactions do not support more than 8 decimal places`;
+        if (
+            testedAmount.toString().split('.')[1].length > currency.cashDecimals
+        ) {
+            error = `${currency.ticker} transactions do not support more than ${currency.cashDecimals} decimal places`;
         }
     }
     // return false if no error, or string error msg if error
     return error;
 };
 
 export const fiatToCrypto = (fiatAmount, fiatPrice) => {
-    // Return a string with no more than 8 decimal places
     let cryptoAmount = new BigNumber(fiatAmount)
         .div(new BigNumber(fiatPrice))
-        .toFixed(8);
+        .toFixed(currency.cashDecimals);
     return cryptoAmount;
 };