diff --git a/web/cashtab/src/components/Common/Ticker.js b/web/cashtab/src/components/Common/Ticker.js
index cdb33382e..8626190c7 100644
--- a/web/cashtab/src/components/Common/Ticker.js
+++ b/web/cashtab/src/components/Common/Ticker.js
@@ -1,152 +1,177 @@
 import mainLogo from '@assets/logo_primary.png';
 import tokenLogo from '@assets/logo_secondary.png';
 import cashaddr from 'cashaddrjs';
 import BigNumber from 'bignumber.js';
 
 export const currency = {
     name: 'eCash',
     ticker: 'XEC',
     logo: mainLogo,
     legacyPrefix: 'bitcoincash',
     prefixes: ['bitcoincash', 'ecash'],
     coingeckoId: 'bitcoin-cash-abc-2',
     defaultFee: 2.01,
     dustSats: 546,
     cashDecimals: 2,
     blockExplorerUrl: 'https://explorer.bitcoinabc.org',
     tokenExplorerUrl: 'https://explorer.be.cash',
     blockExplorerUrlTestnet: 'https://texplorer.bitcoinabc.org',
     tokenName: 'eToken',
     tokenTicker: 'eToken',
     tokenLogo: tokenLogo,
     tokenPrefixes: ['simpleledger', 'etoken'],
     tokenIconsUrl: '', //https://tokens.bitcoin.com/32 for BCH SLP
     useBlockchainWs: false,
     txHistoryCount: 5,
     hydrateUtxoBatchSize: 20,
     defaultSettings: { fiatCurrency: 'usd' },
-    settingsValidation: { fiatCurrency: ['usd', 'idr', 'krw', 'cny'] },
+    settingsValidation: {
+        fiatCurrency: [
+            'usd',
+            'idr',
+            'krw',
+            'cny',
+            'zar',
+            'vnd',
+            'cad',
+            'nok',
+            'eur',
+            'gbp',
+            'jpy',
+            'try',
+            'rub',
+        ],
+    },
     fiatCurrencies: {
         usd: { name: 'US Dollar', symbol: '$', slug: 'usd' },
+        gbp: { name: 'British Pound', symbol: '£', slug: 'gbp' },
+        cad: { name: 'Canadian Dollar', symbol: '$', slug: 'cad' },
+        cny: { name: 'Chinese Yuan', symbol: '元', slug: 'cny' },
+        eur: { name: 'Euro', symbol: '€', slug: 'eur' },
         idr: { name: 'Indonesian Rupiah', symbol: 'Rp', slug: 'idr' },
+        jpy: { name: 'Japanese Yen', symbol: '¥', slug: 'jpy' },
         krw: { name: 'Korean Won', symbol: '₩', slug: 'krw' },
-        cny: { name: 'Chinese Yuan', symbol: '元', slug: 'cny' },
+        nok: { name: 'Norwegian Krone', symbol: 'kr', slug: 'nok' },
+        rub: { name: 'Russian Ruble', symbol: 'р.', slug: 'rub' },
+        zar: { name: 'South African Rand', symbol: 'R', slug: 'zar' },
+        try: { name: 'Turkish Lira', symbol: '₺', slug: 'try' },
+        vnd: { name: 'Vietnamese đồng', symbol: 'đ', slug: 'vnd' },
     },
 };
 
 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 1af002446..784e8ce72 100644
