diff --git a/web/cashtab/src/hooks/useWallet.js b/web/cashtab/src/hooks/useWallet.js
index 2c8b70b01..4d901a2a2 100644
--- a/web/cashtab/src/hooks/useWallet.js
+++ b/web/cashtab/src/hooks/useWallet.js
@@ -1,1463 +1,1497 @@
 import { useState, useEffect } from 'react';
 import usePrevious from 'hooks/usePrevious';
 import useInterval from './useInterval';
 import useBCH from 'hooks/useBCH';
 import BigNumber from 'bignumber.js';
 import {
     loadStoredWallet,
     isValidStoredWallet,
     isLegacyMigrationRequired,
     getHashArrayFromWallet,
-    checkWalletForTokenInfo,
     isActiveWebsocket,
     getWalletBalanceFromUtxos,
 } from 'utils/cashMethods';
 import {
     isValidCashtabSettings,
     isValidCashtabCache,
     isValidContactList,
     parseInvalidSettingsForMigration,
 } from 'utils/validation';
 import localforage from 'localforage';
 import { currency } from 'components/Common/Ticker';
 import {
     xecReceivedNotification,
     xecReceivedNotificationWebsocket,
     eTokenReceivedNotification,
 } from 'components/Common/Notifications';
 import {
     getUtxosChronik,
     organizeUtxosByType,
     getPreliminaryTokensArray,
     finalizeTokensArray,
     finalizeSlpUtxos,
     getTxHistoryChronik,
     parseChronikTx,
 } from 'utils/chronik';
 import { ChronikClient } from 'chronik-client';
 // For XEC, eCash chain:
 const chronik = new ChronikClient(currency.chronikUrl);
 
 const useWallet = () => {
     const [walletRefreshInterval, setWalletRefreshInterval] = useState(
         currency.websocketDisconnectedRefreshInterval,
     );
     const [wallet, setWallet] = useState(false);
     const [chronikWebsocket, setChronikWebsocket] = useState(null);
     const [contactList, setContactList] = useState([{}]);
     const [cashtabSettings, setCashtabSettings] = useState(false);
     const [cashtabCache, setCashtabCache] = useState(
         currency.defaultCashtabCache,
     );
     const [fiatPrice, setFiatPrice] = useState(null);
     const [apiError, setApiError] = useState(false);
     const [checkFiatInterval, setCheckFiatInterval] = useState(null);
     const [hasUpdated, setHasUpdated] = useState(false);
     const { getBCH, getTxHistory, getTxData, addTokenTxData } = useBCH();
     const [loading, setLoading] = useState(true);
     const [apiIndex, setApiIndex] = useState(0);
     const [BCH, setBCH] = useState(getBCH(apiIndex));
     const { balances, tokens } = isValidStoredWallet(wallet)
         ? wallet.state
         : {
               balances: {},
               tokens: [],
               utxos: null,
           };
     const previousBalances = usePrevious(balances);
     const previousTokens = usePrevious(tokens);
 
     // 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 deriveAccount = async (BCH, { masterHDNode, path }) => {
         const node = BCH.HDNode.derivePath(masterHDNode, path);
         const publicKey = BCH.HDNode.toPublicKey(node).toString('hex');
         const cashAddress = BCH.HDNode.toCashAddress(node);
         const hash160 = BCH.Address.toHash160(cashAddress);
         const slpAddress = BCH.SLP.Address.toSLPAddress(cashAddress);
 
         return {
             publicKey,
             hash160,
             cashAddress,
             slpAddress,
             fundingWif: BCH.HDNode.toWIF(node),
             fundingAddress: BCH.SLP.Address.toSLPAddress(cashAddress),
             legacyAddress: BCH.SLP.Address.toLegacyAddress(cashAddress),
         };
     };
 
     const loadWalletFromStorageOnStartup = async setWallet => {
         // get wallet object from localforage
         const wallet = await getWallet();
         // If wallet object in storage is valid, use it to set state on startup
         if (isValidStoredWallet(wallet)) {
             // Convert all the token balance figures to big numbers
             const liveWalletState = loadStoredWallet(wallet.state);
             wallet.state = liveWalletState;
 
             setWallet(wallet);
             return setLoading(false);
         }
         console.log(`Active wallet is not valid, loading params from API`);
         // Loading will remain true until API calls populate this legacy wallet
         setWallet(wallet);
     };
 
     const update = async ({ wallet }) => {
         //console.log(`tick()`);
         //console.time("update");
 
         // Check if walletRefreshInterval is set to 10, i.e. this was called by websocket tx detection
         // If walletRefreshInterval is 10, set it back to the usual refresh rate
         if (walletRefreshInterval === 10) {
             setWalletRefreshInterval(
                 currency.websocketConnectedRefreshInterval,
             );
         }
         try {
             if (!wallet) {
                 return;
             }
             const cashAddresses = [
                 wallet.Path245.cashAddress,
                 wallet.Path145.cashAddress,
                 wallet.Path1899.cashAddress,
             ];
 
             const publicKeys = [
                 wallet.Path145.publicKey,
                 wallet.Path245.publicKey,
                 wallet.Path1899.publicKey,
             ];
 
             /*
                This strange data structure is necessary because chronik requires the hash160
                of an address to tell you what utxos are at that address
             */
             const hash160AndAddressObjArray = [
                 {
                     address: wallet.Path145.cashAddress,
                     hash160: wallet.Path145.hash160,
                 },
                 {
                     address: wallet.Path245.cashAddress,
                     hash160: wallet.Path245.hash160,
                 },
                 {
                     address: wallet.Path1899.cashAddress,
                     hash160: wallet.Path1899.hash160,
                 },
             ];
 
             // Check that server is live
             try {
                 await BCH.Blockchain.getBlockCount();
             } catch (err) {
                 console.log(
                     `Error in BCH.Blockchain.getBlockCount, the full node is likely down`,
                     err,
                 );
                 throw new Error(`Node unavailable`);
             }
 
             const chronikUtxos = await getUtxosChronik(
                 chronik,
                 hash160AndAddressObjArray,
             );
 
             const { preliminarySlpUtxos, nonSlpUtxos } =
                 organizeUtxosByType(chronikUtxos);
 
             const preliminaryTokensArray =
                 getPreliminaryTokensArray(preliminarySlpUtxos);
 
             const { finalTokenArray, updatedTokenInfoById, newTokensToCache } =
                 await finalizeTokensArray(
                     chronik,
                     preliminaryTokensArray,
                     cashtabCache.tokenInfoById,
                 );
 
             // If you have more token info now, write this to local storage
             if (newTokensToCache) {
                 writeTokenInfoByIdToCache(updatedTokenInfoById);
                 // Update the tokenInfoById key in cashtabCache
                 setCashtabCache({
                     ...cashtabCache,
                     tokenInfoById: updatedTokenInfoById,
                 });
             }
 
             const finalizedSlpUtxos = finalizeSlpUtxos(
                 preliminarySlpUtxos,
                 updatedTokenInfoById,
             );
 
             // Preserve bch-api for tx history for now, as this will take another stacked diff to migrate to chronik
             const txHistory = await getTxHistory(BCH, cashAddresses);
 
             const chronikTxHistory = await getTxHistoryChronik(
                 chronik,
                 BCH,
                 wallet,
                 updatedTokenInfoById,
             );
             console.log(
                 `chronikTxHistory as flattened array, sorted by blockheight and time first seen, with parse info, and partial legacy parse info`,
                 chronikTxHistory,
             );
 
             // public keys are used to determined if a tx is incoming outgoing
             const parsedTxHistory = await getTxData(
                 BCH,
                 txHistory,
                 publicKeys,
                 wallet,
             );
 
             const parsedWithTokens = await addTokenTxData(BCH, parsedTxHistory);
             console.log(`parsedWithTokens`, parsedWithTokens);
 
             const newState = {
                 balances: getWalletBalanceFromUtxos(nonSlpUtxos),
                 tokens: finalTokenArray,
                 slpBalancesAndUtxos: {
                     slpUtxos: finalizedSlpUtxos,
                     nonSlpUtxos,
                     tokens,
                 },
                 parsedTxHistory: parsedWithTokens,
                 utxos: chronikUtxos,
             };
 
             // Set wallet with new state field
             wallet.state = newState;
             setWallet(wallet);
 
             // Write this state to indexedDb using localForage
             writeWalletState(wallet, newState);
             // If everything executed correctly, remove apiError
             setApiError(false);
         } catch (error) {
             console.log(`Error in update({wallet})`);
             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 getContactListFromLocalForage = async () => {
         let contactListArray = [];
         try {
             contactListArray = await localforage.getItem('contactList');
         } catch (err) {
             console.log('Error in getContactListFromLocalForage', err);
             contactListArray = null;
         }
         return contactListArray;
     };
 
     const updateContactListInLocalForage = async contactListArray => {
         let updateSuccess = true;
         try {
             await localforage.setItem('contactList', contactListArray);
         } catch (err) {
             console.log('Error in updateContactListInLocalForage', err);
             updateSuccess = false;
         }
         return updateSuccess;
     };
 
     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
             // or each Path1899, Path145, Path245 does not have a public key, add them
             if (existingWallet) {
                 if (isLegacyMigrationRequired(existingWallet)) {
                     console.log(
                         `Wallet does not have Path1899 or does not have public key`,
                     );
                     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 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",
         });
 
         wallet.Path245 = Path245;
         wallet.Path145 = Path145;
         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 writeTokenInfoByIdToCache = async tokenInfoById => {
         console.log(`writeTokenInfoByIdToCache`);
         const cashtabCache = currency.defaultCashtabCache;
         cashtabCache.tokenInfoById = tokenInfoById;
         try {
             await localforage.setItem('cashtabCache', cashtabCache);
             console.log(`cashtabCache successfully updated`);
         } catch (err) {
             console.log(`Error in writeCashtabCache()`, err);
         }
     };
 
     const writeWalletState = async (wallet, newState) => {
         // Add new state as an object on the active wallet
         wallet.state = newState;
         try {
             await localforage.setItem('wallet', wallet);
         } catch (err) {
             console.log(`Error in writeWalletState()`);
             console.log(err);
         }
     };
 
     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
     */
         console.log(`Activating wallet ${walletToActivate.name}`);
         setHasUpdated(false);
         let currentlyActiveWallet;
         try {
             //TODO this should just be a param used to call the function
             currentlyActiveWallet = await localforage.getItem('wallet');
             console.log(
                 `Currently active wallet is ${currentlyActiveWallet.name}`,
             );
         } 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 cashtab.com/, their active wallet will be migrated to Path1899 by 
         the getWallet function. getWallet function also makes sure that each Path has a public key
 
         Wallets in savedWallets are migrated when they are activated, in this function
 
         Two cases to handle
 
         1 - currentlyActiveWallet is valid but its stored keyvalue pair in savedWallets is not
             > Update savedWallets so this saved wallet is valid
         
         2 - walletToActivate is not valid (because it's a legacy saved wallet)
             > Update walletToActivate before activation
         
         */
 
         // Check savedWallets for currentlyActiveWallet
         let walletInSavedWallets = false;
         for (let i = 0; i < savedWallets.length; i += 1) {
             if (savedWallets[i].name === currentlyActiveWallet.name) {
                 walletInSavedWallets = true;
                 // Make sure the savedWallet entry matches the currentlyActiveWallet entry
                 savedWallets[i] = currentlyActiveWallet;
                 console.log(
                     `Updating savedWallet ${savedWallets[i].name} to match state as currentlyActiveWallet ${currentlyActiveWallet.name}`,
                 );
             }
         }
 
         // resave savedWallets
         try {
             // Set walletName as the active wallet
             console.log(`Saving updated savedWallets`);
             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
         // or each of the Path1899, Path145, Path245 does not have a public key, add them
         // by calling migrateLagacyWallet()
         if (isLegacyMigrationRequired(walletToActivate)) {
             // Case 2, described above
             console.log(
                 `Case 2: Wallet to activate is not in the most up to date Cashtab format`,
             );
             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;
             }
         }
 
         // Convert all the token balance figures to big numbers
         // localforage does not preserve BigNumber type; loadStoredWallet restores BigNumber type
         const liveWalletState = loadStoredWallet(walletToActivate.state);
         walletToActivate.state = liveWalletState;
         console.log(`Returning walletToActivate ${walletToActivate.name}`);
         return walletToActivate;
     };
 
     const renameSavedWallet = async (oldName, newName) => {
         // Load savedWallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(
                 `Error in await localforage.getItem("savedWallets") in renameSavedWallet`,
             );
             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 renameSavedWallet()`,
             );
             return false;
         }
         return true;
     };
 
     const renameActiveWallet = async (wallet, oldName, newName) => {
         // Load savedWallets
         let savedWallets;
         try {
             savedWallets = await localforage.getItem('savedWallets');
         } catch (err) {
             console.log(
                 `Error in await localforage.getItem("savedWallets") in renameSavedWallet`,
             );
             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;
             }
         }
         if (wallet.name === oldName) {
             wallet.name = newName;
             setWallet(wallet);
         }
 
         // 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);
             await localforage.setItem('wallet', wallet);
         } catch (err) {
             console.log(
                 `Error in localforage.setItem("wallet", wallet) in renameActiveWallet()`,
             );
             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;
         }
     };
 
     // Parse chronik ws message for incoming tx notifications
     const processChronikWsMsg = async (msg, wallet, fiatPrice) => {
         // get the message type
         const { type } = msg;
         // For now, only act on "first seen" transactions, as the only logic to happen is first seen notifications
         // Dev note: Other chronik msg types
         // "BlockConnected", arrives as new blocks are found
         // "Confirmed", arrives as subscribed + seen txid is confirmed in a block
         if (type !== 'AddedToMempool') {
             return;
         }
         // If you see a tx from your subscribed addresses added to the mempool, then the wallet utxo set has changed
         // Update it
         setWalletRefreshInterval(10);
 
         // get txid info
         const txid = msg.txid;
-        const txDetails = await chronik.tx(txid);
+
+        let incomingTxDetails;
+        try {
+            incomingTxDetails = await chronik.tx(txid);
+        } catch (err) {
+            // In this case, no notification
+            return console.log(
+                `Error in chronik.tx(${txid} while processing an incoming websocket tx`,
+                err,
+            );
+        }
+
+        // Get tokenInfoById from cashtabCache to parse this tx
+        let tokenInfoById = {};
+        try {
+            tokenInfoById = cashtabCache.tokenInfoById;
+        } catch (err) {
+            console.log(
+                `Error getting tokenInfoById from cache on incoming tx`,
+                err,
+            );
+        }
 
         // parse tx for notification
-        const parsedChronikTx = parseChronikTx(txDetails, wallet);
+        const parsedChronikTx = parseChronikTx(
+            BCH,
+            incomingTxDetails,
+            wallet,
+            tokenInfoById,
+        );
+        /* If this is an incoming eToken tx and parseChronikTx was not able to get genesis info
+           from cache, then get genesis info from API and add to cache */
         if (parsedChronikTx.incoming) {
             if (parsedChronikTx.isEtokenTx) {
-                try {
-                    // Get the tokenID
-                    const incomingTokenId = parsedChronikTx.slpMeta.tokenId;
-
-                    // Check cache for token info
-                    // NB this procedure will change when chronik utxo formatting is implemented
-                    let incomingTokenInfo = checkWalletForTokenInfo(
-                        incomingTokenId,
-                        wallet,
+                let eTokenAmountReceived = parsedChronikTx.etokenAmount;
+                if (parsedChronikTx.genesisInfo.success) {
+                    // Send this info to the notification function
+                    eTokenReceivedNotification(
+                        currency,
+                        parsedChronikTx.genesisInfo.tokenTicker,
+                        eTokenAmountReceived,
+                        parsedChronikTx.genesisInfo.tokenName,
                     );
+                } else {
+                    // Get genesis info from API and add to cache
+                    try {
+                        // Get the tokenID
+                        const incomingTokenId = parsedChronikTx.slpMeta.tokenId;
 
-                    let eTokenAmountReceived;
-                    if (!incomingTokenInfo) {
                         // chronik call to genesis tx to get this info
                         const tokenGenesisInfo = await chronik.tx(
                             incomingTokenId,
                         );
-                        incomingTokenInfo = {
-                            decimals:
-                                tokenGenesisInfo.slpTxData.genesisInfo.decimals,
-                            name: tokenGenesisInfo.slpTxData.genesisInfo
-                                .tokenName,
-                            ticker: tokenGenesisInfo.slpTxData.genesisInfo
-                                .tokenTicker,
-                        };
+                        const { genesisInfo } = tokenGenesisInfo.slpTxData;
+                        // Add this to cashtabCache
+                        let tokenInfoByIdUpdatedForThisToken = tokenInfoById;
+                        tokenInfoByIdUpdatedForThisToken[incomingTokenId] =
+                            genesisInfo;
+                        writeTokenInfoByIdToCache(
+                            tokenInfoByIdUpdatedForThisToken,
+                        );
+                        // Update the tokenInfoById key in cashtabCache
+                        setCashtabCache({
+                            ...cashtabCache,
+                            tokenInfoById: tokenInfoByIdUpdatedForThisToken,
+                        });
+
+                        // Calculate eToken amount with decimals
+                        eTokenAmountReceived = new BigNumber(
+                            parsedChronikTx.etokenAmount,
+                        ).shiftedBy(-1 * genesisInfo.decimals);
+
+                        // Send this info to the notification function
+                        eTokenReceivedNotification(
+                            currency,
+                            genesisInfo.tokenTicker,
+                            eTokenAmountReceived,
+                            genesisInfo.tokenName,
+                        );
+                    } catch (err) {
+                        console.log(
+                            `Error in getting and setting new token info for incoming eToken tx`,
+                            err,
+                        );
                     }
-                    // Calculate eToken amount with decimals
-                    eTokenAmountReceived = new BigNumber(
-                        parsedChronikTx.etokenAmount,
-                    ).shiftedBy(-1 * incomingTokenInfo.decimals);
-                    // Send this info to the notification function
-                    eTokenReceivedNotification(
-                        currency,
-                        incomingTokenInfo.ticker,
-                        eTokenAmountReceived,
-                        incomingTokenInfo.name,
-                    );
-                } catch (err) {
-                    // In this case, no incoming tx notification is received
-                    // This is an acceptable error condition, no need to fallback to another notification option
-                    console.log(
-                        `Error parsing eToken data for incoming tx notification`,
-                        err,
-                    );
                 }
             } else {
                 xecReceivedNotificationWebsocket(
                     parsedChronikTx.xecAmount,
                     cashtabSettings,
                     fiatPrice,
                 );
             }
         }
     };
 
     // Chronik websockets
     const initializeWebsocket = async (wallet, fiatPrice) => {
         console.log(
             `Initializing websocket connection for wallet ${wallet.name}`,
         );
         // Because wallet is set to `false` before it is loaded, do nothing if you find this case
         // Also return and wait for legacy migration if wallet is not migrated
         const hash160Array = getHashArrayFromWallet(wallet);
         if (!wallet || !hash160Array) {
             return setChronikWebsocket(null);
         }
 
         // Initialize if not in state
         let ws = chronikWebsocket;
         if (ws === null) {
             ws = chronik.ws({
                 onMessage: msg => {
                     processChronikWsMsg(msg, wallet, fiatPrice);
                 },
                 onReconnect: e => {
                     // Fired before a reconnect attempt is made:
                     console.log(
                         'Reconnecting websocket, disconnection cause: ',
                         e,
                     );
                 },
                 onConnect: e => {
                     console.log(`Chronik websocket connected`, e);
                     console.log(
                         `Websocket connected, adjusting wallet refresh interval to ${
                             currency.websocketConnectedRefreshInterval / 1000
                         }s`,
                     );
                     setWalletRefreshInterval(
                         currency.websocketConnectedRefreshInterval,
                     );
                 },
             });
 
             // Wait for websocket to be connected:
             await ws.waitForOpen();
         } else {
             /*        
             If the websocket connection is not null, initializeWebsocket was called
             because one of the websocket's dependencies changed
 
             Update the onMessage method to get the latest dependencies (wallet, fiatPrice)
             */
 
             ws.onMessage = msg => {
                 processChronikWsMsg(msg, wallet, fiatPrice);
             };
         }
 
         // Check if current subscriptions match current wallet
         let activeSubscriptionsMatchActiveWallet = true;
 
         const previousWebsocketSubscriptions = ws._subs;
         // If there are no previous subscriptions, then activeSubscriptionsMatchActiveWallet is certainly false
         if (previousWebsocketSubscriptions.length === 0) {
             activeSubscriptionsMatchActiveWallet = false;
         } else {
             const subscribedHash160Array = previousWebsocketSubscriptions.map(
                 function (subscription) {
                     return subscription.scriptPayload;
                 },
             );
             // Confirm that websocket is subscribed to every address in wallet hash160Array
             for (let i = 0; i < hash160Array.length; i += 1) {
                 if (!subscribedHash160Array.includes(hash160Array[i])) {
                     activeSubscriptionsMatchActiveWallet = false;
                 }
             }
         }
 
         // If you are already subscribed to the right addresses, exit here
         // You get to this situation if fiatPrice changed but wallet.mnemonic did not
         if (activeSubscriptionsMatchActiveWallet) {
             // Put connected websocket in state
             return setChronikWebsocket(ws);
         }
 
         // Unsubscribe to any active subscriptions
         console.log(
             `previousWebsocketSubscriptions`,
             previousWebsocketSubscriptions,
         );
         if (previousWebsocketSubscriptions.length > 0) {
             for (let i = 0; i < previousWebsocketSubscriptions.length; i += 1) {
                 const unsubHash160 =
                     previousWebsocketSubscriptions[i].scriptPayload;
                 ws.unsubscribe('p2pkh', unsubHash160);
                 console.log(`ws.unsubscribe('p2pkh', ${unsubHash160})`);
             }
         }
 
         // Subscribe to addresses of current wallet
         for (let i = 0; i < hash160Array.length; i += 1) {
             ws.subscribe('p2pkh', hash160Array[i]);
             console.log(`ws.subscribe('p2pkh', ${hash160Array[i]})`);
         }
 
         // Put connected websocket in state
         return setChronikWebsocket(ws);
     };
 
     const handleUpdateWallet = async setWallet => {
         await loadWalletFromStorageOnStartup(setWallet);
     };
 
     const loadCashtabSettings = async () => {
         // get settings object from localforage
         let localSettings;
         try {
             localSettings = await localforage.getItem('settings');
             // If there is no keyvalue pair in localforage with key 'settings'
             if (localSettings === null) {
                 // Create one with the default settings from Ticker.js
                 localforage.setItem('settings', currency.defaultSettings);
                 // Set state to default settings
                 setCashtabSettings(currency.defaultSettings);
                 return currency.defaultSettings;
             }
         } catch (err) {
             console.log(`Error getting cashtabSettings`, err);
             // TODO If they do not exist, write them
             // TODO add function to change them
             setCashtabSettings(currency.defaultSettings);
             return currency.defaultSettings;
         }
         // If you found an object in localforage at the settings key, make sure it's valid
         if (isValidCashtabSettings(localSettings)) {
             setCashtabSettings(localSettings);
             return localSettings;
         }
         // If a settings object is present but invalid, parse to find and add missing keys
         let modifiedLocalSettings =
             parseInvalidSettingsForMigration(localSettings);
         if (isValidCashtabSettings(modifiedLocalSettings)) {
             // modifiedLocalSettings placed in local storage
             localforage.setItem('settings', modifiedLocalSettings);
             setCashtabSettings(modifiedLocalSettings);
             // update missing key in local storage without overwriting existing valid settings
             return modifiedLocalSettings;
         } else {
             // if not valid, also set cashtabSettings to default
             setCashtabSettings(currency.defaultSettings);
             // Since this is returning default settings based on an error from reading storage, do not overwrite whatever is in storage
             return currency.defaultSettings;
         }
     };
 
     const loadContactList = async () => {
         // get contactList object from localforage
         let localContactList;
         try {
             localContactList = await localforage.getItem('contactList');
             // If there is no keyvalue pair in localforage with key 'contactList'
             if (localContactList === null) {
                 // Use an array containing a single empty object
                 localforage.setItem('contactList', [{}]);
                 setContactList([{}]);
                 return [{}];
             }
         } catch (err) {
             console.log(`Error getting contactList`, err);
             setContactList([{}]);
             return [{}];
         }
         // If you found an object in localforage at the contactList key, make sure it's valid
         if (isValidContactList(localContactList)) {
             setContactList(localContactList);
             return localContactList;
         }
         // if not valid, also set to default
         setContactList([{}]);
         return [{}];
     };
 
     const loadCashtabCache = async () => {
         // get cache object from localforage
         let localCashtabCache;
         try {
             localCashtabCache = await localforage.getItem('cashtabCache');
             // If there is no keyvalue pair in localforage with key 'cashtabCache'
             if (localCashtabCache === null) {
                 // Use the default
                 localforage.setItem(
                     'cashtabCache',
                     currency.defaultCashtabCache,
                 );
                 setCashtabCache(currency.defaultCashtabCache);
                 return currency.defaultCashtabCache;
             }
         } catch (err) {
             console.log(`Error getting cashtabCache`, err);
             setCashtabCache(currency.defaultCashtabCache);
             return currency.defaultCashtabCache;
         }
         // If you found an object in localforage at the cashtabCache key, make sure it's valid
         if (isValidCashtabCache(localCashtabCache)) {
             setCashtabCache(localCashtabCache);
             return localCashtabCache;
         }
         // if not valid, also set to default
         setCashtabCache(currency.defaultCashtabCache);
         return currency.defaultCashtabCache;
     };
 
     // With different currency selections possible, need unique intervals for price checks
     // Must be able to end them and set new ones with new currencies
     const initializeFiatPriceApi = async selectedFiatCurrency => {
         // Update fiat price and confirm it is set to make sure ap keeps loading state until this is updated
         await fetchBchPrice(selectedFiatCurrency);
         // Set interval for updating the price with given currency
 
         const thisFiatInterval = setInterval(function () {
             fetchBchPrice(selectedFiatCurrency);
         }, 60000);
 
         // set interval in state
         setCheckFiatInterval(thisFiatInterval);
     };
 
     const clearFiatPriceApi = fiatPriceApi => {
         // Clear fiat price check interval of previously selected currency
         clearInterval(fiatPriceApi);
     };
 
     const changeCashtabSettings = async (key, newValue) => {
         // Set loading to true as you do not want to display the fiat price of the last currency
         // loading = true will lock the UI until the fiat price has updated
         setLoading(true);
         // Get settings from localforage
         let currentSettings;
         let newSettings;
         try {
             currentSettings = await localforage.getItem('settings');
         } catch (err) {
             console.log(`Error in changeCashtabSettings`, err);
             // Set fiat price to null, which disables fiat sends throughout the app
             setFiatPrice(null);
             // Unlock the UI
             setLoading(false);
             return;
         }
 
         // Make sure function was called with valid params
         if (currency.settingsValidation[key].includes(newValue)) {
             // Update settings
             newSettings = currentSettings;
             newSettings[key] = newValue;
         } else {
             // Set fiat price to null, which disables fiat sends throughout the app
             setFiatPrice(null);
             // Unlock the UI
             setLoading(false);
             return;
         }
         // Set new settings in state so they are available in context throughout the app
         setCashtabSettings(newSettings);
         // If this settings change adjusted the fiat currency, update fiat price
         if (key === 'fiatCurrency') {
             clearFiatPriceApi(checkFiatInterval);
             initializeFiatPriceApi(newValue);
         }
         // Write new settings in localforage
         try {
             await localforage.setItem('settings', newSettings);
         } catch (err) {
             console.log(
                 `Error writing newSettings object to localforage in changeCashtabSettings`,
                 err,
             );
             console.log(`newSettings`, newSettings);
             // do nothing. If this happens, the user will see default currency next time they load the app.
         }
         setLoading(false);
     };
 
     // Parse for incoming XEC transactions
     // hasUpdated is set to true in the useInterval function, and re-sets to false during activateWallet
     // Do not show this notification if websocket connection is live; in this case the websocket will handle it
     if (
         !isActiveWebsocket(chronikWebsocket) &&
         previousBalances &&
         balances &&
         'totalBalance' in previousBalances &&
         'totalBalance' in balances &&
         new BigNumber(balances.totalBalance)
             .minus(previousBalances.totalBalance)
             .gt(0) &&
         hasUpdated
     ) {
         xecReceivedNotification(
             balances,
             previousBalances,
             cashtabSettings,
             fiatPrice,
         );
     }
 
     // Parse for incoming eToken transactions
     // Do not show this notification if websocket connection is live; in this case the websocket will handle it
     if (
         !isActiveWebsocket(chronikWebsocket) &&
         tokens &&
         tokens[0] &&
         tokens[0].balance &&
         previousTokens &&
         previousTokens[0] &&
         previousTokens[0].balance &&
         hasUpdated === true
     ) {
         // 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) {
                 eTokenReceivedNotification(
                     currency,
                     receivedSlpTicker,
                     receivedSlpQty,
                     receivedSlpName,
                 );
             }
             //
         } 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;
 
                     eTokenReceivedNotification(
                         currency,
                         receivedSlpTicker,
                         receivedSlpQty,
                         receivedSlpName,
                     );
                 }
             }
         }
     }
 
     // Update wallet according to defined interval
     useInterval(async () => {
         const wallet = await getWallet();
         update({
             wallet,
         }).finally(() => {
             setLoading(false);
             if (!hasUpdated) {
                 setHasUpdated(true);
             }
         });
     }, walletRefreshInterval);
 
     const fetchBchPrice = async (
         fiatCode = cashtabSettings ? cashtabSettings.fiatCurrency : 'usd',
     ) => {
         // Split this variable out in case coingecko changes
         const cryptoId = currency.coingeckoId;
         // 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);
             let bchPriceInFiat = bchPriceJson[cryptoId][fiatCode];
 
             const validEcashPrice = typeof bchPriceInFiat === 'number';
 
             if (validEcashPrice) {
                 setFiatPrice(bchPriceInFiat);
             } else {
                 // If API price looks fishy, do not allow app to send using fiat settings
                 setFiatPrice(null);
             }
         } catch (err) {
             console.log(`Error parsing price API response to JSON`);
             console.log(err);
         }
     };
 
     useEffect(async () => {
         handleUpdateWallet(setWallet);
         await loadContactList();
         await loadCashtabCache();
         const initialSettings = await loadCashtabSettings();
         initializeFiatPriceApi(initialSettings.fiatCurrency);
     }, []);
 
     /*
     Run initializeWebsocket(wallet, fiatPrice) each time the wallet or fiatPrice changes
     
     Use wallet.mnemonic as the useEffect parameter here because we 
     want to run initializeWebsocket(wallet, fiatPrice) when a new unique wallet
     is selected, not when the active wallet changes state
     */
     useEffect(async () => {
         await initializeWebsocket(wallet, fiatPrice);
     }, [wallet.mnemonic, fiatPrice]);
 
     return {
         BCH,
         chronik,
         wallet,
         fiatPrice,
         loading,
         apiError,
         contactList,
         cashtabSettings,
         changeCashtabSettings,
         getActiveWalletFromLocalForage,
         getWallet,
         validateMnemonic,
         getWalletDetails,
         getSavedWallets,
         migrateLegacyWallet,
         getContactListFromLocalForage,
         updateContactListInLocalForage,
         createWallet: async importMnemonic => {
             setLoading(true);
             const newWallet = await createWallet(importMnemonic);
             setWallet(newWallet);
             update({
                 wallet: newWallet,
             }).finally(() => setLoading(false));
         },
         activateWallet: async walletToActivate => {
             setLoading(true);
             // Make sure that the wallet update interval is not called on the former wallet before this function completes
             console.log(
                 `Suspending wallet update interval while new wallet is activated`,
             );
             setWalletRefreshInterval(
                 currency.websocketDisconnectedRefreshInterval,
             );
             const newWallet = await activateWallet(walletToActivate);
             console.log(`activateWallet gives newWallet ${newWallet.name}`);
             // Changing the wallet here will cause `initializeWebsocket` to fire which will update the websocket interval on a successful connection
             setWallet(newWallet);
             // Immediately call update on this wallet to populate it in the latest format
             // Use the instant interval of 10ms that the update function will cancel
             setWalletRefreshInterval(10);
             setLoading(false);
         },
         addNewSavedWallet,
         renameSavedWallet,
         renameActiveWallet,
         deleteWallet,
     };
 };
 
 export default useWallet;
diff --git a/web/cashtab/src/utils/__tests__/cashMethods.test.js b/web/cashtab/src/utils/__tests__/cashMethods.test.js
index 1de11b9cf..834e29361 100644
--- a/web/cashtab/src/utils/__tests__/cashMethods.test.js
+++ b/web/cashtab/src/utils/__tests__/cashMethods.test.js
@@ -1,1403 +1,1381 @@
 import BigNumber from 'bignumber.js';
 import {
     fromSatoshisToXec,
     flattenContactList,
     loadStoredWallet,
     isValidStoredWallet,
     fromLegacyDecimals,
     convertToEcashPrefix,
     isLegacyMigrationRequired,
     toLegacyCash,
     toLegacyToken,
     toLegacyCashArray,
     convertEtokenToEcashAddr,
     parseOpReturn,
     convertEcashtoEtokenAddr,
     getHashArrayFromWallet,
-    checkWalletForTokenInfo,
     isActiveWebsocket,
     parseXecSendValue,
     getChangeAddressFromInputUtxos,
     generateOpReturnScript,
     generateTxInput,
     generateTxOutput,
     signAndBuildTx,
     fromXecToSatoshis,
     getWalletBalanceFromUtxos,
     signUtxosByAddress,
     getUtxoWif,
 } from 'utils/cashMethods';
 import { currency } from 'components/Common/Ticker';
 import {
     validAddressArrayInput,
     validAddressArrayInputMixedPrefixes,
     validAddressArrayOutput,
     validLargeAddressArrayInput,
     validLargeAddressArrayOutput,
     invalidAddressArrayInput,
 } from '../__mocks__/mockAddressArray';
 
 import {
     cachedUtxos,
     utxosLoadedFromCache,
 } from '../__mocks__/mockCachedUtxos';
 import {
     validStoredWallet,
     invalidStoredWallet,
     invalidpreChronikStoredWallet,
 } from '../__mocks__/mockStoredWallets';
 
 import {
     missingPath1899Wallet,
     missingPublicKeyInPath1899Wallet,
     missingPublicKeyInPath145Wallet,
     missingPublicKeyInPath245Wallet,
     notLegacyWallet,
     missingHash160,
 } from '../__mocks__/mockLegacyWalletsUtils';
 
 import {
     shortCashtabMessageInputHex,
     longCashtabMessageInputHex,
     shortExternalMessageInputHex,
     longExternalMessageInputHex,
     shortSegmentedExternalMessageInputHex,
     longSegmentedExternalMessageInputHex,
     mixedSegmentedExternalMessageInputHex,
     mockParsedShortCashtabMessageArray,
     mockParsedLongCashtabMessageArray,
     mockParsedShortExternalMessageArray,
     mockParsedLongExternalMessageArray,
     mockParsedShortSegmentedExternalMessageArray,
     mockParsedLongSegmentedExternalMessageArray,
     mockParsedMixedSegmentedExternalMessageArray,
     eTokenInputHex,
     mockParsedETokenOutputArray,
     mockAirdropHexOutput,
     mockParsedAirdropMessageArray,
 } from '../__mocks__/mockOpReturnParsedArray';
 
 import mockLegacyWallets from 'hooks/__mocks__/mockLegacyWallets';
 import BCHJS from '@psf/bch-js';
 import sendBCHMock from '../../hooks/__mocks__/sendBCH';
 import {
     activeWebsocketAlpha,
     disconnectedWebsocketAlpha,
     unsubscribedWebsocket,
 } from '../__mocks__/chronikWs';
 import mockNonSlpUtxos from '../../hooks/__mocks__/mockNonSlpUtxos';
 import {
     mockOneToOneSendXecTxBuilderObj,
     mockOneToManySendXecTxBuilderObj,
 } from '../__mocks__/mockTxBuilderObj';
 import {
     mockSingleInputUtxo,
     mockMultipleInputUtxos,
     mockSingleOutput,
     mockMultipleOutputs,
 } from '../__mocks__/mockTxBuilderData';
 
 it(`signUtxosByAddress() successfully returns a txBuilder object for a one to one XEC tx`, () => {
     const BCH = new BCHJS();
     const isOneToMany = false;
     const { destinationAddress, wallet, utxos } = sendBCHMock;
     let txBuilder = new BCH.TransactionBuilder();
     const satoshisToSendInput = new BigNumber(2184);
     const feeInSatsPerByte = currency.defaultFee;
 
     // mock tx input
     const inputObj = generateTxInput(
         BCH,
         isOneToMany,
         utxos,
         txBuilder,
         null,
         satoshisToSendInput,
         feeInSatsPerByte,
     );
 
     // mock tx output
     const totalInputUtxoValue =
         mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
     const singleSendValue = new BigNumber(
         fromSatoshisToXec(
             mockOneToOneSendXecTxBuilderObj.transaction.tx.outs[0].value,
         ),
     );
     const satoshisToSendOutput = fromXecToSatoshis(
         new BigNumber(singleSendValue),
     );
     const txFee = new BigNumber(totalInputUtxoValue).minus(
         new BigNumber(satoshisToSendOutput),
     );
     const changeAddress = wallet.Path1899.cashAddress;
     const outputObj = generateTxOutput(
         BCH,
         isOneToMany,
         singleSendValue,
         satoshisToSendOutput,
         totalInputUtxoValue,
         destinationAddress,
         null,
         changeAddress,
         txFee,
         inputObj.txBuilder,
     );
 
     const txBuilderResponse = signUtxosByAddress(
         BCH,
         mockSingleInputUtxo,
         wallet,
         outputObj,
     );
     expect(txBuilderResponse.toString()).toStrictEqual(
         mockOneToOneSendXecTxBuilderObj.toString(),
     );
 });
 
 it(`signUtxosByAddress() successfully returns a txBuilder object for a one to many XEC tx`, () => {
     const BCH = new BCHJS();
     const isOneToMany = true;
     const { wallet, utxos } = sendBCHMock;
     let txBuilder = new BCH.TransactionBuilder();
     let destinationAddressAndValueArray = [
         'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
         'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
         'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
     ];
     const satoshisToSendInput = new BigNumber(900000);
     const feeInSatsPerByte = currency.defaultFee;
 
     // mock tx input
     const inputObj = generateTxInput(
         BCH,
         isOneToMany,
         utxos,
         txBuilder,
         destinationAddressAndValueArray,
         satoshisToSendInput,
         feeInSatsPerByte,
     );
 
     // mock tx output
     const totalInputUtxoValue =
         mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
     const singleSendValue = null;
     const satoshisToSendOutput = new BigNumber(
         mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
     );
     const txFee = new BigNumber(totalInputUtxoValue)
         .minus(satoshisToSendOutput)
         .minus(
             new BigNumber(
                 mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
             ),
         ); // change value
     destinationAddressAndValueArray = toLegacyCashArray(validAddressArrayInput);
     const changeAddress = wallet.Path1899.cashAddress;
     const outputObj = generateTxOutput(
         BCH,
         isOneToMany,
         singleSendValue,
         satoshisToSendOutput,
         totalInputUtxoValue,
         null,
         destinationAddressAndValueArray,
         changeAddress,
         txFee,
         inputObj.txBuilder,
     );
 
     const txBuilderResponse = signUtxosByAddress(
         BCH,
         mockSingleInputUtxo,
         wallet,
         outputObj,
     );
     expect(txBuilderResponse.toString()).toStrictEqual(
         mockOneToManySendXecTxBuilderObj.toString(),
     );
 });
 
 it(`getChangeAddressFromInputUtxos() returns a correct change address from a valid inputUtxo`, () => {
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const inputUtxo = [
         {
             height: 669639,
             tx_hash:
                 '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             tx_pos: 0,
             value: 1000,
             txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             vout: 0,
             isValid: false,
             address: 'bitcoincash:qphpmfj0qn7znklqhrfn5dq7qh36l3vxavu346vqcl',
             wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
         },
     ];
 
     const changeAddress = getChangeAddressFromInputUtxos(
         BCH,
         inputUtxo,
         wallet,
     );
     expect(changeAddress).toStrictEqual(inputUtxo[0].address);
 });
 
 it(`getChangeAddressFromInputUtxos() throws error upon a malformed input utxo`, () => {
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const invalidInputUtxo = [
         {
             height: 669639,
             tx_hash:
                 '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             tx_pos: 0,
             value: 1000,
             txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             vout: 0,
             isValid: false,
             wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
         },
     ];
     let thrownError;
     try {
         getChangeAddressFromInputUtxos(BCH, invalidInputUtxo, wallet);
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid input utxo');
 });
 
 it(`getChangeAddressFromInputUtxos() throws error upon a valid input utxo with invalid address param`, () => {
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const invalidInputUtxo = [
         {
             height: 669639,
             tx_hash:
                 '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             tx_pos: 0,
             value: 1000,
             address: 'bitcoincash:1qphpmfj0qn7znklqhrfn5dq7qh36l3vxavu346vqcl', // invalid cash address
             txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
             vout: 0,
             isValid: false,
             wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
         },
     ];
     let thrownError;
     try {
         getChangeAddressFromInputUtxos(BCH, invalidInputUtxo, wallet);
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid input utxo');
 });
 
 it(`getChangeAddressFromInputUtxos() throws an error upon a null inputUtxos param`, () => {
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const inputUtxo = null;
 
     let thrownError;
     try {
         getChangeAddressFromInputUtxos(BCH, inputUtxo, wallet);
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual(
         'Invalid getChangeAddressFromWallet input parameter',
     );
 });
 
 it(`parseXecSendValue() correctly parses the value for a valid one to one send XEC transaction`, () => {
     expect(parseXecSendValue(false, '550', null)).toStrictEqual(
         new BigNumber(550),
     );
 });
 
 it(`parseXecSendValue() correctly parses the value for a valid one to many send XEC transaction`, () => {
     const destinationAddressAndValueArray = [
         'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,6',
         'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,6',
         'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,6',
     ];
     expect(
         parseXecSendValue(true, null, destinationAddressAndValueArray),
     ).toStrictEqual(new BigNumber(18));
 });
 
 it(`parseXecSendValue() correctly throws error when singleSendValue is invalid for a one to one send XEC transaction`, () => {
     let errorThrown;
     try {
         parseXecSendValue(false, null, 550);
     } catch (err) {
         errorThrown = err;
     }
     expect(errorThrown.message).toStrictEqual('Invalid singleSendValue');
 });
 
 it(`parseXecSendValue() correctly throws error when destinationAddressAndValueArray is invalid for a one to many send XEC transaction`, () => {
     let errorThrown;
     try {
         parseXecSendValue(true, null, null);
     } catch (err) {
         errorThrown = err;
     }
     expect(errorThrown.message).toStrictEqual(
         'Invalid destinationAddressAndValueArray',
     );
 });
 
 it(`parseXecSendValue() correctly throws error when the total value for a one to one send XEC transaction is below dust`, () => {
     let errorThrown;
     try {
         parseXecSendValue(false, '4.5', null);
     } catch (err) {
         errorThrown = err;
     }
     expect(errorThrown.message).toStrictEqual('dust');
 });
 
 it(`parseXecSendValue() correctly throws error when the total value for a one to many send XEC transaction is below dust`, () => {
     const destinationAddressAndValueArray = [
         'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,2',
         'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,2',
         'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,1',
     ];
     let errorThrown;
     try {
         parseXecSendValue(true, null, destinationAddressAndValueArray);
     } catch (err) {
         errorThrown = err;
     }
     expect(errorThrown.message).toStrictEqual('dust');
 });
 
 it('generateOpReturnScript() correctly generates an encrypted message script', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = 'testing generateOpReturnScript()';
     const encryptionFlag = true;
     const airdropFlag = false;
     const airdropTokenId = null;
     const mockEncryptedEj =
         '04688f9907fe3c7c0b78a73c4ab4f75e15e7e2b79641add519617086126fe6f6b1405a14eed48e90c9c8c0fc77f0f36984a78173e76ce51f0a44af94b59e9da703c9ff82758cfdb9cc46437d662423400fb731d3bfc1df0599279356ca261213fbb40d398c041e1bac966afed1b404581ab1bcfcde1fa039d53b7c7b70e8edf26d64bea9fbeed24cc80909796e6af5863707fa021f2a2ebaa2fe894904702be19d';
 
     const encodedScript = generateOpReturnScript(
         BCH,
         optionalOpReturnMsg,
         encryptionFlag,
         airdropFlag,
         airdropTokenId,
         mockEncryptedEj,
     );
     expect(encodedScript.toString('hex')).toBe(
         '6a04657461624d420130343638386639393037666533633763306237386137336334616234663735653135653765326237393634316164643531393631373038363132366665366636623134303561313465656434386539306339633863306663373766306633363938346137383137336537366365353166306134346166393462353965396461373033633966663832373538636664623963633436343337643636323432333430306662373331643362666331646630353939323739333536636132363132313366626234306433393863303431653162616339363661666564316234303435383161623162636663646531666130333964353362376337623730653865646632366436346265613966626565643234636338303930393739366536616635383633373037666130323166326132656261613266653839343930343730326265313964',
     );
 });
 
 it('generateOpReturnScript() correctly generates an un-encrypted non-airdrop message script', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = 'testing generateOpReturnScript()';
     const encryptionFlag = false;
     const airdropFlag = false;
 
     const encodedScript = generateOpReturnScript(
         BCH,
         optionalOpReturnMsg,
         encryptionFlag,
         airdropFlag,
     );
     expect(encodedScript.toString('hex')).toBe(
         '6a04007461622074657374696e672067656e65726174654f7052657475726e5363726970742829',
     );
 });
 
 it('generateOpReturnScript() correctly generates an un-encrypted airdrop message script', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = 'testing generateOpReturnScript()';
     const encryptionFlag = false;
     const airdropFlag = true;
     const airdropTokenId =
         '1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
 
     const encodedScript = generateOpReturnScript(
         BCH,
         optionalOpReturnMsg,
         encryptionFlag,
         airdropFlag,
         airdropTokenId,
     );
     expect(encodedScript.toString('hex')).toBe(
         '6a0464726f70201c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e04007461622074657374696e672067656e65726174654f7052657475726e5363726970742829',
     );
 });
 
 it('generateOpReturnScript() correctly generates an un-encrypted airdrop with no message script', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = null;
     const encryptionFlag = false;
     const airdropFlag = true;
     const airdropTokenId =
         '1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
 
     const encodedScript = generateOpReturnScript(
         BCH,
         optionalOpReturnMsg,
         encryptionFlag,
         airdropFlag,
         airdropTokenId,
     );
     expect(encodedScript.toString('hex')).toBe(
         '6a0464726f70201c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e0400746162',
     );
 });
 
 it('generateOpReturnScript() correctly throws an error on an invalid encryption input', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = null;
     const encryptionFlag = true;
     const airdropFlag = false;
     const airdropTokenId = null;
     const mockEncryptedEj = null; // invalid given encryptionFlag is true
     let thrownError;
 
     try {
         generateOpReturnScript(
             BCH,
             optionalOpReturnMsg,
             encryptionFlag,
             airdropFlag,
             airdropTokenId,
             mockEncryptedEj,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid OP RETURN script input');
 });
 
 it('generateOpReturnScript() correctly throws an error on an invalid airdrop input', () => {
     const BCH = new BCHJS();
     const optionalOpReturnMsg = null;
     const encryptionFlag = false;
     const airdropFlag = true;
     const airdropTokenId = null; // invalid given airdropFlag is true
 
     let thrownError;
 
     try {
         generateOpReturnScript(
             BCH,
             optionalOpReturnMsg,
             encryptionFlag,
             airdropFlag,
             airdropTokenId,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid OP RETURN script input');
 });
 
 it(`generateTxInput() returns an input object for a valid one to one XEC tx`, async () => {
     const BCH = new BCHJS();
     const isOneToMany = false;
     const utxos = mockNonSlpUtxos;
     let txBuilder = new BCH.TransactionBuilder();
     const destinationAddressAndValueArray = null;
     const satoshisToSend = new BigNumber(2184);
     const feeInSatsPerByte = currency.defaultFee;
 
     const inputObj = generateTxInput(
         BCH,
         isOneToMany,
         utxos,
         txBuilder,
         destinationAddressAndValueArray,
         satoshisToSend,
         feeInSatsPerByte,
     );
     expect(inputObj.txBuilder).not.toStrictEqual(null);
     expect(inputObj.totalInputUtxoValue).toStrictEqual(new BigNumber(701000));
     expect(inputObj.txFee).toStrictEqual(752);
     expect(inputObj.inputUtxos.length).not.toStrictEqual(0);
 });
 
 it(`generateTxInput() returns an input object for a valid one to many XEC tx`, async () => {
     const BCH = new BCHJS();
     const isOneToMany = true;
     const utxos = mockNonSlpUtxos;
     let txBuilder = new BCH.TransactionBuilder();
     const destinationAddressAndValueArray = [
         'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
         'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
         'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
     ];
     const satoshisToSend = new BigNumber(900000);
     const feeInSatsPerByte = currency.defaultFee;
 
     const inputObj = generateTxInput(
         BCH,
         isOneToMany,
         utxos,
         txBuilder,
         destinationAddressAndValueArray,
         satoshisToSend,
         feeInSatsPerByte,
     );
     expect(inputObj.txBuilder).not.toStrictEqual(null);
     expect(inputObj.totalInputUtxoValue).toStrictEqual(new BigNumber(1401000));
     expect(inputObj.txFee).toStrictEqual(1186);
     expect(inputObj.inputUtxos.length).not.toStrictEqual(0);
 });
 
 it(`generateTxInput() throws error for a one to many XEC tx with invalid destinationAddressAndValueArray input`, async () => {
     const BCH = new BCHJS();
     const isOneToMany = true;
     const utxos = mockNonSlpUtxos;
     let txBuilder = new BCH.TransactionBuilder();
     const destinationAddressAndValueArray = null; // invalid since isOneToMany is true
     const satoshisToSend = new BigNumber(900000);
     const feeInSatsPerByte = currency.defaultFee;
 
     let thrownError;
     try {
         generateTxInput(
             BCH,
             isOneToMany,
             utxos,
             txBuilder,
             destinationAddressAndValueArray,
             satoshisToSend,
             feeInSatsPerByte,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
 });
 
 it(`generateTxInput() throws error for a one to many XEC tx with invalid utxos input`, async () => {
     const BCH = new BCHJS();
     const isOneToMany = true;
     const utxos = null;
     let txBuilder = new BCH.TransactionBuilder();
     const destinationAddressAndValueArray = [
         'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
         'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
         'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
     ];
     const satoshisToSend = new BigNumber(900000);
     const feeInSatsPerByte = currency.defaultFee;
 
     let thrownError;
     try {
         generateTxInput(
             BCH,
             isOneToMany,
             utxos,
             txBuilder,
             destinationAddressAndValueArray,
             satoshisToSend,
             feeInSatsPerByte,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
 });
 
 it(`generateTxOutput() returns a txBuilder instance for a valid one to one XEC tx`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     const { destinationAddress, wallet } = sendBCHMock;
     const isOneToMany = false;
     const singleSendValue = fromSatoshisToXec(
         mockOneToOneSendXecTxBuilderObj.transaction.tx.outs[0].value,
     );
     const totalInputUtxoValue =
         mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
     const satoshisToSend = fromXecToSatoshis(new BigNumber(singleSendValue));
     // for unit test purposes, calculate fee by subtracting satoshisToSend from totalInputUtxoValue
     // no change output to be subtracted in this tx
     const txFee = new BigNumber(totalInputUtxoValue).minus(
         new BigNumber(satoshisToSend),
     );
 
     const destinationAddressAndValueArray = null;
     let txBuilder = new BCH.TransactionBuilder();
     const changeAddress = wallet.Path1899.cashAddress;
 
     const outputObj = generateTxOutput(
         BCH,
         isOneToMany,
         singleSendValue,
         satoshisToSend,
         totalInputUtxoValue,
         destinationAddress,
         destinationAddressAndValueArray,
         changeAddress,
         txFee,
         txBuilder,
     );
     expect(outputObj.toString()).toStrictEqual(
         mockOneToOneSendXecTxBuilderObj.toString(),
     );
 });
 
 it(`generateTxOutput() returns a txBuilder instance for a valid one to many XEC tx`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     const { destinationAddress, wallet } = sendBCHMock;
     const isOneToMany = true;
     const singleSendValue = null;
     const totalInputUtxoValue =
         mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
     const satoshisToSend = new BigNumber(
         mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
     );
     // for unit test purposes, calculate fee by subtracting satoshisToSend and change amount from totalInputUtxoValue
     const txFee = new BigNumber(totalInputUtxoValue)
         .minus(satoshisToSend)
         .minus(
             new BigNumber(
                 mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
             ),
         ); // change value
 
     const destinationAddressAndValueArray = toLegacyCashArray(
         validAddressArrayInput,
     );
     let txBuilder = new BCH.TransactionBuilder();
     const changeAddress = wallet.Path1899.cashAddress;
 
     const outputObj = generateTxOutput(
         BCH,
         isOneToMany,
         singleSendValue,
         satoshisToSend,
         totalInputUtxoValue,
         destinationAddress,
         destinationAddressAndValueArray,
         changeAddress,
         txFee,
         txBuilder,
     );
     expect(outputObj.toString()).toStrictEqual(
         mockOneToManySendXecTxBuilderObj.toString(),
     );
 });
 
 it(`generateTxOutput() throws an error on invalid input params for a one to one XEC tx`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const isOneToMany = false;
     const singleSendValue = null; // invalid due to singleSendValue being mandatory when isOneToMany is false
     const totalInputUtxoValue =
         mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
     const satoshisToSend = fromXecToSatoshis(new BigNumber(singleSendValue));
     // for unit test purposes, calculate fee by subtracting satoshisToSend from totalInputUtxoValue
     // no change output to be subtracted in this tx
     const txFee = new BigNumber(totalInputUtxoValue).minus(satoshisToSend);
 
     const destinationAddressAndValueArray = null;
     let txBuilder = new BCH.TransactionBuilder();
     const changeAddress = wallet.Path1899.cashAddress;
 
     let thrownError;
     try {
         generateTxOutput(
             BCH,
             isOneToMany,
             singleSendValue,
             satoshisToSend,
             totalInputUtxoValue,
             null,
             destinationAddressAndValueArray,
             changeAddress,
             txFee,
             txBuilder,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
 });
 
 it(`generateTxOutput() throws an error on invalid input params for a one to many XEC tx`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     const { wallet } = sendBCHMock;
     const isOneToMany = true;
     const singleSendValue = null;
     const totalInputUtxoValue =
         mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
         mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
     const satoshisToSend = new BigNumber(
         mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
             mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
     );
     // for unit test purposes, calculate fee by subtracting satoshisToSend and change amount from totalInputUtxoValue
     const txFee = new BigNumber(totalInputUtxoValue)
         .minus(satoshisToSend)
         .minus(
             new BigNumber(
                 mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
             ),
         ); // change value
     const destinationAddressAndValueArray = null; // invalid as this is mandatory when isOneToMany is true
     let txBuilder = new BCH.TransactionBuilder();
     const changeAddress = wallet.Path1899.cashAddress;
 
     let thrownError;
     try {
         generateTxOutput(
             BCH,
             isOneToMany,
             singleSendValue,
             satoshisToSend,
             totalInputUtxoValue,
             null,
             destinationAddressAndValueArray,
             changeAddress,
             txFee,
             txBuilder,
         );
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
 });
 
 it(`signAndBuildTx() successfully returns a raw tx hex for a tx with a single input and a single output`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const { wallet } = sendBCHMock;
     // add inputs to txBuilder
     txBuilder.addInput(
         mockSingleInputUtxo[0].txid,
         mockSingleInputUtxo[0].vout,
     );
 
     // add outputs to txBuilder
     const outputAddressAndValue = mockSingleOutput.split(',');
     txBuilder.addOutput(
         outputAddressAndValue[0], // address
         parseInt(fromXecToSatoshis(new BigNumber(outputAddressAndValue[1]))), // value
     );
     const rawTxHex = signAndBuildTx(
         BCH,
         mockSingleInputUtxo,
         txBuilder,
         wallet,
     );
     expect(rawTxHex).toStrictEqual(
         '0200000001582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006b483045022100b4ee5268cb64c4f097e739df7c6934d1df7e75a4f217d5824db18ae2e12554b102204faf039738181aae80c064b928b3d8079a82cdb080ce9a2d5453939a588f4372412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0158020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
     );
 });
 
 it(`signAndBuildTx() successfully returns a raw tx hex for a tx with a single input and multiple outputs`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const { wallet } = sendBCHMock;
     // add inputs to txBuilder
     txBuilder.addInput(
         mockSingleInputUtxo[0].txid,
         mockSingleInputUtxo[0].vout,
     );
 
     // add outputs to txBuilder
     for (let i = 0; i < mockMultipleOutputs.length; i++) {
         const outputAddressAndValue = mockMultipleOutputs[i].split(',');
         txBuilder.addOutput(
             outputAddressAndValue[0], // address
             parseInt(
                 fromXecToSatoshis(new BigNumber(outputAddressAndValue[1])),
             ), // value
         );
     }
 
     const rawTxHex = signAndBuildTx(
         BCH,
         mockSingleInputUtxo,
         txBuilder,
         wallet,
     );
     expect(rawTxHex).toStrictEqual(
         '0200000001582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006b483045022100df29734c4fb348b0e8b613ce522c10c5ac14cb3ecd32843dc7fcf004d60f1b8a022023c4ae02b38c7272e29f344902ae2afa4db1ec37d582a31c16650a0abc4f480c412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0326020000000000001976a914f627e51001a51a1a92d8927808701373cf29267f88ac26020000000000001976a9140b7d35fda03544a08e65464d54cfae4257eb6db788ac26020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
     );
 });
 
 it(`signAndBuildTx() successfully returns a raw tx hex for a tx with multiple inputs and a single output`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const { wallet } = sendBCHMock;
     // add inputs to txBuilder
     for (let i = 0; i < mockMultipleInputUtxos.length; i++) {
         txBuilder.addInput(
             mockMultipleInputUtxos[i].txid,
             mockMultipleInputUtxos[i].vout,
         );
     }
     // add outputs to txBuilder
     const outputAddressAndValue = mockSingleOutput.split(',');
     txBuilder.addOutput(
         outputAddressAndValue[0], // address
         parseInt(fromXecToSatoshis(new BigNumber(outputAddressAndValue[1]))), // value
     );
 
     const rawTxHex = signAndBuildTx(
         BCH,
         mockMultipleInputUtxos,
         txBuilder,
         wallet,
     );
     expect(rawTxHex).toStrictEqual(
         '0200000003582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006a4730440220541366dd5ea25d65d3044dbde16fc6118ab1aee07c7d0d4c25c9e8aa299f040402203ed2f540948197d4c6a4ae963ad187d145a9fb339e311317b03c6172732e267b412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff7313e804af08113dfa290515390a8ec3ac01448118f2eb556ee168a96ee6acdd000000006b483045022100c1d02c5023f83b87a4f2dd26a7306ed9be9d53ab972bd935b440e45eb54a304302200b99aa2f1a728b3bb1dcbff80742c5fcab991bb74e80fa231255a31d58a6ff7d412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff960dd2f0c47e8a3cf1486b046d879f45a047da3b51aedfb5594138ac857214f1000000006b483045022100bd24d11d7070988848cb4aa2b10748aa0aeb79dc8af39c1f22dc1034b3121e5f02201491026e5f8f6eb566eb17cb195e3da3ff0d9cf01bdd34c944964d33a8d3b1ad412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0158020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
     );
 });
 
 it(`signAndBuildTx() successfully returns a raw tx hex for a tx with multiple inputs and multiple outputs`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const { wallet } = sendBCHMock;
     // add inputs to txBuilder
     for (let i = 0; i < mockMultipleInputUtxos.length; i++) {
         txBuilder.addInput(
             mockMultipleInputUtxos[i].txid,
             mockMultipleInputUtxos[i].vout,
         );
     }
     // add outputs to txBuilder
     for (let i = 0; i < mockMultipleOutputs.length; i++) {
         const outputAddressAndValue = mockMultipleOutputs[i].split(',');
         txBuilder.addOutput(
             outputAddressAndValue[0], // address
             parseInt(
                 fromXecToSatoshis(new BigNumber(outputAddressAndValue[1])),
             ), // value
         );
     }
 
     const rawTxHex = signAndBuildTx(
         BCH,
         mockMultipleInputUtxos,
         txBuilder,
         wallet,
     );
     expect(rawTxHex).toStrictEqual(
         '0200000003582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006a47304402203de4e6a512a6bec1d378b6444008484e1be5a0c621dc4b201d67addefffe864602202daf82e76b7594fe1ab54a49380c6b1226ab65551ae6ab9164216b66266f34a1412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff7313e804af08113dfa290515390a8ec3ac01448118f2eb556ee168a96ee6acdd000000006a473044022029f5fcbc9356beb9eae6b9ff9a479e8c8331b95406b6be456fccf9d90f148ea1022028f4e7fa7234f9429535360c8f5dad303e2c5044431615997861b10f26fa8a88412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff960dd2f0c47e8a3cf1486b046d879f45a047da3b51aedfb5594138ac857214f1000000006a473044022049a67738d99006b3523cff818f3626104cf5106bd463be70d22ad179a8cb403b022025829baf67f964202ea77ea7462a5447e32415e7293cdee382ea7ae9374364e8412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0326020000000000001976a914f627e51001a51a1a92d8927808701373cf29267f88ac26020000000000001976a9140b7d35fda03544a08e65464d54cfae4257eb6db788ac26020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
     );
 });
 
 it(`signAndBuildTx() throws error on an empty inputUtxo param`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const { wallet } = sendBCHMock;
     let thrownError;
     try {
         signAndBuildTx(BCH, [], txBuilder, wallet);
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid buildTx parameter');
 });
 
 it(`signAndBuildTx() throws error on a null inputUtxo param`, () => {
     // txbuilder output params
     const BCH = new BCHJS();
     let txBuilder = new BCH.TransactionBuilder();
     const inputUtxo = null; // invalid input param
     const { wallet } = sendBCHMock;
     let thrownError;
     try {
         signAndBuildTx(BCH, inputUtxo, txBuilder, wallet);
     } catch (err) {
         thrownError = err;
     }
     expect(thrownError.message).toStrictEqual('Invalid buildTx parameter');
 });
 
 describe('Correctly executes cash utility functions', () => {
     it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 2`, () => {
         expect(fromSatoshisToXec(1, 2)).toStrictEqual(new BigNumber(0.01));
     });
     it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 2`, () => {
         expect(fromSatoshisToXec(1000000012345678, 2)).toStrictEqual(
             new BigNumber(10000000123456.78),
         );
     });
     it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 8`, () => {
         expect(fromSatoshisToXec(1, 8)).toStrictEqual(
             new BigNumber(0.00000001),
         );
     });
     it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 8`, () => {
         expect(fromSatoshisToXec(1000000012345678, 8)).toStrictEqual(
             new BigNumber(10000000.12345678),
         );
     });
     it(`Accepts a cachedWalletState that has not preserved BigNumber object types, and returns the same wallet state with BigNumber type re-instituted`, () => {
         expect(loadStoredWallet(cachedUtxos)).toStrictEqual(
             utxosLoadedFromCache,
         );
     });
     it(`Correctly determines a wallet's balance from its set of non-eToken utxos (nonSlpUtxos)`, () => {
         expect(
             getWalletBalanceFromUtxos(
                 validStoredWallet.state.slpBalancesAndUtxos.nonSlpUtxos,
             ),
         ).toStrictEqual(validStoredWallet.state.balances);
     });
     it(`Correctly determines a wallet's zero balance from its empty set of non-eToken utxos (nonSlpUtxos)`, () => {
         expect(
             getWalletBalanceFromUtxos(
                 utxosLoadedFromCache.slpBalancesAndUtxos.nonSlpUtxos,
             ),
         ).toStrictEqual(utxosLoadedFromCache.balances);
     });
     it(`Recognizes a stored wallet as valid if it has all required fields`, () => {
         expect(isValidStoredWallet(validStoredWallet)).toBe(true);
     });
     it(`Recognizes a stored wallet as invalid if it is missing required fields`, () => {
         expect(isValidStoredWallet(invalidStoredWallet)).toBe(false);
     });
     it(`Recognizes a stored wallet as invalid if it includes hydratedUtxoDetails in the state field`, () => {
         expect(isValidStoredWallet(invalidpreChronikStoredWallet)).toBe(false);
     });
     it(`Converts a legacy BCH amount to an XEC amount`, () => {
         expect(fromLegacyDecimals(0.00000546, 2)).toStrictEqual(5.46);
     });
     it(`Leaves a legacy BCH amount unchanged if currency.cashDecimals is 8`, () => {
         expect(fromLegacyDecimals(0.00000546, 8)).toStrictEqual(0.00000546);
     });
     it(`convertToEcashPrefix converts a bitcoincash: prefixed address to an ecash: prefixed address`, () => {
         expect(
             convertToEcashPrefix(
                 'bitcoincash:qz2708636snqhsxu8wnlka78h6fdp77ar5ulhz04hr',
             ),
         ).toBe('ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035');
     });
     it(`convertToEcashPrefix returns an ecash: prefix address unchanged`, () => {
         expect(
             convertToEcashPrefix(
                 'ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035',
             ),
         ).toBe('ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035');
     });
     it(`toLegacyToken returns an etoken: prefix address as simpleledger:`, () => {
         expect(
             toLegacyToken('etoken:qz2708636snqhsxu8wnlka78h6fdp77ar5tv2tzg4r'),
         ).toBe('simpleledger:qz2708636snqhsxu8wnlka78h6fdp77ar5syue64fa');
     });
     it(`toLegacyToken returns an prefixless valid etoken address in simpleledger: format with prefix`, () => {
         expect(
             toLegacyToken('qz2708636snqhsxu8wnlka78h6fdp77ar5tv2tzg4r'),
         ).toBe('simpleledger:qz2708636snqhsxu8wnlka78h6fdp77ar5syue64fa');
     });
     it(`Recognizes a wallet with missing Path1889 is a Legacy Wallet and requires migration`, () => {
         expect(isLegacyMigrationRequired(missingPath1899Wallet)).toBe(true);
     });
     it(`Recognizes a wallet with missing PublicKey in Path1889 is a Legacy Wallet and requires migration`, () => {
         expect(
             isLegacyMigrationRequired(missingPublicKeyInPath1899Wallet),
         ).toBe(true);
     });
     it(`Recognizes a wallet with missing PublicKey in Path145 is a Legacy Wallet and requires migration`, () => {
         expect(isLegacyMigrationRequired(missingPublicKeyInPath145Wallet)).toBe(
             true,
         );
     });
     it(`Recognizes a wallet with missing PublicKey in Path245 is a Legacy Wallet and requires migration`, () => {
         expect(isLegacyMigrationRequired(missingPublicKeyInPath245Wallet)).toBe(
             true,
         );
     });
     it(`Recognizes a wallet with missing Hash160 values is a Legacy Wallet and requires migration`, () => {
         expect(isLegacyMigrationRequired(missingHash160)).toBe(true);
     });
     it(`Recognizes a latest, current wallet that does not require migration`, () => {
         expect(isLegacyMigrationRequired(notLegacyWallet)).toBe(false);
     });
 
     test('toLegacyCash() converts a valid ecash: prefix address to a valid bitcoincash: prefix address', async () => {
         const result = toLegacyCash(
             'ecash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gtfza25mc',
         );
         expect(result).toStrictEqual(
             'bitcoincash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gjykk3wa0',
         );
     });
 
     test('toLegacyCash() converts a valid ecash: prefixless address to a valid bitcoincash: prefix address', async () => {
         const result = toLegacyCash(
             'qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gtfza25mc',
         );
         expect(result).toStrictEqual(
             'bitcoincash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gjykk3wa0',
         );
     });
 
     test('toLegacyCash throws error if input address has invalid checksum', async () => {
         const result = toLegacyCash(
             'ecash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gtfza25m',
         );
         expect(result).toStrictEqual(
             new Error(
                 'ecash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gtfza25m is not a valid ecash address',
             ),
         );
     });
 
     test('toLegacyCash() throws error with input of etoken: address', async () => {
         const result = toLegacyCash(
             'etoken:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4g9htlunl0',
         );
         expect(result).toStrictEqual(
             new Error(
                 'etoken:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4g9htlunl0 is not a valid ecash address',
             ),
         );
     });
 
     test('toLegacyCash() throws error with input of legacy address', async () => {
         const result = toLegacyCash('13U6nDrkRsC3Eb1pxPhNY8XJ5W9zdp6rNk');
         expect(result).toStrictEqual(
             new Error(
                 '13U6nDrkRsC3Eb1pxPhNY8XJ5W9zdp6rNk is not a valid ecash address',
             ),
         );
     });
 
     test('toLegacyCash() throws error with input of bitcoincash: address', async () => {
         const result = toLegacyCash(
             'bitcoincash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gjykk3wa0',
         );
         expect(result).toStrictEqual(
             new Error(
                 'bitcoincash:qqd3qn4zazjhygk5a2vzw2gvqgqwempr4gjykk3wa0 is not a valid ecash address',
             ),
         );
     });
 
     test('toLegacyCashArray throws error if the addressArray input is null', async () => {
         const result = toLegacyCashArray(null);
 
         expect(result).toStrictEqual(new Error('Invalid addressArray input'));
     });
 
     test('toLegacyCashArray throws error if the addressArray input is empty', async () => {
         const result = toLegacyCashArray([]);
 
         expect(result).toStrictEqual(new Error('Invalid addressArray input'));
     });
 
     test('toLegacyCashArray throws error if the addressArray input is a number', async () => {
         const result = toLegacyCashArray(12345);
 
         expect(result).toStrictEqual(new Error('Invalid addressArray input'));
     });
 
     test('toLegacyCashArray throws error if the addressArray input is undefined', async () => {
         const result = toLegacyCashArray(undefined);
 
         expect(result).toStrictEqual(new Error('Invalid addressArray input'));
     });
 
     test('toLegacyCashArray successfully converts a standard sized valid addressArray input', async () => {
         const result = toLegacyCashArray(validAddressArrayInput);
 
         expect(result).toStrictEqual(validAddressArrayOutput);
     });
 
     test('toLegacyCashArray successfully converts a standard sized valid addressArray input including prefixless ecash addresses', async () => {
         const result = toLegacyCashArray(validAddressArrayInputMixedPrefixes);
 
         expect(result).toStrictEqual(validAddressArrayOutput);
     });
 
     test('toLegacyCashArray successfully converts a large valid addressArray input', async () => {
         const result = toLegacyCashArray(validLargeAddressArrayInput);
 
         expect(result).toStrictEqual(validLargeAddressArrayOutput);
     });
 
     test('toLegacyCashArray throws an error on an addressArray with invalid addresses', async () => {
         const result = toLegacyCashArray(invalidAddressArrayInput);
 
         expect(result).toStrictEqual(
             new Error(
                 'ecash:qrqgwxrrrrrrrrrrrrrrrrrrrrrrrrr7zsvk is not a valid ecash address',
             ),
         );
     });
 
     test('parseOpReturn() successfully parses a short cashtab message', async () => {
         const result = parseOpReturn(shortCashtabMessageInputHex);
         expect(result).toStrictEqual(mockParsedShortCashtabMessageArray);
     });
 
     test('parseOpReturn() successfully parses a long cashtab message where an additional PUSHDATA1 is present', async () => {
         const result = parseOpReturn(longCashtabMessageInputHex);
         expect(result).toStrictEqual(mockParsedLongCashtabMessageArray);
     });
 
     test('parseOpReturn() successfully parses a short external message', async () => {
         const result = parseOpReturn(shortExternalMessageInputHex);
         expect(result).toStrictEqual(mockParsedShortExternalMessageArray);
     });
 
     test('parseOpReturn() successfully parses a long external message where an additional PUSHDATA1 is present', async () => {
         const result = parseOpReturn(longExternalMessageInputHex);
         expect(result).toStrictEqual(mockParsedLongExternalMessageArray);
     });
 
     test('parseOpReturn() successfully parses an external message that is segmented into separate short parts', async () => {
         const result = parseOpReturn(shortSegmentedExternalMessageInputHex);
         expect(result).toStrictEqual(
             mockParsedShortSegmentedExternalMessageArray,
         );
     });
 
     test('parseOpReturn() successfully parses an external message that is segmented into separate long parts', async () => {
         const result = parseOpReturn(longSegmentedExternalMessageInputHex);
         expect(result).toStrictEqual(
             mockParsedLongSegmentedExternalMessageArray,
         );
     });
 
     test('parseOpReturn() successfully parses an external message that is segmented into separate long and short parts', async () => {
         const result = parseOpReturn(mixedSegmentedExternalMessageInputHex);
         expect(result).toStrictEqual(
             mockParsedMixedSegmentedExternalMessageArray,
         );
     });
 
     test('parseOpReturn() successfully parses an eToken output', async () => {
         const result = parseOpReturn(eTokenInputHex);
         expect(result).toStrictEqual(mockParsedETokenOutputArray);
     });
 
     test('parseOpReturn() successfully parses an airdrop transaction', async () => {
         const result = parseOpReturn(mockAirdropHexOutput);
         // verify the hex output is parsed correctly
         expect(result).toStrictEqual(mockParsedAirdropMessageArray);
         // verify airdrop hex prefix is contained in the array returned from parseOpReturn()
         expect(
             result.find(
                 element => element === currency.opReturn.appPrefixesHex.airdrop,
             ),
         ).toStrictEqual(currency.opReturn.appPrefixesHex.airdrop);
     });
 
     test('convertEtokenToEcashAddr successfully converts a valid eToken address to eCash', async () => {
         const result = convertEtokenToEcashAddr(
             'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs',
         );
         expect(result).toStrictEqual(
             'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
         );
     });
 
     test('convertEtokenToEcashAddr successfully converts prefixless eToken address as input', async () => {
         const result = convertEtokenToEcashAddr(
             'qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs',
         );
         expect(result).toStrictEqual(
             'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
         );
     });
 
     test('convertEtokenToEcashAddr throws error with an invalid eToken address as input', async () => {
         const result = convertEtokenToEcashAddr('etoken:qpj9gcldpffcs');
         expect(result).toStrictEqual(
             new Error(
                 'cashMethods.convertToEcashAddr() error: etoken:qpj9gcldpffcs is not a valid etoken address',
             ),
         );
     });
 
     test('convertEtokenToEcashAddr throws error with an ecash address as input', async () => {
         const result = convertEtokenToEcashAddr(
             'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
         );
         expect(result).toStrictEqual(
             new Error(
                 'cashMethods.convertToEcashAddr() error: ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8 is not a valid etoken address',
             ),
         );
     });
 
     test('convertEtokenToEcashAddr throws error with null input', async () => {
         const result = convertEtokenToEcashAddr(null);
         expect(result).toStrictEqual(
             new Error(
                 'cashMethods.convertToEcashAddr() error: No etoken address provided',
             ),
         );
     });
 
     test('convertEtokenToEcashAddr throws error with empty string input', async () => {
         const result = convertEtokenToEcashAddr('');
         expect(result).toStrictEqual(
             new Error(
                 'cashMethods.convertToEcashAddr() error: No etoken address provided',
             ),
         );
     });
 
     test('convertEcashtoEtokenAddr successfully converts a valid ecash address into an etoken address', async () => {
         const eCashAddress = 'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8';
         const eTokenAddress =
             'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
         const result = convertEcashtoEtokenAddr(eCashAddress);
         expect(result).toStrictEqual(eTokenAddress);
     });
 
     test('convertEcashtoEtokenAddr successfully converts a valid prefix-less ecash address into an etoken address', async () => {
         const eCashAddress = 'qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8';
         const eTokenAddress =
             'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
         const result = convertEcashtoEtokenAddr(eCashAddress);
         expect(result).toStrictEqual(eTokenAddress);
     });
 
     test('convertEcashtoEtokenAddr throws error with invalid ecash address input', async () => {
         const eCashAddress = 'ecash:qpaNOTVALIDADDRESSwu8';
         const result = convertEcashtoEtokenAddr(eCashAddress);
         expect(result).toStrictEqual(
             new Error(eCashAddress + ' is not a valid ecash address'),
         );
     });
 
     test('convertEcashtoEtokenAddr throws error with a valid etoken address input', async () => {
         const eTokenAddress =
             'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
         const result = convertEcashtoEtokenAddr(eTokenAddress);
         expect(result).toStrictEqual(
             new Error(eTokenAddress + ' is not a valid ecash address'),
         );
     });
 
     test('convertEcashtoEtokenAddr throws error with a valid bitcoincash address input', async () => {
         const bchAddress =
             'bitcoincash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9g0vsgy56s';
         const result = convertEcashtoEtokenAddr(bchAddress);
         expect(result).toStrictEqual(
             new Error(bchAddress + ' is not a valid ecash address'),
         );
     });
 
     test('convertEcashtoEtokenPrefix throws error with null ecash address input', async () => {
         const eCashAddress = null;
         const result = convertEcashtoEtokenAddr(eCashAddress);
         expect(result).toStrictEqual(
             new Error(eCashAddress + ' is not a valid ecash address'),
         );
     });
 
     it(`flattenContactList flattens contactList array by returning an array of addresses`, () => {
         expect(
             flattenContactList([
                 {
                     address: 'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
                     name: 'Alpha',
                 },
                 {
                     address: 'ecash:qpq235n3l3u6ampc8slapapnatwfy446auuv64ylt2',
                     name: 'Beta',
                 },
                 {
                     address: 'ecash:qz50e58nkeg2ej2f34z6mhwylp6ven8emy8pp52r82',
                     name: 'Gamma',
                 },
             ]),
         ).toStrictEqual([
             'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
             'ecash:qpq235n3l3u6ampc8slapapnatwfy446auuv64ylt2',
             'ecash:qz50e58nkeg2ej2f34z6mhwylp6ven8emy8pp52r82',
         ]);
     });
 
     it(`flattenContactList flattens contactList array of length 1 by returning an array of 1 address`, () => {
         expect(
             flattenContactList([
                 {
                     address: 'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
                     name: 'Alpha',
                 },
             ]),
         ).toStrictEqual(['ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr']);
     });
     it(`flattenContactList returns an empty array for invalid input`, () => {
         expect(flattenContactList(false)).toStrictEqual([]);
     });
     it(`getHashArrayFromWallet returns false for a legacy wallet`, () => {
         expect(
             getHashArrayFromWallet(mockLegacyWallets.legacyAlphaMainnet),
         ).toBe(false);
     });
     it(`Successfully extracts a hash160 array from a migrated wallet object`, () => {
         expect(
             getHashArrayFromWallet(
                 mockLegacyWallets.migratedLegacyAlphaMainnet,
             ),
         ).toStrictEqual([
             '960c9ed561f1699f0c49974d50b3bb7cdc118625',
             '2be0e0c999e7e77a443ea726f82c441912fca92b',
             'ba8257db65f40359989c7b894c5e88ed7b6344f6',
         ]);
     });
-
-    it(`Returns decimals, name, and ticker for an eToken stored in wallet object`, () => {
-        expect(
-            checkWalletForTokenInfo(
-                '4bd147fc5d5ff26249a9299c46b80920c0b81f59a60e05428262160ebee0b0c3',
-                validStoredWallet,
-            ),
-        ).toStrictEqual({
-            decimals: 0,
-            name: 'Covid19 Lifetime Immunity',
-            ticker: 'NOCOVID',
-        });
-    });
-    it(`Returns false for an eToken not stored in a wallet object`, () => {
-        expect(
-            checkWalletForTokenInfo(
-                '98183238638ecb4ddc365056e22de0e8a05448c1e6084bae247fae5a74ad4f48',
-                validStoredWallet,
-            ),
-        ).toBe(false);
-    });
     it(`isActiveWebsocket returns true for an active chronik websocket connection`, () => {
         expect(isActiveWebsocket(activeWebsocketAlpha)).toBe(true);
     });
     it(`isActiveWebsocket returns false for a disconnected chronik websocket connection`, () => {
         expect(isActiveWebsocket(disconnectedWebsocketAlpha)).toBe(false);
     });
     it(`isActiveWebsocket returns false for a null chronik websocket connection`, () => {
         expect(isActiveWebsocket(null)).toBe(false);
     });
     it(`isActiveWebsocket returns false for an active websocket connection with no subscriptions`, () => {
         expect(isActiveWebsocket(unsubscribedWebsocket)).toBe(false);
     });
 });