--- a/web/cashtab/src/components/Send/Send.js
+++ b/web/cashtab/src/components/Send/Send.js
@@ -1,572 +1,575 @@
 import React, { useState, useEffect } from 'react';
 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';
 import { formatBalance } from '@utils/cashMethods';
 import {
     BalanceHeader,
     BalanceHeaderFiat,
     ZeroBalanceHeader,
     ConvertAmount,
     AlertMsg,
 } from '@components/Common/Atoms';
 
 // Note jestBCH is only used for unit tests; BCHJS must be mocked for jest
 const SendBCH = ({ jestBCH, filledAddress, callbackTxId }) => {
     // use balance parameters from wallet.state object and not legacy balances parameter from walletState, if user has migrated wallet
     // this handles edge case of user with old wallet who has not opened latest Cashtab version yet
 
     // If the wallet object from ContextValue has a `state key`, then check which keys are in the wallet object
     // Else set it as blank
     const ContextValue = React.useContext(WalletContext);
     const {
         wallet,
         fiatPrice,
         slpBalancesAndUtxos,
         apiError,
         cashtabSettings,
     } = ContextValue;
     let balances;
     const paramsInWalletState = wallet.state ? Object.keys(wallet.state) : [];
     // If wallet.state includes balances and parsedTxHistory params, use these
     // These are saved in indexedDb in the latest version of the app, hence accessible more quickly
     if (paramsInWalletState.includes('balances')) {
         balances = wallet.state.balances;
     } else {
         // If balances and parsedTxHistory are not in the wallet.state object, load them from Context
         // This is how the app used to work
         balances = ContextValue.balances;
     }
 
     // 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();
 
     // jestBCH is only ever specified for unit tests, otherwise app will use getBCH();
     const BCH = jestBCH ? jestBCH : 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 !== 'XEC') {
             bchValue = fiatToCrypto(value, fiatPrice);
         }
 
         try {
             const link = await sendBch(
                 BCH,
                 wallet,
                 slpBalancesAndUtxos.nonSlpUtxos,
                 filledAddress || cleanAddress,
                 bchValue,
                 currency.defaultFee,
                 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 = `Invalid ${currency.ticker} 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 / 10 ** currency.cashDecimals;
             let value =
                 balances.totalBalance - txFeeBch >= 0
                     ? (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 = `${
                 cashtabSettings
                     ? `${
                           currency.fiatCurrencies[cashtabSettings.fiatCurrency]
                               .symbol
                       } `
                     : '$ '
             } ${(fiatPrice * Number(formData.value)).toFixed(2)} ${
                 cashtabSettings && cashtabSettings.fiatCurrency
                     ? cashtabSettings.fiatCurrency.toUpperCase()
                     : 'USD'
             }`;
         } else {
             fiatPriceString = `${
                 formData.value ? fiatToCrypto(formData.value, fiatPrice) : '0'
             } ${currency.ticker}`;
         }
     }
 
     const priceApiError = fiatPrice === null && selectedCurrency !== 'XEC';
 
     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>
                         {formatBalance(balances.totalBalance)} {currency.ticker}
                     </BalanceHeader>
                     {fiatPrice !== null && (
                         <BalanceHeaderFiat>
                             {cashtabSettings
                                 ? `${
                                       currency.fiatCurrencies[
                                           cashtabSettings.fiatCurrency
                                       ].symbol
                                   } `
                                 : '$ '}
                             {(balances.totalBalance * fiatPrice).toFixed(2)}{' '}
                             {cashtabSettings
                                 ? `${currency.fiatCurrencies[
                                       cashtabSettings.fiatCurrency
                                   ].slug.toUpperCase()} `
                                 : '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
                                 activeFiatCode={
                                     cashtabSettings &&
                                     cashtabSettings.fiatCurrency
                                         ? cashtabSettings.fiatCurrency.toUpperCase()
                                         : 'USD'
                                 }
                                 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>
                             {priceApiError && (
                                 <AlertMsg>
-                                    Error fetching fiat price. Setting send by
-                                    USD disabled
+                                    Error fetching fiat price. Setting send by{' '}
+                                    {currency.fiatCurrencies[
+                                        cashtabSettings.fiatCurrency
+                                    ].slug.toUpperCase()}{' '}
+                                    disabled
                                 </AlertMsg>
                             )}
                             <ConvertAmount>
                                 {fiatPriceString !== '' && '='}{' '}
                                 {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/utils/__tests__/validation.test.js b/web/cashtab/src/utils/__tests__/validation.test.js
index 190359f72..6f4589c63 100644
--- a/web/cashtab/src/utils/__tests__/validation.test.js
+++ b/web/cashtab/src/utils/__tests__/validation.test.js
@@ -1,228 +1,228 @@
 import {
     shouldRejectAmountInput,
     fiatToCrypto,
     isValidTokenName,
     isValidTokenTicker,
     isValidTokenDecimals,
     isValidTokenInitialQty,
     isValidTokenDocumentUrl,
     isValidTokenStats,
     isValidCashtabSettings,
 } from '../validation';
 import { currency } from '@components/Common/Ticker.js';
 import { fromSmallestDenomination } from '@utils/cashMethods';
 import {
     stStatsValid,
     noCovidStatsValid,
     noCovidStatsInvalid,
     cGenStatsValid,
 } from '../__mocks__/mockTokenStats';
 
 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 ${fromSmallestDenomination(
         currency.dustSats,
     ).toString()} minimum`, () => {
         const expectedValidationError = `Send amount must be at least ${fromSmallestDenomination(
             currency.dustSats,
         ).toString()} ${currency.ticker}`;
         expect(
             shouldRejectAmountInput(
                 (
                     fromSmallestDenomination(currency.dustSats).toString() -
                     0.00000001
                 ).toString(),
                 currency.ticker,
                 20.0,
                 3,
             ),
         ).toBe(expectedValidationError);
     });
     it(`Returns error if ${
         currency.ticker
     } send amount is less than ${fromSmallestDenomination(
         currency.dustSats,
     ).toString()} minimum in fiat currency`, () => {
         const expectedValidationError = `Send amount must be at least ${fromSmallestDenomination(
             currency.dustSats,
         ).toString()} ${currency.ticker}`;
         expect(
             shouldRejectAmountInput('0.0000005', 'USD', 0.00005, 1000000),
         ).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 ${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 ${currency.cashDecimals} decimals of precision even if inputs have higher precision`, () => {
         expect(fiatToCrypto('10.97231694823432', 20.3231342349234234, 8)).toBe(
             '0.53989295',
         );
     });
     it(`Returns expected crypto amount with ${currency.cashDecimals} decimals of precision even if inputs have higher precision`, () => {
         expect(fiatToCrypto('10.97231694823432', 20.3231342349234234, 2)).toBe(
             '0.54',
         );
     });
     it(`Returns expected crypto amount with ${currency.cashDecimals} decimals of precision even if inputs have lower precision`, () => {
         expect(fiatToCrypto('10.94', 10, 8)).toBe('1.09400000');
     });
     it(`Accepts a valid ${currency.tokenTicker} token name`, () => {
         expect(isValidTokenName('Valid token name')).toBe(true);
     });
     it(`Accepts a valid ${currency.tokenTicker} token name that is a stringified number`, () => {
         expect(isValidTokenName('123456789')).toBe(true);
     });
     it(`Rejects ${currency.tokenTicker} token name if longer than 68 characters`, () => {
         expect(
             isValidTokenName(
                 'This token name is not valid because it is longer than 68 characters which is really pretty long for a token name when you think about it and all',
             ),
         ).toBe(false);
     });
     it(`Rejects ${currency.tokenTicker} token name if empty string`, () => {
         expect(isValidTokenName('')).toBe(false);
     });
     it(`Accepts a 4-char ${currency.tokenTicker} token ticker`, () => {
         expect(isValidTokenTicker('DOGE')).toBe(true);
     });
     it(`Accepts a 12-char ${currency.tokenTicker} token ticker`, () => {
         expect(isValidTokenTicker('123456789123')).toBe(true);
     });
     it(`Rejects ${currency.tokenTicker} token ticker if empty string`, () => {
         expect(isValidTokenTicker('')).toBe(false);
     });
     it(`Rejects ${currency.tokenTicker} token ticker if > 12 chars`, () => {
         expect(isValidTokenTicker('1234567891234')).toBe(false);
     });
     it(`Accepts ${currency.tokenDecimals} if zero`, () => {
         expect(isValidTokenDecimals('0')).toBe(true);
     });
     it(`Accepts ${currency.tokenDecimals} if between 0 and 9 inclusive`, () => {
         expect(isValidTokenDecimals('9')).toBe(true);
     });
     it(`Rejects ${currency.tokenDecimals} if empty string`, () => {
         expect(isValidTokenDecimals('')).toBe(false);
     });
     it(`Rejects ${currency.tokenDecimals} if non-integer`, () => {
         expect(isValidTokenDecimals('1.7')).toBe(false);
     });
     it(`Accepts ${currency.tokenDecimals} initial genesis quantity at minimum amount for 3 decimal places`, () => {
         expect(isValidTokenInitialQty('0.001', '3')).toBe(true);
     });
     it(`Accepts ${currency.tokenDecimals} initial genesis quantity at minimum amount for 9 decimal places`, () => {
         expect(isValidTokenInitialQty('0.000000001', '9')).toBe(true);
     });
     it(`Accepts ${currency.tokenDecimals} initial genesis quantity at amount below 100 billion`, () => {
         expect(isValidTokenInitialQty('1000', '0')).toBe(true);
     });
     it(`Accepts highest possible ${currency.tokenDecimals} initial genesis quantity at amount below 100 billion`, () => {
         expect(isValidTokenInitialQty('99999999999.999999999', '9')).toBe(true);
     });
     it(`Accepts ${currency.tokenDecimals} initial genesis quantity if decimal places equal tokenDecimals`, () => {
         expect(isValidTokenInitialQty('0.123', '3')).toBe(true);
     });
     it(`Accepts ${currency.tokenDecimals} initial genesis quantity if decimal places are less than tokenDecimals`, () => {
         expect(isValidTokenInitialQty('0.12345', '9')).toBe(true);
     });
     it(`Rejects ${currency.tokenDecimals} initial genesis quantity of zero`, () => {
         expect(isValidTokenInitialQty('0', '9')).toBe(false);
     });
     it(`Rejects ${currency.tokenDecimals} initial genesis quantity if tokenDecimals is not valid`, () => {
         expect(isValidTokenInitialQty('0', '')).toBe(false);
     });
     it(`Rejects ${currency.tokenDecimals} initial genesis quantity if 100 billion or higher`, () => {
         expect(isValidTokenInitialQty('100000000000', '0')).toBe(false);
     });
     it(`Rejects ${currency.tokenDecimals} initial genesis quantity if it has more decimal places than tokenDecimals`, () => {
         expect(isValidTokenInitialQty('1.5', '0')).toBe(false);
     });
     it(`Accepts a valid ${currency.tokenTicker} token document URL`, () => {
         expect(isValidTokenDocumentUrl('cashtabapp.com')).toBe(true);
     });
     it(`Accepts a valid ${currency.tokenTicker} token document URL including special URL characters`, () => {
         expect(isValidTokenDocumentUrl('https://cashtabapp.com/')).toBe(true);
     });
     it(`Accepts a blank string as a valid ${currency.tokenTicker} token document URL`, () => {
         expect(isValidTokenDocumentUrl('')).toBe(true);
     });
     it(`Rejects ${currency.tokenTicker} token name if longer than 68 characters`, () => {
         expect(
             isValidTokenDocumentUrl(
                 'http://www.ThisTokenDocumentUrlIsActuallyMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchTooLong.com/',
             ),
         ).toBe(false);
     });
     it(`Correctly validates token stats for token created before the ${currency.ticker} fork`, () => {
         expect(isValidTokenStats(stStatsValid)).toBe(true);
     });
     it(`Correctly validates token stats for token created after the ${currency.ticker} fork`, () => {
         expect(isValidTokenStats(noCovidStatsValid)).toBe(true);
     });
     it(`Correctly validates token stats for token with no minting baton`, () => {
         expect(isValidTokenStats(cGenStatsValid)).toBe(true);
     });
     it(`Recognizes a token stats object with missing required keys as invalid`, () => {
         expect(isValidTokenStats(noCovidStatsInvalid)).toBe(false);
     });
     it(`Recognizes a valid cashtab settings object`, () => {
         expect(isValidCashtabSettings({ fiatCurrency: 'usd' })).toBe(true);
     });
     it(`Rejects a cashtab settings object for an unsupported currency`, () => {
-        expect(isValidCashtabSettings({ fiatCurrency: 'jpy' })).toBe(false);
+        expect(isValidCashtabSettings({ fiatCurrency: 'xau' })).toBe(false);
     });
     it(`Rejects a corrupted cashtab settings object for an unsupported currency`, () => {
         expect(isValidCashtabSettings({ fiatCurrencyWrongLabel: 'usd' })).toBe(
             false,
         );
     });
 });