diff --git a/web/cashtab/src/utils/__tests__/chronik.test.js b/web/cashtab/src/utils/__tests__/chronik.test.js
index 045b8ea22..823213833 100644
--- a/web/cashtab/src/utils/__tests__/chronik.test.js
+++ b/web/cashtab/src/utils/__tests__/chronik.test.js
@@ -1,464 +1,506 @@
 import BigNumber from 'bignumber.js';
 import {
     organizeUtxosByType,
     getPreliminaryTokensArray,
     finalizeTokensArray,
     finalizeSlpUtxos,
     getTokenStats,
     flattenChronikTxHistory,
     sortAndTrimChronikTxHistory,
     parseChronikTx,
 } from 'utils/chronik';
 import {
     mockChronikUtxos,
     mockOrganizedUtxosByType,
     mockPreliminaryTokensArray,
     mockPreliminaryTokensArrayClone,
     mockPreliminaryTokensArrayCloneClone,
     mockChronikTxDetailsResponses,
     mockFinalTokenArray,
     mockFinalCachedTokenInfo,
     mockPartialCachedTokenInfo,
     mockPartialChronikTxDetailsResponses,
     mockPreliminarySlpUtxos,
     mockFinalizedSlpUtxos,
     mockTokenInfoById,
 } from '../__mocks__/chronikUtxos';
 import {
     mockChronikTokenResponse,
     mockGetTokenStatsReturn,
 } from '../__mocks__/mockChronikTokenStats';
 import {
     mockTxHistoryOfAllAddresses,
     mockFlatTxHistoryNoUnconfirmed,
     mockSortedTxHistoryNoUnconfirmed,
     mockFlatTxHistoryWithUnconfirmed,
     mockSortedFlatTxHistoryWithUnconfirmed,
     mockFlatTxHistoryWithAllUnconfirmed,
     mockSortedFlatTxHistoryWithAllUnconfirmed,
     mockParseTxWallet,
     lambdaIncomingXecTx,
     lambdaOutgoingXecTx,
     lambdaIncomingEtokenTx,
     lambdaOutgoingEtokenTx,
     eTokenGenesisTx,
     receivedEtokenTxNineDecimals,
     anotherMockParseTxWallet,
     txHistoryTokenInfoById,
 } from '../__mocks__/chronikTxHistory';
 import { ChronikClient } from 'chronik-client';
 import { when } from 'jest-when';
 import BCHJS from '@psf/bch-js';
 
 it(`getTokenStats successfully returns a token stats object`, async () => {
     // Initialize chronik
     const chronik = new ChronikClient(
         'https://FakeChronikUrlToEnsureMocksOnly.com',
     );
     const tokenId =
         'bb8e9f685a06a2071d82f757ce19201b4c8e5e96fbe186960a3d65aec83eab20';
     /*
         Mock the API response from chronik.token('tokenId') called
         in getTokenStats()
     */
     chronik.token = jest.fn();
     when(chronik.token)
         .calledWith(tokenId)
         .mockResolvedValue(mockChronikTokenResponse);
     expect(await getTokenStats(chronik, tokenId)).toStrictEqual(
         mockGetTokenStatsReturn,
     );
 });
 
 it(`organizeUtxosByType successfully splits a chronikUtxos array into slpUtxos and nonSlpUtxos`, () => {
     expect(organizeUtxosByType(mockChronikUtxos)).toStrictEqual(
         mockOrganizedUtxosByType,
     );
 
     const resultingOrganizedUtxosObject = organizeUtxosByType(mockChronikUtxos);
     const { nonSlpUtxos, preliminarySlpUtxos } = resultingOrganizedUtxosObject;
     const utxosWithUnexpectedKeys = [];
     for (let i = 0; i < nonSlpUtxos.length; i += 1) {
         // None of the objects in mockOrganizedUtxosByType.nonSlpUtxos should have the `slpToken` key
         // Note: Some may have an `slpMeta` key, if the utxo is from a token burn
         const nonSlpUtxo = nonSlpUtxos[i];
         if ('slpToken' in nonSlpUtxo) {
             console.log(`unexpected nonSlpUtxo!`, nonSlpUtxo);
             utxosWithUnexpectedKeys.push(nonSlpUtxo);
         }
     }
     for (let i = 0; i < preliminarySlpUtxos.length; i += 1) {
         // All of the objects in mockOrganizedUtxosByType.slpUtxos should have the `slpMeta` and `slpToken` keys
         const slpUtxo = preliminarySlpUtxos[i];
         if (!('slpMeta' in slpUtxo) || !('slpToken' in slpUtxo)) {
             console.log(`unexpected slpUtxo!`, slpUtxo);
             utxosWithUnexpectedKeys.push(slpUtxo);
         }
     }
     expect(utxosWithUnexpectedKeys.length).toBe(0);
     // Length of organized utxos should match original
     expect(preliminarySlpUtxos.length + nonSlpUtxos.length).toBe(
         mockChronikUtxos.length,
     );
 });
 
 it(`getPreliminaryTokensArray successfully returns an array of all tokenIds and token balances (not yet adjusted for token decimals)`, () => {
     expect(
         getPreliminaryTokensArray(mockOrganizedUtxosByType.preliminarySlpUtxos),
     ).toStrictEqual(mockPreliminaryTokensArray);
 });
 
 it(`finalizeTokensArray successfully returns finalTokenArray and cachedTokenInfoById even if no cachedTokenInfoById is provided`, async () => {
     // Initialize chronik
     const chronik = new ChronikClient(
         'https://FakeChronikUrlToEnsureMocksOnly.com',
     );
     /* 
         Mock the API response from chronik.tx('tokenId') called 
         in returnGetTokenInfoChronikPromise -- for each tokenId used
     */
     chronik.tx = jest.fn();
     for (let i = 0; i < mockChronikTxDetailsResponses.length; i += 1) {
         when(chronik.tx)
             .calledWith(mockChronikTxDetailsResponses[i].txid)
             .mockResolvedValue(mockChronikTxDetailsResponses[i]);
     }
 
     expect(
         await finalizeTokensArray(chronik, mockPreliminaryTokensArray),
     ).toStrictEqual({
         finalTokenArray: mockFinalTokenArray,
         updatedTokenInfoById: mockFinalCachedTokenInfo,
         newTokensToCache: true,
     });
 });
 
 it(`finalizeTokensArray successfully returns finalTokenArray and cachedTokenInfoById when called with all token info in cache`, async () => {
     // Initialize chronik
     const chronik = new ChronikClient(
         'https://FakeChronikUrlToEnsureMocksOnly.com',
     );
 
     expect(
         await finalizeTokensArray(
             chronik,
             mockPreliminaryTokensArrayClone,
             mockFinalCachedTokenInfo,
         ),
     ).toStrictEqual({
         finalTokenArray: mockFinalTokenArray,
         updatedTokenInfoById: mockFinalCachedTokenInfo,
         newTokensToCache: false,
     });
 });
 
 it(`updateCachedTokenInfoAndFinalizeTokensArray successfully returns finalTokenArray and cachedTokenInfoById when called with some token info in cache`, async () => {
     // Initialize chronik
     const chronik = new ChronikClient(
         'https://FakeChronikUrlToEnsureMocksOnly.com',
     );
     /* 
         Mock the API response from chronik.tx('tokenId') called 
         in returnGetTokenInfoChronikPromise -- for each tokenId used
     */
     chronik.tx = jest.fn();
     for (let i = 0; i < mockPartialChronikTxDetailsResponses.length; i += 1) {
         when(chronik.tx)
             .calledWith(mockPartialChronikTxDetailsResponses[i].txid)
             .mockResolvedValue(mockPartialChronikTxDetailsResponses[i]);
     }
 
     expect(
         await finalizeTokensArray(
             chronik,
             mockPreliminaryTokensArrayCloneClone,
             mockPartialCachedTokenInfo,
         ),
     ).toStrictEqual({
         finalTokenArray: mockFinalTokenArray,
         updatedTokenInfoById: mockFinalCachedTokenInfo,
         newTokensToCache: true,
     });
 });
 
 it(`finalizeSlpUtxos successfully adds token quantity adjusted for token decimals to preliminarySlpUtxos`, async () => {
     expect(
         await finalizeSlpUtxos(mockPreliminarySlpUtxos, mockTokenInfoById),
     ).toStrictEqual(mockFinalizedSlpUtxos);
 });
 
 it(`flattenChronikTxHistory successfully combines the result of getTxHistoryChronik into a single array`, async () => {
     expect(
         await flattenChronikTxHistory(mockTxHistoryOfAllAddresses),
     ).toStrictEqual(mockFlatTxHistoryNoUnconfirmed);
 });
 
 it(`sortAndTrimChronikTxHistory successfully orders the result of flattenChronikTxHistory by blockheight and firstSeenTime if all txs are confirmed, and returns a result of expected length`, async () => {
     expect(
         await sortAndTrimChronikTxHistory(mockFlatTxHistoryNoUnconfirmed, 10),
     ).toStrictEqual(mockSortedTxHistoryNoUnconfirmed);
 });
 
 it(`sortAndTrimChronikTxHistory successfully orders the result of flattenChronikTxHistory by blockheight and firstSeenTime if some txs are confirmed and others unconfirmed, and returns a result of expected length`, async () => {
     expect(
         await sortAndTrimChronikTxHistory(mockFlatTxHistoryWithUnconfirmed, 10),
     ).toStrictEqual(mockSortedFlatTxHistoryWithUnconfirmed);
 });
 
 it(`sortAndTrimChronikTxHistory successfully orders the result of flattenChronikTxHistory by blockheight and firstSeenTime if all txs are unconfirmed, and returns a result of expected length`, async () => {
     expect(
         await sortAndTrimChronikTxHistory(
             mockFlatTxHistoryWithAllUnconfirmed,
             10,
         ),
     ).toStrictEqual(mockSortedFlatTxHistoryWithAllUnconfirmed);
 });
 
 it(`Successfully parses an incoming XEC tx`, () => {
     const BCH = new BCHJS({
         restURL: 'https://FakeBchApiUrlToEnsureMocksOnly.com',
     });
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvll3cvjwd',
         );
     expect(
         parseChronikTx(
             BCH,
             lambdaIncomingXecTx,
             mockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: true,
         xecAmount: '42',
         originatingHash160: '4e532257c01b310b3b5c1fd947c79a72addf8523',
         isEtokenTx: false,
         legacy: {
             airdropFlag: false,
             airdropTokenId: '',
             amountReceived: '42',
             amountSent: 0,
             decryptionSuccess: false,
             isCashtabMessage: false,
             isEncryptedMessage: false,
             opReturnMessage: '',
             outgoingTx: false,
             replyAddress: 'ecash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvxj9nhgg6',
             tokenTx: false,
         },
     });
 });
 it(`Successfully parses an outgoing XEC tx`, () => {
     const BCH = new BCHJS({
         restURL: 'https://FakeBchApiUrlToEnsureMocksOnly.com',
     });
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qpmytrdsakt0axrrlswvaj069nat3p9s7ct4lsf8k9',
         );
     expect(
         parseChronikTx(
             BCH,
             lambdaOutgoingXecTx,
             mockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: false,
         xecAmount: '222',
         originatingHash160: '76458db0ed96fe9863fc1ccec9fa2cfab884b0f6',
         isEtokenTx: false,
         legacy: {
             airdropFlag: false,
             airdropTokenId: '',
             amountReceived: 0,
             amountSent: '222',
             decryptionSuccess: false,
             isCashtabMessage: false,
             isEncryptedMessage: false,
             opReturnMessage: '',
             outgoingTx: true,
             replyAddress: 'ecash:qpmytrdsakt0axrrlswvaj069nat3p9s7cjctmjasj',
             tokenTx: false,
         },
     });
 });
 it(`Successfully parses an incoming eToken tx`, () => {
     const BCH = new BCHJS();
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvll3cvjwd',
         );
     expect(
         parseChronikTx(
             BCH,
             lambdaIncomingEtokenTx,
             mockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: true,
         xecAmount: '5.46',
         isEtokenTx: true,
         originatingHash160: '4e532257c01b310b3b5c1fd947c79a72addf8523',
         slpMeta: {
             tokenId:
                 '4bd147fc5d5ff26249a9299c46b80920c0b81f59a60e05428262160ebee0b0c3',
             tokenType: 'FUNGIBLE',
             txType: 'SEND',
         },
+        genesisInfo: {
+            decimals: 0,
+            success: true,
+            tokenDocumentHash: '',
+            tokenDocumentUrl:
+                'https://www.who.int/emergencies/diseases/novel-coronavirus-2019/covid-19-vaccines',
+            tokenId:
+                '4bd147fc5d5ff26249a9299c46b80920c0b81f59a60e05428262160ebee0b0c3',
+            tokenName: 'Covid19 Lifetime Immunity',
+            tokenTicker: 'NOCOVID',
+        },
         etokenAmount: '12',
         legacy: {
             airdropFlag: false,
             airdropTokenId: '',
             amountReceived: '5.46',
             amountSent: 0,
             decryptionSuccess: false,
             isCashtabMessage: false,
             isEncryptedMessage: false,
             opReturnMessage: '',
             outgoingTx: false,
             replyAddress: 'ecash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvxj9nhgg6',
             tokenTx: true,
         },
     });
 });
 it(`Successfully parses an outgoing eToken tx`, () => {
     const BCH = new BCHJS({
         restURL: 'https://FakeBchApiUrlToEnsureMocksOnly.com',
     });
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qpmytrdsakt0axrrlswvaj069nat3p9s7ct4lsf8k9',
         );
     expect(
         parseChronikTx(
             BCH,
             lambdaOutgoingEtokenTx,
             mockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: false,
         xecAmount: '5.46',
         isEtokenTx: true,
         originatingHash160: '76458db0ed96fe9863fc1ccec9fa2cfab884b0f6',
         slpMeta: {
             tokenId:
                 '4bd147fc5d5ff26249a9299c46b80920c0b81f59a60e05428262160ebee0b0c3',
             tokenType: 'FUNGIBLE',
             txType: 'SEND',
         },
+        genesisInfo: {
+            decimals: 0,
+            success: true,
+            tokenDocumentHash: '',
+            tokenDocumentUrl:
+                'https://www.who.int/emergencies/diseases/novel-coronavirus-2019/covid-19-vaccines',
+            tokenId:
+                '4bd147fc5d5ff26249a9299c46b80920c0b81f59a60e05428262160ebee0b0c3',
+            tokenName: 'Covid19 Lifetime Immunity',
+            tokenTicker: 'NOCOVID',
+        },
         etokenAmount: '17',
         legacy: {
             airdropFlag: false,
             airdropTokenId: '',
             amountReceived: 0,
             amountSent: '5.46',
             decryptionSuccess: false,
             isCashtabMessage: false,
             isEncryptedMessage: false,
             opReturnMessage: '',
             outgoingTx: true,
             replyAddress: 'ecash:qpmytrdsakt0axrrlswvaj069nat3p9s7cjctmjasj',
             tokenTx: true,
         },
     });
 });
 it(`Successfully parses a genesis eToken tx`, () => {
     const BCH = new BCHJS({
         restURL: 'https://FakeBchApiUrlToEnsureMocksOnly.com',
     });
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qz2708636snqhsxu8wnlka78h6fdp77ar5ulhz04hr',
         );
     expect(
         parseChronikTx(
             BCH,
             eTokenGenesisTx,
             anotherMockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: false,
         xecAmount: '0',
         originatingHash160: '95e79f51d4260bc0dc3ba7fb77c7be92d0fbdd1d',
         isEtokenTx: true,
         etokenAmount: '777.7777777',
         slpMeta: {
             tokenType: 'FUNGIBLE',
             txType: 'GENESIS',
             tokenId:
                 'cf601c56b58bc05a39a95374a4a865f0a8b56544ea937b30fb46315441717c50',
         },
+        genesisInfo: {
+            decimals: 7,
+            success: true,
+            tokenDocumentHash: '',
+            tokenDocumentUrl: 'https://cashtab.com/',
+            tokenId:
+                'cf601c56b58bc05a39a95374a4a865f0a8b56544ea937b30fb46315441717c50',
+            tokenName: 'UpdateTest',
+            tokenTicker: 'UDT',
+        },
         legacy: {
             amountSent: '0',
             amountReceived: 0,
             outgoingTx: true,
             tokenTx: true,
             airdropFlag: false,
             airdropTokenId: '',
             opReturnMessage: '',
             isCashtabMessage: false,
             isEncryptedMessage: false,
             decryptionSuccess: false,
             replyAddress: 'ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035',
         },
     });
 });
 it(`Successfully parses a received eToken tx with 9 decimal places`, () => {
     const BCH = new BCHJS({
         restURL: 'https://FakeBchApiUrlToEnsureMocksOnly.com',
     });
     // This function needs to be mocked as bch-js functions that require Buffer types do not work in jest environment
     BCH.Address.hash160ToCash = jest
         .fn()
         .mockReturnValue(
             'bitcoincash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvll3cvjwd',
         );
     expect(
         parseChronikTx(
             BCH,
             receivedEtokenTxNineDecimals,
             anotherMockParseTxWallet,
             txHistoryTokenInfoById,
         ),
     ).toStrictEqual({
         incoming: true,
         xecAmount: '5.46',
         originatingHash160: '4e532257c01b310b3b5c1fd947c79a72addf8523',
         isEtokenTx: true,
         etokenAmount: '0.123456789',
         slpMeta: {
             tokenType: 'FUNGIBLE',
             txType: 'SEND',
             tokenId:
                 'acba1d7f354c6d4d001eb99d31de174e5cea8a31d692afd6e7eb8474ad541f55',
         },
+        genesisInfo: {
+            decimals: 9,
+            success: true,
+            tokenDocumentHash: '',
+            tokenDocumentUrl: 'https://cashtabapp.com/',
+            tokenId:
+                'acba1d7f354c6d4d001eb99d31de174e5cea8a31d692afd6e7eb8474ad541f55',
+            tokenName: 'CashTabBits',
+            tokenTicker: 'CTB',
+        },
         legacy: {
             amountSent: 0,
             amountReceived: '5.46',
             outgoingTx: false,
             tokenTx: true,
             airdropFlag: false,
             airdropTokenId: '',
             opReturnMessage: '',
             isCashtabMessage: false,
             isEncryptedMessage: false,
             decryptionSuccess: false,
             replyAddress: 'ecash:qp89xgjhcqdnzzemts0aj378nfe2mhu9yvxj9nhgg6',
         },
     });
 });
diff --git a/web/cashtab/src/utils/cashMethods.js b/web/cashtab/src/utils/cashMethods.js
index c81088146..a000c82ec 100644
--- a/web/cashtab/src/utils/cashMethods.js
+++ b/web/cashtab/src/utils/cashMethods.js
@@ -1,872 +1,847 @@
 import { currency } from 'components/Common/Ticker';
 import {
     isValidXecAddress,
     isValidEtokenAddress,
     isValidContactList,
 } from 'utils/validation';
 import BigNumber from 'bignumber.js';
 import cashaddr from 'ecashaddrjs';
 import useBCH from '../hooks/useBCH';
 
 export const getUtxoWif = (utxo, wallet) => {
     if (!wallet) {
         throw new Error('Invalid wallet parameter');
     }
     const accounts = [wallet.Path245, wallet.Path145, wallet.Path1899];
     const wif = accounts
         .filter(acc => acc.cashAddress === utxo.address)
         .pop().fundingWif;
     return wif;
 };
 
 export const signUtxosByAddress = (BCH, inputUtxos, wallet, txBuilder) => {
     for (let i = 0; i < inputUtxos.length; i++) {
         const utxo = inputUtxos[i];
         const accounts = [wallet.Path245, wallet.Path145, wallet.Path1899];
         const utxoEcPair = BCH.ECPair.fromWIF(
             accounts.filter(acc => acc.cashAddress === utxo.address).pop()
                 .fundingWif,
         );
 
         txBuilder.sign(
             i,
             utxoEcPair,
             undefined,
             txBuilder.hashTypes.SIGHASH_ALL,
             parseInt(utxo.value),
         );
     }
 
     return txBuilder;
 };
 
 export const generateTxInput = (
     BCH,
     isOneToMany,
     utxos,
     txBuilder,
     destinationAddressAndValueArray,
     satoshisToSend,
     feeInSatsPerByte,
 ) => {
     const { calcFee } = useBCH();
     let txInputObj = {};
     const inputUtxos = [];
     let txFee = 0;
     let totalInputUtxoValue = new BigNumber(0);
     try {
         if (
             !BCH ||
             (isOneToMany && !destinationAddressAndValueArray) ||
             !utxos ||
             !txBuilder ||
             !satoshisToSend ||
             !feeInSatsPerByte
         ) {
             throw new Error('Invalid tx input parameter');
         }
 
         // A normal tx will have 2 outputs, destination and change
         // A one to many tx will have n outputs + 1 change output, where n is the number of recipients
         const txOutputs = isOneToMany
             ? destinationAddressAndValueArray.length + 1
             : 2;
         for (let i = 0; i < utxos.length; i++) {
             const utxo = utxos[i];
             totalInputUtxoValue = totalInputUtxoValue.plus(utxo.value);
             const vout = utxo.outpoint.outIdx;
             const txid = utxo.outpoint.txid;
             // add input with txid and index of vout
             txBuilder.addInput(txid, vout);
 
             inputUtxos.push(utxo);
             txFee = calcFee(BCH, inputUtxos, txOutputs, feeInSatsPerByte);
 
             if (totalInputUtxoValue.minus(satoshisToSend).minus(txFee).gte(0)) {
                 break;
             }
         }
     } catch (err) {
         console.log(`generateTxInput() error: ` + err);
         throw err;
     }
     txInputObj.txBuilder = txBuilder;
     txInputObj.totalInputUtxoValue = totalInputUtxoValue;
     txInputObj.inputUtxos = inputUtxos;
     txInputObj.txFee = txFee;
     return txInputObj;
 };
 
 export const getChangeAddressFromInputUtxos = (BCH, inputUtxos, wallet) => {
     if (!BCH || !inputUtxos || !wallet) {
         throw new Error('Invalid getChangeAddressFromWallet input parameter');
     }
 
     // Assume change address is input address of utxo at index 0
     let changeAddress;
 
     // Validate address
     try {
         changeAddress = inputUtxos[0].address;
         BCH.Address.isCashAddress(changeAddress);
     } catch (err) {
         throw new Error('Invalid input utxo');
     }
     return changeAddress;
 };
 
 /*
  * Parse the total value of a send XEC tx and checks whether it is more than dust
  * One to many: isOneToMany is true, singleSendValue is null
  * One to one: isOneToMany is false, destinationAddressAndValueArray is null
  * Returns the aggregate send value in BigNumber format
  */
 export const parseXecSendValue = (
     isOneToMany,
     singleSendValue,
     destinationAddressAndValueArray,
 ) => {
     let value = new BigNumber(0);
 
     try {
         if (isOneToMany) {
             // this is a one to many XEC transaction
             if (
                 !destinationAddressAndValueArray ||
                 !destinationAddressAndValueArray.length
             ) {
                 throw new Error('Invalid destinationAddressAndValueArray');
             }
             const arrayLength = destinationAddressAndValueArray.length;
             for (let i = 0; i < arrayLength; i++) {
                 // add the total value being sent in this array of recipients
                 // each array row is: 'eCash address, send value'
                 value = BigNumber.sum(
                     value,
                     new BigNumber(
                         destinationAddressAndValueArray[i].split(',')[1],
                     ),
                 );
             }
         } else {
             // this is a one to one XEC transaction then check singleSendValue
             // note: one to many transactions won't be sending a singleSendValue param
 
             if (!singleSendValue) {
                 throw new Error('Invalid singleSendValue');
             }
 
             value = new BigNumber(singleSendValue);
         }
         // If user is attempting to send an aggregate value that is less than minimum accepted by the backend
         if (
             value.lt(
                 new BigNumber(fromSatoshisToXec(currency.dustSats).toString()),
             )
         ) {
             // Throw the same error given by the backend attempting to broadcast such a tx
             throw new Error('dust');
         }
     } catch (err) {
         console.log('Error in parseXecSendValue: ' + err);
         throw err;
     }
     return value;
 };
 
 /*
  * Generates an OP_RETURN script to reflect the various send XEC permutations
  * involving messaging, encryption, eToken IDs and airdrop flags.
  *
  * Returns the final encoded script object
  */
 export const generateOpReturnScript = (
     BCH,
     optionalOpReturnMsg,
     encryptionFlag,
     airdropFlag,
     airdropTokenId,
     encryptedEj,
 ) => {
     // encrypted mesage is mandatory when encryptionFlag is true
     // airdrop token id is mandatory when airdropFlag is true
     if (
         !BCH ||
         (encryptionFlag && !encryptedEj) ||
         (airdropFlag && !airdropTokenId)
     ) {
         throw new Error('Invalid OP RETURN script input');
     }
 
     // Note: script.push(Buffer.from(currency.opReturn.opReturnPrefixHex, 'hex')); actually evaluates to '016a'
     // instead of keeping the hex string intact. This behavour is specific to the initial script array element.
     // To get around this, the bch-js approach of directly using the opReturn prefix in decimal form for the initial entry is used here.
     let script = [currency.opReturn.opReturnPrefixDec]; // initialize script with the OP_RETURN op code (6a) in decimal form (106)
 
     try {
         if (encryptionFlag) {
             // if the user has opted to encrypt this message
 
             // add the encrypted cashtab messaging prefix and encrypted msg to script
             script.push(
                 Buffer.from(
                     currency.opReturn.appPrefixesHex.cashtabEncrypted,
                     'hex',
                 ), // 65746162
             );
 
             // add the encrypted message to script
             script.push(Buffer.from(encryptedEj));
         } else {
             // this is an un-encrypted message
 
             if (airdropFlag) {
                 // if this was routed from the airdrop component
                 // add the airdrop prefix to script
                 script.push(
                     Buffer.from(
                         currency.opReturn.appPrefixesHex.airdrop,
                         'hex',
                     ), // drop
                 );
                 // add the airdrop token ID to script
                 script.push(Buffer.from(airdropTokenId, 'hex'));
             }
 
             // add the cashtab prefix to script
             script.push(
                 Buffer.from(currency.opReturn.appPrefixesHex.cashtab, 'hex'), // 00746162
             );
 
             // add the un-encrypted message to script if supplied
             if (optionalOpReturnMsg) {
                 script.push(Buffer.from(optionalOpReturnMsg));
             }
         }
     } catch (err) {
         console.log('Error in generateOpReturnScript(): ' + err);
         throw err;
     }
 
     const data = BCH.Script.encode(script);
     return data;
 };
 
 export const generateTxOutput = (
     BCH,
     isOneToMany,
     singleSendValue,
     satoshisToSend,
     totalInputUtxoValue,
     destinationAddress,
     destinationAddressAndValueArray,
     changeAddress,
     txFee,
     txBuilder,
 ) => {
     try {
         if (
             !BCH ||
             (isOneToMany && !destinationAddressAndValueArray) ||
             (!isOneToMany && !destinationAddress && !singleSendValue) ||
             !changeAddress ||
             !satoshisToSend ||
             !totalInputUtxoValue ||
             !txFee ||
             !txBuilder
         ) {
             throw new Error('Invalid tx input parameter');
         }
 
         // amount to send back to the remainder address.
         const remainder = new BigNumber(totalInputUtxoValue)
             .minus(satoshisToSend)
             .minus(txFee);
         if (remainder.lt(0)) {
             throw new Error(`Insufficient funds`);
         }
 
         if (isOneToMany) {
             // for one to many mode, add the multiple outputs from the array
             let arrayLength = destinationAddressAndValueArray.length;
             for (let i = 0; i < arrayLength; i++) {
                 // add each send tx from the array as an output
                 let outputAddress =
                     destinationAddressAndValueArray[i].split(',')[0];
                 let outputValue = new BigNumber(
                     destinationAddressAndValueArray[i].split(',')[1],
                 );
                 txBuilder.addOutput(
                     BCH.Address.toCashAddress(outputAddress),
                     parseInt(fromXecToSatoshis(outputValue)),
                 );
             }
         } else {
             // for one to one mode, add output w/ single address and amount to send
             txBuilder.addOutput(
                 BCH.Address.toCashAddress(destinationAddress),
                 parseInt(fromXecToSatoshis(singleSendValue)),
             );
         }
 
         // if a remainder exists, return to change address as the final output
         if (remainder.gte(new BigNumber(currency.dustSats))) {
             txBuilder.addOutput(changeAddress, parseInt(remainder));
         }
     } catch (err) {
         console.log('Error in generateTxOutput(): ' + err);
         throw err;
     }
 
     return txBuilder;
 };
 
 export const signAndBuildTx = (BCH, inputUtxos, txBuilder, wallet) => {
     if (
         !BCH ||
         !inputUtxos ||
         inputUtxos.length === 0 ||
         !txBuilder ||
         !wallet ||
         // txBuilder.transaction.tx.ins is empty until the inputUtxos are signed
         txBuilder.transaction.tx.outs.length === 0
     ) {
         throw new Error('Invalid buildTx parameter');
     }
 
     // Sign each XEC UTXO being consumed and refresh transactionBuilder
     txBuilder = signUtxosByAddress(BCH, inputUtxos, wallet, txBuilder);
 
     let hex;
     try {
         // build tx
         const tx = txBuilder.build();
         // output rawhex
         hex = tx.toHex();
     } catch (err) {
         throw new Error('Transaction build failed');
     }
     return hex;
 };
 
 export function parseOpReturn(hexStr) {
     if (
         !hexStr ||
         typeof hexStr !== 'string' ||
         hexStr.substring(0, 2) !== currency.opReturn.opReturnPrefixHex
     ) {
         return false;
     }
 
     hexStr = hexStr.slice(2); // remove the first byte i.e. 6a
 
     /*
      * @Return: resultArray is structured as follows:
      *  resultArray[0] is the transaction type i.e. eToken prefix, cashtab prefix, external message itself if unrecognized prefix
      *  resultArray[1] is the actual cashtab message or the 2nd part of an external message
      *  resultArray[2 - n] are the additional messages for future protcols
      */
     let resultArray = [];
     let message = '';
     let hexStrLength = hexStr.length;
 
     for (let i = 0; hexStrLength !== 0; i++) {
         // part 1: check the preceding byte value for the subsequent message
         let byteValue = hexStr.substring(0, 2);
         let msgByteSize = 0;
         if (byteValue === currency.opReturn.opPushDataOne) {
             // if this byte is 4c then the next byte is the message byte size - retrieve the message byte size only
             msgByteSize = parseInt(hexStr.substring(2, 4), 16); // hex base 16 to decimal base 10
             hexStr = hexStr.slice(4); // strip the 4c + message byte size info
         } else {
             // take the byte as the message byte size
             msgByteSize = parseInt(hexStr.substring(0, 2), 16); // hex base 16 to decimal base 10
             hexStr = hexStr.slice(2); // strip the message byte size info
         }
 
         // part 2: parse the subsequent message based on bytesize
         const msgCharLength = 2 * msgByteSize;
         message = hexStr.substring(0, msgCharLength);
         if (i === 0 && message === currency.opReturn.appPrefixesHex.eToken) {
             // add the extracted eToken prefix to array then exit loop
             resultArray[i] = currency.opReturn.appPrefixesHex.eToken;
             break;
         } else if (
             i === 0 &&
             message === currency.opReturn.appPrefixesHex.cashtab
         ) {
             // add the extracted Cashtab prefix to array
             resultArray[i] = currency.opReturn.appPrefixesHex.cashtab;
         } else if (
             i === 0 &&
             message === currency.opReturn.appPrefixesHex.cashtabEncrypted
         ) {
             // add the Cashtab encryption prefix to array
             resultArray[i] = currency.opReturn.appPrefixesHex.cashtabEncrypted;
         } else if (
             i === 0 &&
             message === currency.opReturn.appPrefixesHex.airdrop
         ) {
             // add the airdrop prefix to array
             resultArray[i] = currency.opReturn.appPrefixesHex.airdrop;
         } else {
             // this is either an external message or a subsequent cashtab message loop to extract the message
             resultArray[i] = message;
         }
 
         // strip out the parsed message
         hexStr = hexStr.slice(msgCharLength);
         hexStrLength = hexStr.length;
     }
     return resultArray;
 }
 
 export const fromLegacyDecimals = (
     amount,
     cashDecimals = currency.cashDecimals,
 ) => {
     // Input 0.00000546 BCH
     // Output 5.46 XEC or 0.00000546 BCH, depending on currency.cashDecimals
     const amountBig = new BigNumber(amount);
     const conversionFactor = new BigNumber(10 ** (8 - cashDecimals));
     const amountSmallestDenomination = amountBig
         .times(conversionFactor)
         .toNumber();
     return amountSmallestDenomination;
 };
 
 export const fromSatoshisToXec = (
     amount,
     cashDecimals = currency.cashDecimals,
 ) => {
     const amountBig = new BigNumber(amount);
     const multiplier = new BigNumber(10 ** (-1 * cashDecimals));
     const amountInBaseUnits = amountBig.times(multiplier);
     return amountInBaseUnits;
 };
 
 export const fromXecToSatoshis = (
     sendAmount,
     cashDecimals = currency.cashDecimals,
 ) => {
     // Replace the BCH.toSatoshi method with an equivalent function that works for arbitrary decimal places
     // Example, for an 8 decimal place currency like Bitcoin
     // Input: a BigNumber of the amount of Bitcoin to be sent
     // Output: a BigNumber of the amount of satoshis to be sent, or false if input is invalid
 
     // Validate
     // Input should be a BigNumber with no more decimal places than cashDecimals
     const isValidSendAmount =
         BigNumber.isBigNumber(sendAmount) && sendAmount.dp() <= cashDecimals;
     if (!isValidSendAmount) {
         return false;
     }
     const conversionFactor = new BigNumber(10 ** cashDecimals);
     const sendAmountSmallestDenomination = sendAmount.times(conversionFactor);
     return sendAmountSmallestDenomination;
 };
 
 export const flattenContactList = contactList => {
     /*
     Converts contactList from array of objects of type {address: <valid XEC address>, name: <string>} to array of addresses only
 
     If contact list is invalid, returns and empty array
     */
     if (!isValidContactList(contactList)) {
         return [];
     }
     let flattenedContactList = [];
     for (let i = 0; i < contactList.length; i += 1) {
         const thisAddress = contactList[i].address;
         flattenedContactList.push(thisAddress);
     }
     return flattenedContactList;
 };
 
 export const loadStoredWallet = walletStateFromStorage => {
     // Accept cached tokens array that does not save BigNumber type of BigNumbers
     // Return array with BigNumbers converted
     // See BigNumber.js api for how to create a BigNumber object from an object
     // https://mikemcl.github.io/bignumber.js/
     const liveWalletState = walletStateFromStorage;
     const { slpBalancesAndUtxos, tokens } = liveWalletState;
     for (let i = 0; i < tokens.length; i += 1) {
         const thisTokenBalance = tokens[i].balance;
         thisTokenBalance._isBigNumber = true;
         tokens[i].balance = new BigNumber(thisTokenBalance);
     }
 
     // Also confirm balance is correct
     // Necessary step in case currency.decimals changed since last startup
     const balancesRebased = getWalletBalanceFromUtxos(
         slpBalancesAndUtxos.nonSlpUtxos,
     );
     liveWalletState.balances = balancesRebased;
     return liveWalletState;
 };
 
 export const getWalletBalanceFromUtxos = nonSlpUtxos => {
     const totalBalanceInSatoshis = nonSlpUtxos.reduce(
         (previousBalance, utxo) =>
             previousBalance.plus(new BigNumber(utxo.value)),
         new BigNumber(0),
     );
     return {
         totalBalanceInSatoshis: totalBalanceInSatoshis.toString(),
         totalBalance: fromSatoshisToXec(totalBalanceInSatoshis).toString(),
     };
 };
 
 export const isValidStoredWallet = walletStateFromStorage => {
     return (
         typeof walletStateFromStorage === 'object' &&
         'state' in walletStateFromStorage &&
         typeof walletStateFromStorage.state === 'object' &&
         'balances' in walletStateFromStorage.state &&
         'utxos' in walletStateFromStorage.state &&
         !('hydratedUtxoDetails' in walletStateFromStorage.state) &&
         'slpBalancesAndUtxos' in walletStateFromStorage.state &&
         'tokens' in walletStateFromStorage.state
     );
 };
 
 export const getWalletState = wallet => {
     if (!wallet || !wallet.state) {
         return {
             balances: { totalBalance: 0, totalBalanceInSatoshis: 0 },
             hydratedUtxoDetails: {},
             tokens: [],
             slpBalancesAndUtxos: {},
             parsedTxHistory: [],
             utxos: [],
         };
     }
 
     return wallet.state;
 };
 
 export function convertEtokenToEcashAddr(eTokenAddress) {
     if (!eTokenAddress) {
         return new Error(
             `cashMethods.convertToEcashAddr() error: No etoken address provided`,
         );
     }
 
     // Confirm input is a valid eToken address
     const isValidInput = isValidEtokenAddress(eTokenAddress);
     if (!isValidInput) {
         return new Error(
             `cashMethods.convertToEcashAddr() error: ${eTokenAddress} is not a valid etoken address`,
         );
     }
 
     // Check for etoken: prefix
     const isPrefixedEtokenAddress = eTokenAddress.slice(0, 7) === 'etoken:';
 
     // If no prefix, assume it is checksummed for an etoken: prefix
     const testedEtokenAddr = isPrefixedEtokenAddress
         ? eTokenAddress
         : `etoken:${eTokenAddress}`;
 
     let ecashAddress;
     try {
         const { type, hash } = cashaddr.decode(testedEtokenAddr);
         ecashAddress = cashaddr.encode('ecash', type, hash);
     } catch (err) {
         return err;
     }
 
     return ecashAddress;
 }
 
 export function convertToEcashPrefix(bitcoincashPrefixedAddress) {
     // 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 = bitcoincashPrefixedAddress.includes(':');
     if (hasPrefix) {
         // Is it bitcoincash: or simpleledger:
         const { type, hash, prefix } = cashaddr.decode(
             bitcoincashPrefixedAddress,
         );
 
         let newPrefix;
         if (prefix === 'bitcoincash') {
             newPrefix = 'ecash';
         } else if (prefix === 'simpleledger') {
             newPrefix = 'etoken';
         } else {
             return bitcoincashPrefixedAddress;
         }
 
         const convertedAddress = cashaddr.encode(newPrefix, type, hash);
 
         return convertedAddress;
     } else {
         return bitcoincashPrefixedAddress;
     }
 }
 
 export function convertEcashtoEtokenAddr(eCashAddress) {
     const isValidInput = isValidXecAddress(eCashAddress);
     if (!isValidInput) {
         return new Error(`${eCashAddress} is not a valid ecash address`);
     }
 
     // Check for ecash: prefix
     const isPrefixedEcashAddress = eCashAddress.slice(0, 6) === 'ecash:';
 
     // If no prefix, assume it is checksummed for an ecash: prefix
     const testedEcashAddr = isPrefixedEcashAddress
         ? eCashAddress
         : `ecash:${eCashAddress}`;
 
     let eTokenAddress;
     try {
         const { type, hash } = cashaddr.decode(testedEcashAddr);
         eTokenAddress = cashaddr.encode('etoken', type, hash);
     } catch (err) {
         return new Error('eCash to eToken address conversion error');
     }
     return eTokenAddress;
 }
 
 export function toLegacyCash(addr) {
     // Confirm input is a valid ecash address
     const isValidInput = isValidXecAddress(addr);
     if (!isValidInput) {
         return new Error(`${addr} is not a valid ecash address`);
     }
 
     // Check for ecash: prefix
     const isPrefixedXecAddress = addr.slice(0, 6) === 'ecash:';
 
     // If no prefix, assume it is checksummed for an ecash: prefix
     const testedXecAddr = isPrefixedXecAddress ? addr : `ecash:${addr}`;
 
     let legacyCashAddress;
     try {
         const { type, hash } = cashaddr.decode(testedXecAddr);
         legacyCashAddress = cashaddr.encode(currency.legacyPrefix, type, hash);
     } catch (err) {
         return err;
     }
     return legacyCashAddress;
 }
 
 export function toLegacyCashArray(addressArray) {
     let cleanArray = []; // array of bch converted addresses to be returned
 
     if (
         addressArray === null ||
         addressArray === undefined ||
         !addressArray.length ||
         addressArray === ''
     ) {
         return new Error('Invalid addressArray input');
     }
 
     const arrayLength = addressArray.length;
 
     for (let i = 0; i < arrayLength; i++) {
         let addressValueArr = addressArray[i].split(',');
         let address = addressValueArr[0];
         let value = addressValueArr[1];
 
         // NB that toLegacyCash() includes address validation; will throw error for invalid address input
         const legacyAddress = toLegacyCash(address);
         if (legacyAddress instanceof Error) {
             return legacyAddress;
         }
         let convertedArrayData = legacyAddress + ',' + value + '\n';
         cleanArray.push(convertedArrayData);
     }
 
     return cleanArray;
 }
 
 export function toLegacyToken(addr) {
     // Confirm input is a valid ecash address
     const isValidInput = isValidEtokenAddress(addr);
     if (!isValidInput) {
         return new Error(`${addr} is not a valid etoken address`);
     }
 
     // Check for ecash: prefix
     const isPrefixedEtokenAddress = addr.slice(0, 7) === 'etoken:';
 
     // If no prefix, assume it is checksummed for an ecash: prefix
     const testedEtokenAddr = isPrefixedEtokenAddress ? addr : `etoken:${addr}`;
 
     let legacyTokenAddress;
     try {
         const { type, hash } = cashaddr.decode(testedEtokenAddr);
         legacyTokenAddress = cashaddr.encode('simpleledger', type, hash);
     } catch (err) {
         return err;
     }
     return legacyTokenAddress;
 }
 
 /* Converts a serialized buffer containing encrypted data into an object
  * that can be interpreted by the ecies-lite library.
  *
  * For reference on the parsing logic in this function refer to the link below on the segment of
  * ecies-lite's encryption function where the encKey, macKey, iv and cipher are sliced and concatenated
  * https://github.com/tibetty/ecies-lite/blob/8fd97e80b443422269d0223ead55802378521679/index.js#L46-L55
  *
  * A similar PSF implmentation can also be found at:
  * https://github.com/Permissionless-Software-Foundation/bch-encrypt-lib/blob/master/lib/encryption.js
  *
  * For more detailed overview on the ecies encryption scheme, see https://cryptobook.nakov.com/asymmetric-key-ciphers/ecies-public-key-encryption
  */
 export const convertToEncryptStruct = encryptionBuffer => {
     // based on ecies-lite's encryption logic, the encryption buffer is concatenated as follows:
     //  [ epk + iv + ct + mac ]  whereby:
     // - The first 32 or 64 chars of the encryptionBuffer is the epk
     // - Both iv and ct params are 16 chars each, hence their combined substring is 32 chars from the end of the epk string
     //    - within this combined iv/ct substring, the first 16 chars is the iv param, and ct param being the later half
     // - The mac param is appended to the end of the encryption buffer
 
     // validate input buffer
     if (!encryptionBuffer) {
         throw new Error(
             'cashmethods.convertToEncryptStruct() error: input must be a buffer',
         );
     }
 
     try {
         // variable tracking the starting char position for string extraction purposes
         let startOfBuf = 0;
 
         // *** epk param extraction ***
         // The first char of the encryptionBuffer indicates the type of the public key
         // If the first char is 4, then the public key is 64 chars
         // If the first char is 3 or 2, then the public key is 32 chars
         // Otherwise this is not a valid encryption buffer compatible with the ecies-lite library
         let publicKey;
         switch (encryptionBuffer[0]) {
             case 4:
                 publicKey = encryptionBuffer.slice(0, 65); //  extract first 64 chars as public key
                 break;
             case 3:
             case 2:
                 publicKey = encryptionBuffer.slice(0, 33); //  extract first 32 chars as public key
                 break;
             default:
                 throw new Error(`Invalid type: ${encryptionBuffer[0]}`);
         }
 
         // *** iv and ct param extraction ***
         startOfBuf += publicKey.length; // sets the starting char position to the end of the public key (epk) in order to extract subsequent iv and ct substrings
         const encryptionTagLength = 32; // the length of the encryption tag (i.e. mac param) computed from each block of ciphertext, and is used to verify no one has tampered with the encrypted data
         const ivCtSubstring = encryptionBuffer.slice(
             startOfBuf,
             encryptionBuffer.length - encryptionTagLength,
         ); // extract the substring containing both iv and ct params, which is after the public key but before the mac param i.e. the 'encryption tag'
         const ivbufParam = ivCtSubstring.slice(0, 16); // extract the first 16 chars of substring as the iv param
         const ctbufParam = ivCtSubstring.slice(16); // extract the last 16 chars as substring the ct param
 
         // *** mac param extraction ***
         const macParam = encryptionBuffer.slice(
             encryptionBuffer.length - encryptionTagLength,
             encryptionBuffer.length,
         ); // extract the mac param appended to the end of the buffer
 
         return {
             iv: ivbufParam,
             epk: publicKey,
             ct: ctbufParam,
             mac: macParam,
         };
     } catch (err) {
         console.error(`useBCH.convertToEncryptStruct() error: `, err);
         throw err;
     }
 };
 
 export const getPublicKey = async (BCH, address) => {
     try {
         const publicKey = await BCH.encryption.getPubKey(address);
         return publicKey.publicKey;
     } catch (err) {
         if (err['error'] === 'No transaction history.') {
             throw new Error(
                 'Cannot send an encrypted message to a wallet with no outgoing transactions',
             );
         } else {
             throw err;
         }
     }
 };
 
 export const isLegacyMigrationRequired = wallet => {
     // If the wallet does not have Path1899,
     // Or each Path1899, Path145, Path245 does not have a public key
     // Then it requires migration
     if (
         !wallet.Path1899 ||
         !wallet.Path1899.publicKey ||
         !wallet.Path1899.hash160 ||
         !wallet.Path145.publicKey ||
         !wallet.Path145.hash160 ||
         !wallet.Path245.publicKey ||
         !wallet.Path245.hash160
     ) {
         return true;
     }
 
     return false;
 };
 
 export const getHashArrayFromWallet = wallet => {
     // If the wallet has wallet.Path1899.hash160, it's migrated and will have all of them
     // Return false for an umigrated wallet
     const hash160Array =
         wallet && wallet.Path1899 && 'hash160' in wallet.Path1899
             ? [
                   wallet.Path245.hash160,
                   wallet.Path145.hash160,
                   wallet.Path1899.hash160,
               ]
             : false;
     return hash160Array;
 };
 
-export const checkWalletForTokenInfo = (tokenId, wallet) => {
-    /* 
-    Check wallet for cached information about a given tokenId
-    Return {decimals: tokenDecimals, name: tokenName, ticker: tokenTicker}
-    If this tokenId does not exist in wallet, return false
-    */
-    try {
-        const { tokens } = wallet.state;
-        for (let i = 0; i < tokens.length; i += 1) {
-            const thisTokenId = tokens[i].tokenId;
-            if (tokenId === thisTokenId) {
-                return {
-                    decimals: tokens[i].info.decimals,
-                    ticker: tokens[i].info.tokenTicker,
-                    name: tokens[i].info.tokenName,
-                };
-            }
-        }
-    } catch (err) {
-        return false;
-    }
-
-    return false;
-};
-
 export const isActiveWebsocket = ws => {
     // Return true if websocket is connected and subscribed
     // Otherwise return false
     return (
         ws !== null &&
         ws &&
         '_ws' in ws &&
         'readyState' in ws._ws &&
         ws._ws.readyState === 1 &&
         '_subs' in ws &&
         ws._subs.length > 0
     );
 };
diff --git a/web/cashtab/src/utils/chronik.js b/web/cashtab/src/utils/chronik.js
index 1c3260bef..222dcd812 100644
--- a/web/cashtab/src/utils/chronik.js
+++ b/web/cashtab/src/utils/chronik.js
@@ -1,810 +1,816 @@
 // Chronik methods
 import BigNumber from 'bignumber.js';
 import { currency } from 'components/Common/Ticker';
 import {
     parseOpReturn,
     convertToEncryptStruct,
     getHashArrayFromWallet,
     getUtxoWif,
 } from 'utils/cashMethods';
 import ecies from 'ecies-lite';
 import wif from 'wif';
 import cashaddr from 'ecashaddrjs';
 
 // Return false if do not get a valid response
 export const getTokenStats = async (chronik, tokenId) => {
     try {
         // token attributes available via chronik's token() method
         let tokenResponseObj = await chronik.token(tokenId);
         const tokenDecimals = tokenResponseObj.slpTxData.genesisInfo.decimals;
 
         // additional arithmetic to account for token decimals
         // circulating supply not provided by chronik, calculate via totalMinted - totalBurned
         tokenResponseObj.circulatingSupply = new BigNumber(
             tokenResponseObj.tokenStats.totalMinted,
         )
             .minus(new BigNumber(tokenResponseObj.tokenStats.totalBurned))
             .shiftedBy(-1 * tokenDecimals)
             .toString();
 
         tokenResponseObj.tokenStats.totalMinted = new BigNumber(
             tokenResponseObj.tokenStats.totalMinted,
         )
             .shiftedBy(-1 * tokenDecimals)
             .toString();
 
         tokenResponseObj.initialTokenQuantity = new BigNumber(
             tokenResponseObj.initialTokenQuantity,
         )
             .shiftedBy(-1 * tokenDecimals)
             .toString();
 
         tokenResponseObj.tokenStats.totalBurned = new BigNumber(
             tokenResponseObj.tokenStats.totalBurned,
         )
             .shiftedBy(-1 * tokenDecimals)
             .toString();
 
         return tokenResponseObj;
     } catch (err) {
         console.log(
             `Error fetching token stats for tokenId ${tokenId}: ` + err,
         );
         return false;
     }
 };
 
 /* 
 Note: chronik.script('p2pkh', hash160).utxos(); is not readily mockable in jest
 Hence it is necessary to keep this out of any functions that require unit testing
 */
 export const getUtxosSingleHashChronik = async (chronik, hash160) => {
     // Get utxos at a single address, which chronik takes in as a hash160
     let utxos;
     try {
         utxos = await chronik.script('p2pkh', hash160).utxos();
         if (utxos.length === 0) {
             // Chronik returns an empty array if there are no utxos at this hash160
             return [];
         }
         /* Chronik returns an array of with a single object if there are utxos at this hash 160
         [
             {
                 outputScript: <hash160>,
                 utxos:[{utxo}, {utxo}, ..., {utxo}]
             }
         ]
         */
 
         // Return only the array of utxos at this address
         return utxos[0].utxos;
     } catch (err) {
         console.log(`Error in chronik.utxos(${hash160})`, err);
     }
 };
 
 export const returnGetUtxosChronikPromise = (chronik, hash160AndAddressObj) => {
     /*
         Chronik thinks in hash160s, but people and wallets think in addresses
         Add the address to each utxo
     */
     return new Promise((resolve, reject) => {
         getUtxosSingleHashChronik(chronik, hash160AndAddressObj.hash160).then(
             result => {
                 for (let i = 0; i < result.length; i += 1) {
                     const thisUtxo = result[i];
                     thisUtxo.address = hash160AndAddressObj.address;
                 }
                 resolve(result);
             },
             err => {
                 reject(err);
             },
         );
     });
 };
 
 export const getUtxosChronik = async (chronik, hash160sMappedToAddresses) => {
     /* 
         Chronik only accepts utxo requests for one address at a time
         Construct an array of promises for each address
         Note: Chronik requires the hash160 of an address for this request
     */
     const chronikUtxoPromises = [];
     for (let i = 0; i < hash160sMappedToAddresses.length; i += 1) {
         const thisPromise = returnGetUtxosChronikPromise(
             chronik,
             hash160sMappedToAddresses[i],
         );
         chronikUtxoPromises.push(thisPromise);
     }
     const allUtxos = await Promise.all(chronikUtxoPromises);
     // Since each individual utxo has address information, no need to keep them in distinct arrays
     // Combine into one array of all utxos
     const flatUtxos = allUtxos.flat();
     return flatUtxos;
 };
 
 export const organizeUtxosByType = chronikUtxos => {
     /* 
     
     Convert chronik utxos (returned by getUtxosChronik function, above) to match 
     shape of existing slpBalancesAndUtxos object
     
     This means sequestering eToken utxos from non-eToken utxos
 
     For legacy reasons, the term "SLP" is still sometimes used to describe an eToken
 
     So, SLP utxos === eToken utxos, it's just a semantics difference here
     
     */
 
     const nonSlpUtxos = [];
     const preliminarySlpUtxos = [];
     for (let i = 0; i < chronikUtxos.length; i += 1) {
         // Construct nonSlpUtxos and slpUtxos arrays
         const thisUtxo = chronikUtxos[i];
         if (typeof thisUtxo.slpToken !== 'undefined') {
             preliminarySlpUtxos.push(thisUtxo);
         } else {
             nonSlpUtxos.push(thisUtxo);
         }
     }
 
     return { preliminarySlpUtxos, nonSlpUtxos };
 };
 
 export const getPreliminaryTokensArray = preliminarySlpUtxos => {
     // Iterate over the slpUtxos to create the 'tokens' object
     let tokensById = {};
 
     preliminarySlpUtxos.forEach(preliminarySlpUtxo => {
         /* 
         Note that a wallet could have many eToken utxos all belonging to the same eToken
         For example, a user could have 100 of a certain eToken, but this is composed of
         four utxos, one for 17, one for 50, one for 30, one for 3        
         */
 
         // Start with the existing object for this particular token, if it exists
         let token = tokensById[preliminarySlpUtxo.slpMeta.tokenId];
 
         if (token) {
             if (preliminarySlpUtxo.slpToken.amount) {
                 token.balance = token.balance.plus(
                     new BigNumber(preliminarySlpUtxo.slpToken.amount),
                 );
             }
         } else {
             // If it does not exist, create it
             token = {};
             token.tokenId = preliminarySlpUtxo.slpMeta.tokenId;
             if (preliminarySlpUtxo.slpToken.amount) {
                 token.balance = new BigNumber(
                     preliminarySlpUtxo.slpToken.amount,
                 );
             } else {
                 token.balance = new BigNumber(0);
             }
             tokensById[preliminarySlpUtxo.slpMeta.tokenId] = token;
         }
     });
 
     const preliminaryTokensArray = Object.values(tokensById);
     return preliminaryTokensArray;
 };
 
 const returnGetTokenInfoChronikPromise = (chronik, tokenId) => {
     /*
     The chronik.tx(txid) API call returns extensive transaction information
     For the purposes of finalizing token information, we only need the token metadata
 
     This function returns a promise that extracts only this needed information from
     the chronik.tx(txid) API call
 
     In this way, calling Promise.all() on an array of tokenIds that lack metadata
     will return an array with all required metadata
     */
     return new Promise((resolve, reject) => {
         chronik.tx(tokenId).then(
             result => {
                 const thisTokenInfo = result.slpTxData.genesisInfo;
                 thisTokenInfo.tokenId = tokenId;
                 // You only want the genesis info for tokenId
                 resolve(thisTokenInfo);
             },
             err => {
                 reject(err);
             },
         );
     });
 };
 
 export const processPreliminaryTokensArray = (
     preliminaryTokensArray,
     tokenInfoByTokenId,
 ) => {
     /* Iterate over preliminaryTokensArray to
 
     1 - Add slp metadata (token ticker, name, other metadata)
     2 - Calculate the token balance. Token balance in 
         preliminaryTokensArray does not take into account the
         decimal places of the token...so it is incorrect.
 
     */
     const finalTokenArray = [];
     for (let i = 0; i < preliminaryTokensArray.length; i += 1) {
         const thisToken = preliminaryTokensArray[i];
         const thisTokenId = thisToken.tokenId;
 
         // Because tokenInfoByTokenId is indexed by tokenId, it's easy to reference
         const thisTokenInfo = tokenInfoByTokenId[thisTokenId];
 
         // The decimals are specifically needed to calculate the correct balance
         const thisTokenDecimals = thisTokenInfo.decimals;
 
         // Add info object to token
         thisToken.info = thisTokenInfo;
 
         // Update balance according to decimals
         thisToken.balance = thisToken.balance.shiftedBy(-1 * thisTokenDecimals);
 
         // Now that you have the metadata and the correct balance,
         // preliminaryTokenInfo is finalTokenInfo
         finalTokenArray.push(thisToken);
     }
     return finalTokenArray;
 };
 
 export const finalizeTokensArray = async (
     chronik,
     preliminaryTokensArray,
     cachedTokenInfoById = {},
 ) => {
     // Iterate over preliminaryTokensArray to determine what tokens you need to make API calls for
 
     // Create an array of promises
     // Each promise is a chronik API call to obtain token metadata for this token ID
     const getTokenInfoPromises = [];
 
     for (let i = 0; i < preliminaryTokensArray.length; i += 1) {
         const thisTokenId = preliminaryTokensArray[i].tokenId;
         // See if you already have this info in cachedTokenInfo
         if (thisTokenId in cachedTokenInfoById) {
             // If you already have this info in cache, do not create an API request for it
             continue;
         }
         const thisTokenInfoPromise = returnGetTokenInfoChronikPromise(
             chronik,
             thisTokenId,
         );
         getTokenInfoPromises.push(thisTokenInfoPromise);
     }
 
     const newTokensToCache = getTokenInfoPromises.length > 0;
 
     // Get all the token info you need
     let tokenInfoArray = [];
     try {
         tokenInfoArray = await Promise.all(getTokenInfoPromises);
     } catch (err) {
         console.log(`Error in Promise.all(getTokenInfoPromises)`, err);
     }
 
     // Add the token info you received from those API calls to
     // your token info cache object, cachedTokenInfoByTokenId
 
     const updatedTokenInfoById = cachedTokenInfoById;
     for (let i = 0; i < tokenInfoArray.length; i += 1) {
         /* tokenInfoArray is an array of objects that look like
         {
             "tokenTicker": "ST",
             "tokenName": "ST",
             "tokenDocumentUrl": "developer.bitcoin.com",
             "tokenDocumentHash": "",
             "decimals": 0,
             "tokenId": "bf24d955f59351e738ecd905966606a6837e478e1982943d724eab10caad82fd"
         }
         */
 
         const thisTokenInfo = tokenInfoArray[i];
         const thisTokenId = thisTokenInfo.tokenId;
         // Add this entry to updatedTokenInfoById
         updatedTokenInfoById[thisTokenId] = thisTokenInfo;
     }
 
     // Now use cachedTokenInfoByTokenId object to finalize token info
     // Split this out into a separate function so you can unit test
     const finalTokenArray = processPreliminaryTokensArray(
         preliminaryTokensArray,
         updatedTokenInfoById,
     );
 
     return { finalTokenArray, updatedTokenInfoById, newTokensToCache };
 };
 
 export const finalizeSlpUtxos = (preliminarySlpUtxos, tokenInfoById) => {
     // We need tokenQty in each slpUtxo to support transaction creation
     // Add this info here
     const finalizedSlpUtxos = [];
     for (let i = 0; i < preliminarySlpUtxos.length; i += 1) {
         const thisUtxo = preliminarySlpUtxos[i];
         const thisTokenId = thisUtxo.slpMeta.tokenId;
         const { decimals } = tokenInfoById[thisTokenId];
         // Update balance according to decimals
         thisUtxo.tokenQty = new BigNumber(thisUtxo.slpToken.amount)
             .shiftedBy(-1 * decimals)
             .toString();
         // SLP utxos also require tokenId and decimals directly in the utxo object
         // This is bad organization but necessary until bch-js is refactored
         // https://github.com/Permissionless-Software-Foundation/bch-js/blob/master/src/slp/tokentype1.js#L217
         thisUtxo.tokenId = thisTokenId;
         thisUtxo.decimals = decimals;
         finalizedSlpUtxos.push(thisUtxo);
     }
     return finalizedSlpUtxos;
 };
 
 export const flattenChronikTxHistory = txHistoryOfAllAddresses => {
     // Create an array of all txs
 
     let flatTxHistoryArray = [];
     for (let i = 0; i < txHistoryOfAllAddresses.length; i += 1) {
         const txHistoryResponseOfThisAddress = txHistoryOfAllAddresses[i];
         const txHistoryOfThisAddress = txHistoryResponseOfThisAddress.txs;
         flatTxHistoryArray = flatTxHistoryArray.concat(txHistoryOfThisAddress);
     }
     return flatTxHistoryArray;
 };
 
 export const sortAndTrimChronikTxHistory = (
     flatTxHistoryArray,
     txHistoryCount,
 ) => {
     // Isolate unconfirmed txs
     // In chronik, unconfirmed txs have an `undefined` block key
     const unconfirmedTxs = [];
     const confirmedTxs = [];
     for (let i = 0; i < flatTxHistoryArray.length; i += 1) {
         const thisTx = flatTxHistoryArray[i];
         if (typeof thisTx.block === 'undefined') {
             unconfirmedTxs.push(thisTx);
         } else {
             confirmedTxs.push(thisTx);
         }
     }
     console.log(`confirmed txs`, confirmedTxs);
     console.log(`unconfirmed txs`, unconfirmedTxs);
     // Sort confirmed txs by blockheight, and then timeFirstSeen
     const sortedConfirmedTxHistoryArray = confirmedTxs.sort(
         (a, b) =>
             // We want more recent blocks i.e. higher blockheights to have earlier array indices
             b.block.height - a.block.height ||
             // For blocks with the same height, we want more recent timeFirstSeen i.e. higher timeFirstSeen to have earlier array indices
             b.timeFirstSeen - a.timeFirstSeen,
     );
     // Sort unconfirmed txs by timeFirstSeen
     const sortedUnconfirmedTxHistoryArray = unconfirmedTxs.sort(
         (a, b) => b.timeFirstSeen - a.timeFirstSeen,
     );
     // The unconfirmed txs are more recent, so they should be inserted into an array before the confirmed txs
     const sortedChronikTxHistoryArray = sortedUnconfirmedTxHistoryArray.concat(
         sortedConfirmedTxHistoryArray,
     );
 
     const trimmedAndSortedChronikTxHistoryArray =
         sortedChronikTxHistoryArray.splice(0, txHistoryCount);
 
     return trimmedAndSortedChronikTxHistoryArray;
 };
 
 export const returnGetTxHistoryChronikPromise = (
     chronik,
     hash160AndAddressObj,
 ) => {
     /*
         Chronik thinks in hash160s, but people and wallets think in addresses
         Add the address to each utxo
     */
     return new Promise((resolve, reject) => {
         chronik
             .script('p2pkh', hash160AndAddressObj.hash160)
             .history(/*page=*/ 0, /*page_size=*/ currency.txHistoryCount)
             .then(
                 result => {
                     console.log(
                         `result for ${hash160AndAddressObj.hash160}`,
                         result,
                     );
                     resolve(result);
                 },
                 err => {
                     reject(err);
                 },
             );
     });
 };
 
 export const parseChronikTx = (BCH, tx, wallet, tokenInfoById) => {
     const walletHash160s = getHashArrayFromWallet(wallet);
     const { inputs, outputs } = tx;
     // Assign defaults
     let incoming = true;
     let xecAmount = new BigNumber(0);
     let originatingHash160 = '';
     let etokenAmount = new BigNumber(0);
     const isEtokenTx = 'slpTxData' in tx && typeof tx.slpTxData !== 'undefined';
     const isGenesisTx =
         isEtokenTx &&
         tx.slpTxData.slpMeta &&
         tx.slpTxData.slpMeta.txType &&
         tx.slpTxData.slpMeta.txType === 'GENESIS';
     if (isGenesisTx) {
         console.log(`${tx.txid} isGenesisTx`);
     }
 
     // Defining variables used in lines legacy parseTxData function from useBCH.js
     let substring = '';
     let airdropFlag = false;
     let airdropTokenId = '';
     let opReturnMessage = '';
     let isCashtabMessage = false;
     let isEncryptedMessage = false;
     let decryptionSuccess = false;
     let replyAddress = '';
 
     // Iterate over inputs to see if this is an incoming tx (incoming === true)
     for (let i = 0; i < inputs.length; i += 1) {
         const thisInput = inputs[i];
         const thisInputSendingHash160 = thisInput.outputScript;
         /* 
         
         Assume the first input is the originating address
         
         https://en.bitcoin.it/wiki/Script for reference
         
         Assume standard pay-to-pubkey-hash tx        
         scriptPubKey: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
         76 + a9 + 14 = OP_DUP + OP_HASH160 + 14 Bytes to push
         88 + ac = OP_EQUALVERIFY + OP_CHECKSIG
 
         So, the hash160 we want will be in between '76a914' and '88ac'
         ...most of the time ;)
         */
         try {
             originatingHash160 = thisInputSendingHash160.substring(
                 thisInputSendingHash160.indexOf('76a914') + '76a914'.length,
                 thisInputSendingHash160.lastIndexOf('88ac'),
             );
 
             let replyAddressBchFormat =
                 BCH.Address.hash160ToCash(originatingHash160);
 
             const { type, hash } = cashaddr.decode(replyAddressBchFormat);
             replyAddress = cashaddr.encode('ecash', type, hash);
             console.log(`replyAddressXecFormat`, replyAddress);
         } catch (err) {
             console.log(`err from ${originatingHash160}`, err);
             // If the transaction is nonstandard, don't worry about a reply address for now
             originatingHash160 = 'N/A';
         }
         for (let j = 0; j < walletHash160s.length; j += 1) {
             const thisWalletHash160 = walletHash160s[j];
             if (thisInputSendingHash160.includes(thisWalletHash160)) {
                 // Then this is an outgoing tx
                 incoming = false;
                 // Break out of this for loop once you know this is an incoming tx
                 break;
             }
         }
     }
     // Iterate over outputs to get the amount sent
     for (let i = 0; i < outputs.length; i += 1) {
         const thisOutput = outputs[i];
         const thisOutputReceivedAtHash160 = thisOutput.outputScript;
         // Check for OP_RETURN msg
         if (
             thisOutput.value === '0' &&
             typeof thisOutput.slpToken === 'undefined'
         ) {
             let hex = thisOutputReceivedAtHash160;
             let parsedOpReturnArray = parseOpReturn(hex);
 
             // Exactly copying lines 177-293 of useBCH.js
             // Differences
             // 1 - patched ecies not async error
             // 2 - Removed if loop for tx being token, as this is handled elsewhere here
             if (!parsedOpReturnArray) {
                 console.log(
                     'useBCH.parsedTxData() error: parsed array is empty',
                 );
                 break;
             }
 
             let message = '';
             let txType = parsedOpReturnArray[0];
 
             if (txType === currency.opReturn.appPrefixesHex.airdrop) {
                 // this is to facilitate special Cashtab-specific cases of airdrop txs, both with and without msgs
                 // The UI via Tx.js can check this airdropFlag attribute in the parsedTx object to conditionally render airdrop-specific formatting if it's true
                 airdropFlag = true;
                 // index 0 is drop prefix, 1 is the token Id, 2 is msg prefix, 3 is msg
                 airdropTokenId = parsedOpReturnArray[1];
                 txType = parsedOpReturnArray[2];
 
                 // remove the first two elements of airdrop prefix and token id from array so the array parsing logic below can remain unchanged
                 parsedOpReturnArray.splice(0, 2);
                 // index 0 now becomes msg prefix, 1 becomes the msg
             }
 
             if (txType === currency.opReturn.appPrefixesHex.cashtab) {
                 // this is a Cashtab message
                 try {
                     opReturnMessage = Buffer.from(
                         parsedOpReturnArray[1],
                         'hex',
                     );
                     isCashtabMessage = true;
                 } catch (err) {
                     // soft error if an unexpected or invalid cashtab hex is encountered
                     opReturnMessage = '';
                     console.log(
                         'useBCH.parsedTxData() error: invalid cashtab msg hex: ' +
                             parsedOpReturnArray[1],
                     );
                 }
             } else if (
                 txType === currency.opReturn.appPrefixesHex.cashtabEncrypted
             ) {
                 // this is an encrypted Cashtab message
                 let msgString = parsedOpReturnArray[1];
                 let fundingWif, privateKeyObj, privateKeyBuff;
                 if (
                     wallet &&
                     wallet.state &&
                     wallet.state.slpBalancesAndUtxos &&
                     wallet.state.slpBalancesAndUtxos.nonSlpUtxos[0]
                 ) {
                     fundingWif = getUtxoWif(
                         wallet.state.slpBalancesAndUtxos.nonSlpUtxos[0],
                         wallet,
                     );
                     privateKeyObj = wif.decode(fundingWif);
                     privateKeyBuff = privateKeyObj.privateKey;
                     if (!privateKeyBuff) {
                         throw new Error('Private key extraction error');
                     }
                 } else {
                     break;
                 }
 
                 let structData;
                 let decryptedMessage;
 
                 try {
                     // Convert the hex encoded message to a buffer
                     const msgBuf = Buffer.from(msgString, 'hex');
 
                     // Convert the bufer into a structured object.
                     structData = convertToEncryptStruct(msgBuf);
 
                     decryptedMessage = ecies.decrypt(
                         privateKeyBuff,
                         structData,
                     );
                     decryptionSuccess = true;
                 } catch (err) {
                     console.log(
                         'useBCH.parsedTxData() decryption error: ' + err,
                     );
                     decryptedMessage =
                         'Only the message recipient can view this';
                 }
                 isCashtabMessage = true;
                 isEncryptedMessage = true;
                 opReturnMessage = decryptedMessage;
             } else {
                 // this is an externally generated message
                 message = txType; // index 0 is the message content in this instance
 
                 // if there are more than one part to the external message
                 const arrayLength = parsedOpReturnArray.length;
                 for (let i = 1; i < arrayLength; i++) {
                     message = message + parsedOpReturnArray[i];
                 }
 
                 try {
                     opReturnMessage = Buffer.from(message, 'hex');
                 } catch (err) {
                     // soft error if an unexpected or invalid cashtab hex is encountered
                     opReturnMessage = '';
                     console.log(
                         'useBCH.parsedTxData() error: invalid external msg hex: ' +
                             substring,
                     );
                 }
             }
         }
         // Find amounts at your wallet's addresses
         for (let j = 0; j < walletHash160s.length; j += 1) {
             const thisWalletHash160 = walletHash160s[j];
             if (thisOutputReceivedAtHash160.includes(thisWalletHash160)) {
                 // If incoming tx, this is amount received by the user's wallet
                 // if outgoing tx (incoming === false), then this is a change amount
                 const thisOutputAmount = new BigNumber(thisOutput.value);
                 xecAmount = incoming
                     ? xecAmount.plus(thisOutputAmount)
                     : xecAmount.minus(thisOutputAmount);
 
                 // Parse token qty if token tx
                 // Note: edge case this is a token tx that sends XEC to Cashtab recipient but token somewhere else
                 if (isEtokenTx) {
                     try {
                         const thisEtokenAmount = new BigNumber(
                             thisOutput.slpToken.amount,
                         );
 
                         etokenAmount =
                             incoming || isGenesisTx
                                 ? etokenAmount.plus(thisEtokenAmount)
                                 : etokenAmount.minus(thisEtokenAmount);
                     } catch (err) {
                         // edge case described above; in this case there is zero eToken value for this Cashtab recipient, so add 0
                         etokenAmount.plus(new BigNumber(0));
                     }
                 }
             }
         }
         // Output amounts not at your wallet are sent amounts if !incoming
         // Exception for eToken genesis transactions
         if (!incoming) {
             const thisOutputAmount = new BigNumber(thisOutput.value);
             xecAmount = xecAmount.plus(thisOutputAmount);
             if (isEtokenTx && !isGenesisTx) {
                 try {
                     const thisEtokenAmount = new BigNumber(
                         thisOutput.slpToken.amount,
                     );
                     etokenAmount = etokenAmount.plus(thisEtokenAmount);
                 } catch (err) {
                     // NB the edge case described above cannot exist in an outgoing tx
                     // because the eTokens sent originated from this wallet
                 }
             }
         }
     }
 
     // Convert from sats to XEC
     xecAmount = xecAmount.shiftedBy(-1 * currency.cashDecimals);
 
     // Convert from BigNumber to string
     xecAmount = xecAmount.toString();
 
     // Get decimal info for correct etokenAmount
+    let genesisInfo = {};
     if (isEtokenTx) {
         // Get token genesis info from cache
-        let tokenGenesisInfo = {};
+
         let decimals = 0;
         try {
-            tokenGenesisInfo = tokenInfoById[tx.slpTxData.slpMeta.tokenId];
+            genesisInfo = tokenInfoById[tx.slpTxData.slpMeta.tokenId];
+            genesisInfo.success = true;
             // tokenGenesisInfo should be there for every tx in tx history, since it's already been cached for every utxo in the wallet
             // but try...catch just in case
-            decimals = tokenGenesisInfo.decimals;
+            decimals = genesisInfo.decimals;
             etokenAmount = etokenAmount.shiftedBy(-1 * decimals);
         } catch (err) {
             console.log(
                 `Error getting token info from cache in parseChronikTx`,
                 err,
             );
+            // To keep this function synchronous, do not get this info from the API if it is not in cache
+            // Instead, return a flag so that useWallet.js knows and can fetch this info + add it to cache
+            genesisInfo.success = false;
         }
     }
     etokenAmount = etokenAmount.toString();
 
     // Convert opReturnMessage to string
     opReturnMessage = Buffer.from(opReturnMessage).toString();
 
     // Return eToken specific fields if eToken tx
     if (isEtokenTx) {
         const { slpMeta } = tx.slpTxData;
         return {
             incoming,
             xecAmount,
             originatingHash160,
             isEtokenTx,
             etokenAmount,
             slpMeta,
+            genesisInfo,
             legacy: {
                 amountSent: incoming ? 0 : xecAmount,
                 amountReceived: incoming ? xecAmount : 0,
                 outgoingTx: !incoming,
                 tokenTx: true,
                 airdropFlag,
                 airdropTokenId,
                 opReturnMessage: '',
                 isCashtabMessage,
                 isEncryptedMessage,
                 decryptionSuccess,
                 replyAddress,
             },
         };
     }
     // Otherwise do not include these fields
     return {
         incoming,
         xecAmount,
         originatingHash160,
         isEtokenTx,
         legacy: {
             amountSent: incoming ? 0 : xecAmount,
             amountReceived: incoming ? xecAmount : 0,
             outgoingTx: !incoming,
             tokenTx: false,
             airdropFlag,
             airdropTokenId,
             opReturnMessage,
             isCashtabMessage,
             isEncryptedMessage,
             decryptionSuccess,
             replyAddress,
         },
     };
 };
 
 export const getTxHistoryChronik = async (
     chronik,
     BCH,
     wallet,
     tokenInfoById,
 ) => {
     // Create array of promises to get chronik history for each address
     // Combine them all and sort by blockheight and firstSeen
     // Add all the info cashtab needs to make them useful
     console.log(`tokenInfoById`, tokenInfoById);
 
     const hash160AndAddressObjArray = [
         {
             address: wallet.Path145.cashAddress,
             hash160: wallet.Path145.hash160,
         },
         {
             address: wallet.Path245.cashAddress,
             hash160: wallet.Path245.hash160,
         },
         {
             address: wallet.Path1899.cashAddress,
             hash160: wallet.Path1899.hash160,
         },
     ];
 
     let txHistoryPromises = [];
     for (let i = 0; i < hash160AndAddressObjArray.length; i += 1) {
         const txHistoryPromise = returnGetTxHistoryChronikPromise(
             chronik,
             hash160AndAddressObjArray[i],
         );
         txHistoryPromises.push(txHistoryPromise);
     }
     let txHistoryOfAllAddresses;
     try {
         txHistoryOfAllAddresses = await Promise.all(txHistoryPromises);
     } catch (err) {
         console.log(`Error in Promise.all(txHistoryPromises)`, err);
     }
     console.log(`txHistoryOfAllAddresses`, txHistoryOfAllAddresses);
     const flatTxHistoryArray = flattenChronikTxHistory(txHistoryOfAllAddresses);
     console.log(`flatTxHistoryArray`, flatTxHistoryArray);
     const sortedTxHistoryArray = sortAndTrimChronikTxHistory(
         flatTxHistoryArray,
         currency.txHistoryCount,
     );
 
     // Parse txs
     const parsedTxs = [];
     for (let i = 0; i < sortedTxHistoryArray.length; i += 1) {
         const sortedTx = sortedTxHistoryArray[i];
         // Add token genesis info so parsing function can calculate amount by decimals
         sortedTx.parsed = parseChronikTx(BCH, sortedTx, wallet, tokenInfoById);
         parsedTxs.push(sortedTx);
     }
 
     return parsedTxs;
 };