diff --git a/web/cashtab/src/hooks/__mocks__/mockLegacyWallets.js b/web/cashtab/src/hooks/__mocks__/mockLegacyWallets.js index 9154cc7b9..a37686de3 100644 --- a/web/cashtab/src/hooks/__mocks__/mockLegacyWallets.js +++ b/web/cashtab/src/hooks/__mocks__/mockLegacyWallets.js @@ -1,127 +1,133 @@ export default { legacyAlphaMainnet: { mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'MigrationTestAlpha on Mainnet', Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', }, Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', }, }, migratedLegacyAlphaMainnet: { mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'MigrationTestAlpha on Mainnet', Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', + hash160: '960c9ed561f1699f0c49974d50b3bb7cdc118625', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', publicKey: '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', }, Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', + hash160: '2be0e0c999e7e77a443ea726f82c441912fca92b', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', publicKey: '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', }, Path1899: { cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', + hash160: 'ba8257db65f40359989c7b894c5e88ed7b6344f6', fundingAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', publicKey: '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', }, }, legacyAlphaTestnet: { mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'MigrationTestAlpha on Testnet', Path245: { cashAddress: 'bchtest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy539jyxazm', fundingAddress: 'slptest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5234lu2sx', fundingWif: 'cN3NDtiabeeX1Wzg2CPgLgrb7fsDG8PgWqTnmwAhYWmY6osSta7Q', legacyAddress: 'muCLmiGfH961UuWrTTFNU3KxH9pVQJJx6Z', slpAddress: 'slptest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5234lu2sx', }, Path145: { cashAddress: 'bchtest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vtdvpkdz7', fundingAddress: 'slptest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vset6v6sr', fundingWif: 'cTKuvZ644Sf7xra5z3dPshEECJNaDyBCq7HyBsysQPh1ySSpxtQ1', legacyAddress: 'mjWxk74mLM7TieAsSJArLF7nXqC6oc2mof', slpAddress: 'slptest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vset6v6sr', }, }, migratedLegacyAlphaTestnet: { mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'MigrationTestAlpha on Testnet', Path245: { cashAddress: 'bchtest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy539jyxazm', fundingAddress: 'slptest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5234lu2sx', fundingWif: 'cN3NDtiabeeX1Wzg2CPgLgrb7fsDG8PgWqTnmwAhYWmY6osSta7Q', + hash160: '960c9ed561f1699f0c49974d50b3bb7cdc118625', legacyAddress: 'muCLmiGfH961UuWrTTFNU3KxH9pVQJJx6Z', slpAddress: 'slptest:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5234lu2sx', publicKey: '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', }, Path145: { cashAddress: 'bchtest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vtdvpkdz7', fundingAddress: 'slptest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vset6v6sr', fundingWif: 'cTKuvZ644Sf7xra5z3dPshEECJNaDyBCq7HyBsysQPh1ySSpxtQ1', + hash160: '2be0e0c999e7e77a443ea726f82c441912fca92b', legacyAddress: 'mjWxk74mLM7TieAsSJArLF7nXqC6oc2mof', slpAddress: 'slptest:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vset6v6sr', publicKey: '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', }, Path1899: { cashAddress: 'bchtest:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7c9ex06hrx', fundingAddress: 'slptest:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7c7dp5qq3m', fundingWif: 'cNRFB6MmkNhyhAj1TpGhXdbHgzWg4BsdHbAkKjiz4vt4vwgpC44F', + hash160: 'ba8257db65f40359989c7b894c5e88ed7b6344f6', legacyAddress: 'mxX888y8yaPpTYh3WhrB9GEkT3cgumYwPw', slpAddress: 'slptest:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7c7dp5qq3m', publicKey: '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', }, }, }; diff --git a/web/cashtab/src/hooks/useWallet.js b/web/cashtab/src/hooks/useWallet.js index e3d240d5f..f8dac6d5b 100644 --- a/web/cashtab/src/hooks/useWallet.js +++ b/web/cashtab/src/hooks/useWallet.js @@ -1,1263 +1,1265 @@ import { useState, useEffect } from 'react'; import useAsyncTimeout from 'hooks/useAsyncTimeout'; import usePrevious from 'hooks/usePrevious'; import useBCH from 'hooks/useBCH'; import BigNumber from 'bignumber.js'; import { fromSmallestDenomination, loadStoredWallet, isValidStoredWallet, isLegacyMigrationRequired, whichUtxosWereAdded, whichUtxosWereConsumed, addNewHydratedUtxos, removeConsumedUtxos, areAllUtxosIncludedInIncrementallyHydratedUtxos, } from 'utils/cashMethods'; import { isValidCashtabSettings, isValidContactList } from 'utils/validation'; import localforage from 'localforage'; import { currency } from 'components/Common/Ticker'; import isEmpty from 'lodash.isempty'; import isEqual from 'lodash.isequal'; import { xecReceivedNotification, eTokenReceivedNotification, } from 'components/Common/Notifications'; const useWallet = () => { const [wallet, setWallet] = useState(false); const [contactList, setContactList] = useState(false); const [cashtabSettings, setCashtabSettings] = useState(false); const [fiatPrice, setFiatPrice] = useState(null); const [apiError, setApiError] = useState(false); const [checkFiatInterval, setCheckFiatInterval] = useState(null); const [hasUpdated, setHasUpdated] = useState(false); const { getBCH, getUtxos, getHydratedUtxoDetails, getSlpBalancesAndUtxos, getTxHistory, getTxData, addTokenTxData, } = useBCH(); const [loading, setLoading] = useState(true); const [apiIndex, setApiIndex] = useState(0); const [BCH, setBCH] = useState(getBCH(apiIndex)); const { balances, tokens, utxos } = isValidStoredWallet(wallet) ? wallet.state : { balances: {}, tokens: [], utxos: null, }; const previousBalances = usePrevious(balances); const previousTokens = usePrevious(tokens); const previousUtxos = usePrevious(utxos); // If you catch API errors, call this function const tryNextAPI = () => { let currentApiIndex = apiIndex; // How many APIs do you have? const apiString = process.env.REACT_APP_BCHA_APIS; const apiArray = apiString.split(','); console.log(`You have ${apiArray.length} APIs to choose from`); console.log(`Current selection: ${apiIndex}`); // If only one, exit if (apiArray.length === 0) { console.log( `There are no backup APIs, you are stuck with this error`, ); return; } else if (currentApiIndex < apiArray.length - 1) { currentApiIndex += 1; console.log( `Incrementing API index from ${apiIndex} to ${currentApiIndex}`, ); } else { // Otherwise use the first option again console.log(`Retrying first API index`); currentApiIndex = 0; } //return setApiIndex(currentApiIndex); console.log(`Setting Api Index to ${currentApiIndex}`); setApiIndex(currentApiIndex); return setBCH(getBCH(currentApiIndex)); // If you have more than one, use the next one // If you are at the "end" of the array, use the first one }; const normalizeSlpBalancesAndUtxos = (slpBalancesAndUtxos, wallet) => { const Accounts = [wallet.Path245, wallet.Path145, wallet.Path1899]; slpBalancesAndUtxos.nonSlpUtxos.forEach(utxo => { const derivatedAccount = Accounts.find( account => account.cashAddress === utxo.address, ); utxo.wif = derivatedAccount.fundingWif; }); return slpBalancesAndUtxos; }; const normalizeBalance = slpBalancesAndUtxos => { const totalBalanceInSatoshis = slpBalancesAndUtxos.nonSlpUtxos.reduce( (previousBalance, utxo) => previousBalance + utxo.value, 0, ); return { totalBalanceInSatoshis, totalBalance: fromSmallestDenomination(totalBalanceInSatoshis), }; }; 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); } // Loading will remain true until API calls populate this legacy wallet setWallet(wallet); }; const haveUtxosChanged = (wallet, utxos, previousUtxos) => { // Relevant points for this array comparing exercise // https://stackoverflow.com/questions/13757109/triple-equal-signs-return-false-for-arrays-in-javascript-why // https://stackoverflow.com/questions/7837456/how-to-compare-arrays-in-javascript // If this is initial state if (utxos === null) { // Then make sure to get slpBalancesAndUtxos return true; } // If this is the first time the wallet received utxos if (typeof utxos === 'undefined') { // Then they have certainly changed return true; } if (typeof previousUtxos === 'undefined') { // Compare to what you have in localStorage on startup // If previousUtxos are undefined, see if you have previousUtxos in wallet state // If you do, and it has everything you need, set wallet state with that instead of calling hydrateUtxos on all utxos if (isValidStoredWallet(wallet)) { // Convert all the token balance figures to big numbers const liveWalletState = loadStoredWallet(wallet.state); wallet.state = liveWalletState; return setWallet(wallet); } // If wallet in storage is a legacy wallet or otherwise does not have all state fields, // then assume utxos have changed return true; } // return true for empty array, since this means you definitely do not want to skip the next API call if (utxos && utxos.length === 0) { return true; } // If wallet is valid, compare what exists in written wallet state instead of former api call let utxosToCompare = previousUtxos; if (isValidStoredWallet(wallet)) { try { utxosToCompare = wallet.state.utxos; } catch (err) { console.log(`Error setting utxos to wallet.state.utxos`, err); console.log(`Wallet at err`, wallet); // If this happens, assume utxo set has changed return true; } } // Compare utxo sets return !isEqual(utxos, utxosToCompare); }; const update = async ({ wallet }) => { //console.log(`tick()`); //console.time("update"); 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, ]; const utxos = await getUtxos(BCH, cashAddresses); // If an error is returned or utxos from only 1 address are returned if (!utxos || isEmpty(utxos) || utxos.error || utxos.length < 2) { // Throw error here to prevent more attempted api calls // as you are likely already at rate limits throw new Error('Error fetching utxos'); } // Need to call with wallet as a parameter rather than trusting it is in state, otherwise can sometimes get wallet=false from haveUtxosChanged const utxosHaveChanged = haveUtxosChanged( wallet, utxos, previousUtxos, ); // If the utxo set has not changed, if (!utxosHaveChanged) { // remove api error here; otherwise it will remain if recovering from a rate // limit error with an unchanged utxo set setApiError(false); // then wallet.state has not changed and does not need to be updated //console.timeEnd("update"); return; } let incrementalHydratedUtxosValid; let incrementallyAdjustedHydratedUtxoDetails; try { // Make sure you have all the required inputs to use this approach if ( !wallet || !wallet.state || !wallet.state.utxos || !wallet.state.hydratedUtxoDetails || !utxos ) { throw new Error( 'Wallet does not have required state for incremental approach, hydrating full utxo set', ); } const utxosAdded = whichUtxosWereAdded( wallet.state.utxos, utxos, ); const utxosConsumed = whichUtxosWereConsumed( wallet.state.utxos, utxos, ); incrementallyAdjustedHydratedUtxoDetails = wallet.state.hydratedUtxoDetails; if (utxosConsumed) { incrementallyAdjustedHydratedUtxoDetails = removeConsumedUtxos( utxosConsumed, incrementallyAdjustedHydratedUtxoDetails, ); } if (utxosAdded) { const addedHydratedUtxos = await getHydratedUtxoDetails( BCH, utxosAdded, ); incrementallyAdjustedHydratedUtxoDetails = addNewHydratedUtxos( addedHydratedUtxos, incrementallyAdjustedHydratedUtxoDetails, ); } incrementalHydratedUtxosValid = areAllUtxosIncludedInIncrementallyHydratedUtxos( utxos, incrementallyAdjustedHydratedUtxoDetails, ); } catch (err) { console.log( `Error in incremental determination of hydratedUtxoDetails`, ); console.log(err); incrementalHydratedUtxosValid = false; } if (!incrementalHydratedUtxosValid) { console.log( `Incremental approach invalid, hydrating all utxos`, ); incrementallyAdjustedHydratedUtxoDetails = await getHydratedUtxoDetails(BCH, utxos); } const slpBalancesAndUtxos = await getSlpBalancesAndUtxos( BCH, incrementallyAdjustedHydratedUtxoDetails, ); console.log(`slpBalancesAndUtxos`, slpBalancesAndUtxos); const txHistory = await getTxHistory(BCH, cashAddresses); // 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); if (typeof slpBalancesAndUtxos === 'undefined') { console.log(`slpBalancesAndUtxos is undefined`); throw new Error('slpBalancesAndUtxos is undefined'); } const { tokens } = slpBalancesAndUtxos; const newState = { balances: {}, tokens: [], slpBalancesAndUtxos: [], }; newState.slpBalancesAndUtxos = normalizeSlpBalancesAndUtxos( slpBalancesAndUtxos, wallet, ); newState.balances = normalizeBalance(slpBalancesAndUtxos); newState.tokens = tokens; newState.parsedTxHistory = parsedWithTokens; newState.utxos = utxos; newState.hydratedUtxoDetails = incrementallyAdjustedHydratedUtxoDetails; // 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 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 */ setHasUpdated(false); let currentlyActiveWallet; try { currentlyActiveWallet = await localforage.getItem('wallet'); } catch (err) { console.log( `Error in localforage.getItem("wallet") in activateWallet()`, ); return false; } // Get savedwallets let savedWallets; try { savedWallets = await localforage.getItem('savedWallets'); } catch (err) { console.log( `Error in localforage.getItem("savedWallets") in activateWallet()`, ); return false; } /* When a legacy user runs 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 has Path1899, but its stored keyvalue pair in savedWallets does not > Update savedWallets so that Path1899 is added to currentlyActiveWallet 2 - walletToActivate does not have Path1899 > Update walletToActivate with Path1899 before activation NOTE: since publicKey property is added later, wallet without public key in Path1899 is also considered legacy and required migration. */ // Need to handle a similar situation with state // If you find the activeWallet in savedWallets but without state, resave active wallet with state // Note you do not have the Case 2 described above here, as wallet state is added in the update() function of useWallet.js // Also note, since state can be expected to change frequently (unlike path deriv), you will likely save it every time you activate a new wallet // Check savedWallets for currentlyActiveWallet let walletInSavedWallets = false; for (let i = 0; i < savedWallets.length; i += 1) { if (savedWallets[i].name === currentlyActiveWallet.name) { walletInSavedWallets = true; // Check savedWallets for unmigrated currentlyActiveWallet if (isLegacyMigrationRequired(savedWallets[i])) { // Case 1, described above savedWallets[i].Path1899 = currentlyActiveWallet.Path1899; savedWallets[i].Path145 = currentlyActiveWallet.Path145; savedWallets[i].Path245 = currentlyActiveWallet.Path245; } /* Update wallet state Note, this makes previous `walletUnmigrated` variable redundant savedWallets[i] should always be updated, since wallet state can be expected to change most of the time */ savedWallets[i].state = currentlyActiveWallet.state; } } // resave savedWallets try { // Set walletName as the active wallet await localforage.setItem('savedWallets', savedWallets); } catch (err) { console.log( `Error in localforage.setItem("savedWallets") in activateWallet() for unmigrated wallet`, ); } if (!walletInSavedWallets) { console.log(`Wallet is not in saved Wallets, adding`); savedWallets.push(currentlyActiveWallet); // resave savedWallets try { // Set walletName as the active wallet await localforage.setItem('savedWallets', savedWallets); } catch (err) { console.log( `Error in localforage.setItem("savedWallets") in activateWallet()`, ); } } // If wallet does not have Path1899, add it // 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 does not have Path1899 or does not have public key in each Path`, ); console.log( `Wallet to activate from SavedWallets does not have Path1899 or does not have public key in each Path`, ); 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; } } // Make sure stored wallet is in correct format to be used as live wallet if (isValidStoredWallet(walletToActivate)) { // Convert all the token balance figures to big numbers const liveWalletState = loadStoredWallet(walletToActivate.state); walletToActivate.state = liveWalletState; } return walletToActivate; }; const renameWallet = async (oldName, newName) => { // Load savedWallets let savedWallets; try { savedWallets = await localforage.getItem('savedWallets'); } catch (err) { console.log( `Error in await localforage.getItem("savedWallets") in renameWallet`, ); console.log(err); return false; } // Verify that no existing wallet has this name for (let i = 0; i < savedWallets.length; i += 1) { if (savedWallets[i].name === newName) { // return an error return false; } } // change name of desired wallet for (let i = 0; i < savedWallets.length; i += 1) { if (savedWallets[i].name === oldName) { // Replace the name of this entry with the new name savedWallets[i].name = newName; } } // resave savedWallets try { // Set walletName as the active wallet await localforage.setItem('savedWallets', savedWallets); } catch (err) { console.log( `Error in localforage.setItem("savedWallets", savedWallets) in renameWallet()`, ); return false; } return true; }; const deleteWallet = async walletToBeDeleted => { // delete a wallet // returns true if wallet is successfully deleted // otherwise returns false // Load savedWallets let savedWallets; try { savedWallets = await localforage.getItem('savedWallets'); } catch (err) { console.log( `Error in await localforage.getItem("savedWallets") in deleteWallet`, ); console.log(err); return false; } // Iterate over to find the wallet to be deleted // Verify that no existing wallet has this name let walletFoundAndRemoved = false; for (let i = 0; i < savedWallets.length; i += 1) { if (savedWallets[i].name === walletToBeDeleted.name) { // Verify it has the same mnemonic too, that's a better UUID if (savedWallets[i].mnemonic === walletToBeDeleted.mnemonic) { // Delete it savedWallets.splice(i, 1); walletFoundAndRemoved = true; } } } // If you don't find the wallet, return false if (!walletFoundAndRemoved) { return false; } // Resave savedWallets less the deleted wallet try { // Set walletName as the active wallet await localforage.setItem('savedWallets', savedWallets); } catch (err) { console.log( `Error in localforage.setItem("savedWallets", savedWallets) in deleteWallet()`, ); return false; } return true; }; const addNewSavedWallet = async importMnemonic => { // Add a new wallet to savedWallets from importMnemonic or just new wallet const lang = 'english'; // create 128 bit BIP39 mnemonic const Bip39128BitMnemonic = importMnemonic ? importMnemonic : BCH.Mnemonic.generate(128, BCH.Mnemonic.wordLists()[lang]); const newSavedWallet = await getWalletDetails({ mnemonic: Bip39128BitMnemonic.toString(), }); // Get saved wallets let savedWallets; try { savedWallets = await localforage.getItem('savedWallets'); // If this doesn't exist yet, savedWallets === null if (savedWallets === null) { savedWallets = []; } } catch (err) { console.log( `Error in savedWallets = await localforage.getItem("savedWallets") in addNewSavedWallet()`, ); console.log(err); console.log(`savedWallets in error state`, savedWallets); } // If this wallet is from an imported mnemonic, make sure it does not already exist in savedWallets if (importMnemonic) { for (let i = 0; i < savedWallets.length; i += 1) { // Check for condition "importing new wallet that is already in savedWallets" if (savedWallets[i].mnemonic === importMnemonic) { // set this as the active wallet to keep name history console.log( `Error: this wallet already exists in savedWallets`, ); console.log(`Wallet not being added.`); return false; } } } // add newSavedWallet savedWallets.push(newSavedWallet); // update savedWallets try { await localforage.setItem('savedWallets', savedWallets); } catch (err) { console.log( `Error in localforage.setItem("savedWallets", activeWallet) called in createWallet with ${importMnemonic}`, ); console.log(`savedWallets`, savedWallets); console.log(err); } return true; }; const createWallet = async importMnemonic => { const lang = 'english'; // create 128 bit BIP39 mnemonic const Bip39128BitMnemonic = importMnemonic ? importMnemonic : BCH.Mnemonic.generate(128, BCH.Mnemonic.wordLists()[lang]); const wallet = await getWalletDetails({ mnemonic: Bip39128BitMnemonic.toString(), }); try { await localforage.setItem('wallet', wallet); } catch (err) { console.log( `Error setting wallet to wallet indexedDb in createWallet()`, ); console.log(err); } // Since this function is only called from OnBoarding.js, also add this to the saved wallet try { await localforage.setItem('savedWallets', [wallet]); } catch (err) { console.log( `Error setting wallet to savedWallets indexedDb in createWallet()`, ); console.log(err); } return wallet; }; const validateMnemonic = ( mnemonic, wordlist = BCH.Mnemonic.wordLists().english, ) => { let mnemonicTestOutput; try { mnemonicTestOutput = BCH.Mnemonic.validate(mnemonic, wordlist); if (mnemonicTestOutput === 'Valid mnemonic') { return true; } else { return false; } } catch (err) { console.log(err); return false; } }; const handleUpdateWallet = async setWallet => { 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 not valid, also set cashtabSettings to default setCashtabSettings(currency.defaultSettings); 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 'settings' 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 settings key, make sure it's valid if (isValidContactList(localContactList)) { setContactList(localContactList); return localContactList; } // if not valid, also set to default setContactList([{}]); return [{}]; }; // 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 useAsyncTimeout function, and re-sets to false during activateWallet if ( 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 if ( 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 every 10s useAsyncTimeout(async () => { const wallet = await getWallet(); update({ wallet, }).finally(() => { setLoading(false); if (!hasUpdated) { setHasUpdated(true); } }); }, 1000); 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(); const initialSettings = await loadCashtabSettings(); initializeFiatPriceApi(initialSettings.fiatCurrency); }, []); return { BCH, 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); const newWallet = await activateWallet(walletToActivate); setWallet(newWallet); if (isValidStoredWallet(walletToActivate)) { // If you have all state parameters needed in storage, immediately load the wallet setLoading(false); } else { // If the wallet is missing state parameters in storage, wait for API info // This handles case of unmigrated legacy wallet update({ wallet: newWallet, }).finally(() => setLoading(false)); } }, addNewSavedWallet, renameWallet, deleteWallet, }; }; export default useWallet; diff --git a/web/cashtab/src/utils/__mocks__/mockLegacyWalletsUtils.js b/web/cashtab/src/utils/__mocks__/mockLegacyWalletsUtils.js index e0507e91f..1e6223836 100644 --- a/web/cashtab/src/utils/__mocks__/mockLegacyWalletsUtils.js +++ b/web/cashtab/src/utils/__mocks__/mockLegacyWalletsUtils.js @@ -1,164 +1,207 @@ export const missingPath1899Wallet = { Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', }, Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', }, mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'Missing Path1899', state: {}, }; export const missingPublicKeyInPath1899Wallet = { Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', publicKey: '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', }, Path1899: { cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', fundingAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', }, Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', publicKey: '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', }, mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'Missing Public Key in Path1899', state: {}, }; export const missingPublicKeyInPath145Wallet = { Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', }, Path1899: { cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', fundingAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', publicKey: '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', }, Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', publicKey: '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', }, mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'Missing Public Key in Path145', state: {}, }; export const missingPublicKeyInPath245Wallet = { Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', publicKey: '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', }, Path1899: { cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', fundingAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', publicKey: '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', }, Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', }, mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'Missing Public Key in Path245', state: {}, }; export const notLegacyWallet = { Path145: { cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', fundingAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', + hash160: '2be0e0c999e7e77a443ea726f82c441912fca92b', legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', publicKey: '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', }, Path1899: { cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', fundingAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', + hash160: 'ba8257db65f40359989c7b894c5e88ed7b6344f6', legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', publicKey: '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', }, Path245: { cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', fundingAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', + hash160: '960c9ed561f1699f0c49974d50b3bb7cdc118625', legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', publicKey: '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', }, mnemonic: 'apart vacuum color cream drama kind foil history hurt alone ask census', name: 'Current Wallet, Not Legacy', state: {}, }; + +export const missingHash160 = { + Path145: { + cashAddress: 'bitcoincash:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9v0lgx569z', + fundingAddress: + 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', + fundingWif: 'L2xvTe6CdNxroR6pbdpGWNjAa55AZX5Wm59W5TXMuH31ihNJdDjt', + + legacyAddress: '1511T3ynXKgCwXhFijCUWKuTfqbPxFV1AF', + publicKey: + '02fe5308d77bcce825068a9e46adc6f032dbbe39167a7b6d05ac563ac71d8b186e', + slpAddress: 'simpleledger:qq47pcxfn8n7w7jy86njd7pvgsv39l9f9vryrap6mu', + }, + Path1899: { + cashAddress: 'bitcoincash:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cptzgcqy6', + fundingAddress: + 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', + fundingWif: 'Kx4FiBMvKK1iXjFk5QTaAK6E4mDGPjmwDZ2HDKGUZpE4gCXMaPe9', + + legacyAddress: '1J1Aq5tAAYxZgSDRo8soKM2Rb41z3xrYpm', + publicKey: + '02a06bb380cf180d703f6f80796a13555aefff817d1f6f842f1e5c555b15f0fa70', + slpAddress: 'simpleledger:qzagy47mvh6qxkvcn3acjnz73rkhkc6y7cdsfndq6y', + }, + Path245: { + cashAddress: 'bitcoincash:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy54hkry298', + fundingAddress: + 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', + fundingWif: 'KwgNkyijAaxFr5XQdnaYyNMXVSZobgHzSoKKfWiC3Q7Xr4n7iYMG', + + legacyAddress: '1EgPUfBgU7ekho3EjtGze87dRADnUE8ojP', + publicKey: + '03c4a69fd90c8b196683216cffd2943a7b13b0db0812e44a4ff156ac7e03fc4ed7', + slpAddress: 'simpleledger:qztqe8k4v8ckn8cvfxt5659nhd7dcyvxy5evac32me', + }, + mnemonic: + 'apart vacuum color cream drama kind foil history hurt alone ask census', + name: 'Missing Public Key in Path1899', + state: {}, +}; diff --git a/web/cashtab/src/utils/__tests__/cashMethods.test.js b/web/cashtab/src/utils/__tests__/cashMethods.test.js index 4ae7458e0..c6f1b9db1 100644 --- a/web/cashtab/src/utils/__tests__/cashMethods.test.js +++ b/web/cashtab/src/utils/__tests__/cashMethods.test.js @@ -1,876 +1,880 @@ import { ValidationError } from 'ecashaddrjs'; import { fromSmallestDenomination, batchArray, flattenContactList, flattenBatchedHydratedUtxos, loadStoredWallet, isValidStoredWallet, fromLegacyDecimals, convertToEcashPrefix, checkNullUtxosForTokenStatus, confirmNonEtokenUtxos, isLegacyMigrationRequired, toLegacyCash, toLegacyToken, toLegacyCashArray, convertEtokenToEcashAddr, parseOpReturn, isExcludedUtxo, whichUtxosWereAdded, whichUtxosWereConsumed, addNewHydratedUtxos, removeConsumedUtxos, getUtxoCount, areAllUtxosIncludedInIncrementallyHydratedUtxos, convertEcashtoEtokenAddr, } from 'utils/cashMethods'; import { currency } from 'components/Common/Ticker'; import { unbatchedArray, arrayBatchedByThree, } from '../__mocks__/mockBatchedArrays'; import { validAddressArrayInput, validAddressArrayInputMixedPrefixes, validAddressArrayOutput, validLargeAddressArrayInput, validLargeAddressArrayOutput, invalidAddressArrayInput, } from '../__mocks__/mockAddressArray'; import { unflattenedHydrateUtxosResponse, flattenedHydrateUtxosResponse, } from '../__mocks__/flattenBatchedHydratedUtxosMocks'; import { cachedUtxos, utxosLoadedFromCache, } from '../__mocks__/mockCachedUtxos'; import { validStoredWallet, invalidStoredWallet, } from '../__mocks__/mockStoredWallets'; import { mockTxDataResults, mockNonEtokenUtxos, mockTxDataResultsWithEtoken, mockHydratedUtxosWithNullValues, mockHydratedUtxosWithNullValuesSetToFalse, } from '../__mocks__/nullUtxoMocks'; 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 { excludedUtxoAlpha, excludedUtxoBeta, includedUtxoAlpha, includedUtxoBeta, previousUtxosObjUtxoArray, previousUtxosTemplate, currentUtxosAfterSingleXecReceiveTxTemplate, utxosAddedBySingleXecReceiveTxTemplate, previousUtxosBeforeSingleXecReceiveTx, currentUtxosAfterSingleXecReceiveTx, utxosAddedBySingleXecReceiveTx, currentUtxosAfterMultiXecReceiveTxTemplate, utxosAddedByMultiXecReceiveTxTemplate, previousUtxosBeforeMultiXecReceiveTx, currentUtxosAfterMultiXecReceiveTx, utxosAddedByMultiXecReceiveTx, currentUtxosAfterEtokenReceiveTxTemplate, utxosAddedByEtokenReceiveTxTemplate, previousUtxosBeforeEtokenReceiveTx, currentUtxosAfterEtokenReceiveTx, utxosAddedByEtokenReceiveTx, previousUtxosBeforeSendAllTxTemplate, currentUtxosAfterSendAllTxTemplate, previousUtxosBeforeSendAllTx, currentUtxosAfterSendAllTx, previousUtxosBeforeSingleXecSendTx, currentUtxosAfterSingleXecSendTx, utxosAddedBySingleXecSendTx, currentUtxosAfterSingleXecSendTxTemplate, utxosAddedBySingleXecSendTxTemplate, currentUtxosAfterEtokenSendTxTemplate, utxosAddedByEtokenSendTxTemplate, previousUtxosBeforeEtokenSendTx, currentUtxosAfterEtokenSendTx, utxosAddedByEtokenSendTx, utxosConsumedByEtokenSendTx, utxosConsumedByEtokenSendTxTemplate, utxosConsumedBySingleXecSendTx, utxosConsumedBySingleXecSendTxTemplate, utxosConsumedBySendAllTx, utxosConsumedBySendAllTxTemplate, hydratedUtxoDetailsBeforeAddingTemplate, hydratedUtxoDetailsAfterAddingSingleUtxoTemplate, newHydratedUtxosSingleTemplate, addedHydratedUtxosOverTwenty, existingHydratedUtxoDetails, existingHydratedUtxoDetailsAfterAdd, hydratedUtxoDetailsBeforeConsumedTemplate, consumedUtxoTemplate, hydratedUtxoDetailsAfterRemovingConsumedUtxoTemplate, consumedUtxos, hydratedUtxoDetailsBeforeRemovingConsumedUtxos, hydratedUtxoDetailsAfterRemovingConsumedUtxos, consumedUtxosMoreThanTwenty, hydratedUtxoDetailsAfterRemovingMoreThanTwentyConsumedUtxos, consumedUtxosMoreThanTwentyInRandomObjects, utxoCountMultiTemplate, utxoCountSingleTemplate, incrementalUtxosTemplate, incrementallyHydratedUtxosTemplate, incrementallyHydratedUtxosTemplateMissing, utxosAfterSentTxIncremental, incrementallyHydratedUtxosAfterProcessing, incrementallyHydratedUtxosAfterProcessingOneMissing, } from '../__mocks__/incrementalUtxoMocks'; describe('Correctly executes cash utility functions', () => { it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 2`, () => { expect(fromSmallestDenomination(1, 2)).toBe(0.01); }); it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 2`, () => { expect(fromSmallestDenomination(1000000012345678, 2)).toBe( 10000000123456.78, ); }); it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 8`, () => { expect(fromSmallestDenomination(1, 8)).toBe(0.00000001); }); it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 8`, () => { expect(fromSmallestDenomination(1000000012345678, 8)).toBe( 10000000.12345678, ); }); it(`Correctly converts an array of length 10 to an array of 4 arrays, each with max length 3`, () => { expect(batchArray(unbatchedArray, 3)).toStrictEqual( arrayBatchedByThree, ); }); it(`If array length is less than batch size, return original array as first and only element of new array`, () => { expect(batchArray(unbatchedArray, 20)).toStrictEqual([unbatchedArray]); }); it(`Flattens hydrateUtxos from Promise.all() response into array that can be parsed by getSlpBalancesAndUtxos`, () => { expect( flattenBatchedHydratedUtxos(unflattenedHydrateUtxosResponse), ).toStrictEqual(flattenedHydrateUtxosResponse); }); 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(`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(`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(`Correctly parses utxo vout tx data to confirm the transactions are not eToken txs`, () => { expect(checkNullUtxosForTokenStatus(mockTxDataResults)).toStrictEqual( mockNonEtokenUtxos, ); }); it(`Correctly parses utxo vout tx data and screens out an eToken by asm field`, () => { expect( checkNullUtxosForTokenStatus(mockTxDataResultsWithEtoken), ).toStrictEqual([]); }); it(`Changes isValid from 'null' to 'false' for confirmed nonEtokenUtxos`, () => { expect( confirmNonEtokenUtxos( mockHydratedUtxosWithNullValues, mockNonEtokenUtxos, ), ).toStrictEqual(mockHydratedUtxosWithNullValuesSetToFalse); }); 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('isExcludedUtxo returns true for a utxo with different tx_pos and same txid as an existing utxo in the set', async () => { expect( isExcludedUtxo(excludedUtxoAlpha, previousUtxosObjUtxoArray), ).toBe(true); }); test('isExcludedUtxo returns true for a utxo with different value and same txid as an existing utxo in the set', async () => { expect( isExcludedUtxo(excludedUtxoBeta, previousUtxosObjUtxoArray), ).toBe(true); }); test('isExcludedUtxo returns false for a utxo with different tx_pos and same txid', async () => { expect( isExcludedUtxo(includedUtxoAlpha, previousUtxosObjUtxoArray), ).toBe(false); }); test('isExcludedUtxo returns false for a utxo with different value and same txid', async () => { expect( isExcludedUtxo(includedUtxoBeta, previousUtxosObjUtxoArray), ).toBe(false); }); test('whichUtxosWereAdded correctly identifies a single added utxo after a received XEC tx [template]', async () => { expect( whichUtxosWereAdded( previousUtxosTemplate, currentUtxosAfterSingleXecReceiveTxTemplate, ), ).toStrictEqual(utxosAddedBySingleXecReceiveTxTemplate); }); test('whichUtxosWereAdded correctly identifies a single added utxo after a received XEC tx', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeSingleXecReceiveTx, currentUtxosAfterSingleXecReceiveTx, ), ).toStrictEqual(utxosAddedBySingleXecReceiveTx); }); test('whichUtxosWereAdded correctly identifies multiple added utxos with the same txid [template]', async () => { expect( whichUtxosWereAdded( previousUtxosTemplate, currentUtxosAfterMultiXecReceiveTxTemplate, ), ).toStrictEqual(utxosAddedByMultiXecReceiveTxTemplate); }); test('whichUtxosWereAdded correctly identifies multiple added utxos with the same txid', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeMultiXecReceiveTx, currentUtxosAfterMultiXecReceiveTx, ), ).toStrictEqual(utxosAddedByMultiXecReceiveTx); }); test('whichUtxosWereAdded correctly identifies an added utxos from received eToken tx [template]', async () => { expect( whichUtxosWereAdded( previousUtxosTemplate, currentUtxosAfterEtokenReceiveTxTemplate, ), ).toStrictEqual(utxosAddedByEtokenReceiveTxTemplate); }); test('whichUtxosWereAdded correctly identifies an added utxos from received eToken tx', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeEtokenReceiveTx, currentUtxosAfterEtokenReceiveTx, ), ).toStrictEqual(utxosAddedByEtokenReceiveTx); }); test('whichUtxosWereAdded correctly identifies no utxos were added in a send all XEC tx (no change) [template]', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeSendAllTxTemplate, currentUtxosAfterSendAllTxTemplate, ), ).toStrictEqual(false); }); test('whichUtxosWereAdded correctly identifies no utxos were added in a send all XEC tx (no change)', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeSendAllTx, currentUtxosAfterSendAllTx, ), ).toStrictEqual(false); }); test('whichUtxosWereAdded correctly identifies an added utxo from a single send XEC tx', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeSingleXecSendTx, currentUtxosAfterSingleXecSendTx, ), ).toStrictEqual(utxosAddedBySingleXecSendTx); }); test('whichUtxosWereAdded correctly identifies an added utxo from a single send XEC tx [template]', async () => { expect( whichUtxosWereAdded( previousUtxosTemplate, currentUtxosAfterSingleXecSendTxTemplate, ), ).toStrictEqual(utxosAddedBySingleXecSendTxTemplate); }); test('whichUtxosWereAdded correctly identifies added change utxos from a send eToken tx [template]', async () => { expect( whichUtxosWereAdded( previousUtxosTemplate, currentUtxosAfterEtokenSendTxTemplate, ), ).toStrictEqual(utxosAddedByEtokenSendTxTemplate); }); test('whichUtxosWereAdded correctly identifies added change utxos from a send eToken tx', async () => { expect( whichUtxosWereAdded( previousUtxosBeforeEtokenSendTx, currentUtxosAfterEtokenSendTx, ), ).toStrictEqual(utxosAddedByEtokenSendTx); }); test('whichUtxosWereConsumed correctly identifies no utxos consumed after a received XEC tx [template]', async () => { expect( whichUtxosWereConsumed( previousUtxosTemplate, currentUtxosAfterSingleXecReceiveTxTemplate, ), ).toStrictEqual(false); }); test('whichUtxosWereConsumed correctly identifies no utxos consumed a received XEC tx', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeSingleXecReceiveTx, currentUtxosAfterSingleXecReceiveTx, ), ).toStrictEqual(false); }); test('whichUtxosWereConsumed correctly identifies no consumed utxos after receiving an XEC multi-send tx [template]', async () => { expect( whichUtxosWereConsumed( previousUtxosTemplate, currentUtxosAfterMultiXecReceiveTxTemplate, ), ).toStrictEqual(false); }); test('whichUtxosWereConsumed correctly identifies no consumed utxos after receiving an XEC multi-send tx', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeMultiXecReceiveTx, currentUtxosAfterMultiXecReceiveTx, ), ).toStrictEqual(false); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a single send XEC tx', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeSingleXecSendTx, currentUtxosAfterSingleXecSendTx, ), ).toStrictEqual(utxosConsumedBySingleXecSendTx); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a send all XEC tx [template]', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeSendAllTxTemplate, currentUtxosAfterSendAllTxTemplate, ), ).toStrictEqual(utxosConsumedBySendAllTxTemplate); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a send all XEC tx', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeSendAllTx, currentUtxosAfterSendAllTx, ), ).toStrictEqual(utxosConsumedBySendAllTx); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a single send XEC tx [template]', async () => { expect( whichUtxosWereConsumed( previousUtxosTemplate, currentUtxosAfterSingleXecSendTxTemplate, ), ).toStrictEqual(utxosConsumedBySingleXecSendTxTemplate); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a send eToken tx [template]', async () => { expect( whichUtxosWereConsumed( previousUtxosTemplate, currentUtxosAfterEtokenSendTxTemplate, ), ).toStrictEqual(utxosConsumedByEtokenSendTxTemplate); }); test('whichUtxosWereConsumed correctly identifies consumed utxos from a send eToken tx', async () => { expect( whichUtxosWereConsumed( previousUtxosBeforeEtokenSendTx, currentUtxosAfterEtokenSendTx, ), ).toStrictEqual(utxosConsumedByEtokenSendTx); }); test('addNewHydratedUtxos correctly adds new utxos object to existing hydratedUtxoDetails object', async () => { expect( addNewHydratedUtxos( newHydratedUtxosSingleTemplate, hydratedUtxoDetailsBeforeAddingTemplate, ), ).toStrictEqual(hydratedUtxoDetailsAfterAddingSingleUtxoTemplate); }); test('addNewHydratedUtxos correctly adds more than 20 new hydrated utxos to existing hydratedUtxoDetails object', async () => { expect( addNewHydratedUtxos( addedHydratedUtxosOverTwenty, existingHydratedUtxoDetails, ), ).toStrictEqual(existingHydratedUtxoDetailsAfterAdd); }); test('removeConsumedUtxos correctly removes a single utxo from hydratedUtxoDetails - template', async () => { expect( removeConsumedUtxos( consumedUtxoTemplate, hydratedUtxoDetailsBeforeConsumedTemplate, ), ).toStrictEqual(hydratedUtxoDetailsAfterRemovingConsumedUtxoTemplate); }); test('removeConsumedUtxos correctly removes a single utxo from hydratedUtxoDetails', async () => { expect( removeConsumedUtxos( consumedUtxos, hydratedUtxoDetailsBeforeRemovingConsumedUtxos, ), ).toStrictEqual(hydratedUtxoDetailsAfterRemovingConsumedUtxos); }); test('removeConsumedUtxos correctly removes more than twenty utxos from hydratedUtxoDetails', async () => { expect( removeConsumedUtxos( consumedUtxosMoreThanTwenty, hydratedUtxoDetailsBeforeRemovingConsumedUtxos, ), ).toStrictEqual( hydratedUtxoDetailsAfterRemovingMoreThanTwentyConsumedUtxos, ); }); test('removeConsumedUtxos correctly removes more than twenty utxos from multiple utxo objects from hydratedUtxoDetails', async () => { expect( removeConsumedUtxos( consumedUtxosMoreThanTwentyInRandomObjects, hydratedUtxoDetailsBeforeRemovingConsumedUtxos, ), ).toStrictEqual( hydratedUtxoDetailsAfterRemovingMoreThanTwentyConsumedUtxos, ); }); test('getUtxoCount correctly calculates the total for a utxo object with empty addresses [template]', async () => { expect(getUtxoCount(utxoCountSingleTemplate)).toStrictEqual(1); }); test('getUtxoCount correctly calculates the total for multiple utxos [template]', async () => { expect(getUtxoCount(utxoCountMultiTemplate)).toStrictEqual(12); }); test('areAllUtxosIncludedInIncrementallyHydratedUtxos correctly identifies all utxos are in incrementally hydrated utxos [template]', async () => { expect( areAllUtxosIncludedInIncrementallyHydratedUtxos( incrementalUtxosTemplate, incrementallyHydratedUtxosTemplate, ), ).toBe(true); }); test('areAllUtxosIncludedInIncrementallyHydratedUtxos returns false if a utxo in the utxo set is not in incrementally hydrated utxos [template]', async () => { expect( areAllUtxosIncludedInIncrementallyHydratedUtxos( incrementalUtxosTemplate, incrementallyHydratedUtxosTemplateMissing, ), ).toBe(false); }); test('areAllUtxosIncludedInIncrementallyHydratedUtxos correctly identifies all utxos are in incrementally hydrated utxos', async () => { expect( areAllUtxosIncludedInIncrementallyHydratedUtxos( utxosAfterSentTxIncremental, incrementallyHydratedUtxosAfterProcessing, ), ).toBe(true); }); test('areAllUtxosIncludedInIncrementallyHydratedUtxos returns false if a utxo in the utxo set is not in incrementally hydrated utxos', async () => { expect( areAllUtxosIncludedInIncrementallyHydratedUtxos( utxosAfterSentTxIncremental, incrementallyHydratedUtxosAfterProcessingOneMissing, ), ).toBe(false); }); test('areAllUtxosIncludedInIncrementallyHydratedUtxos returns false if utxo set is invalid', async () => { expect( areAllUtxosIncludedInIncrementallyHydratedUtxos( {}, incrementallyHydratedUtxosAfterProcessing, ), ).toBe(false); }); 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([]); }); }); diff --git a/web/cashtab/src/utils/cashMethods.js b/web/cashtab/src/utils/cashMethods.js index 5ac59194f..c2a06ea70 100644 --- a/web/cashtab/src/utils/cashMethods.js +++ b/web/cashtab/src/utils/cashMethods.js @@ -1,977 +1,980 @@ import { currency } from 'components/Common/Ticker'; import { isValidXecAddress, isValidEtokenAddress, isValidBchApiUtxoObject, isValidContactList, } from 'utils/validation'; import BigNumber from 'bignumber.js'; import cashaddr from 'ecashaddrjs'; 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 fromSmallestDenomination = ( amount, cashDecimals = currency.cashDecimals, ) => { const amountBig = new BigNumber(amount); const multiplier = new BigNumber(10 ** (-1 * cashDecimals)); const amountInBaseUnits = amountBig.times(multiplier); return amountInBaseUnits.toNumber(); }; export const toSmallestDenomination = ( 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 batchArray = (inputArray, batchSize) => { // take an array of n elements, return an array of arrays each of length batchSize const batchedArray = []; for (let i = 0; i < inputArray.length; i += batchSize) { const tempArray = inputArray.slice(i, i + batchSize); batchedArray.push(tempArray); } return batchedArray; }; export const flattenBatchedHydratedUtxos = batchedHydratedUtxoDetails => { // Return same result as if only the bulk API call were made // to do this, just need to move all utxos under one slpUtxos /* given [ { slpUtxos: [ { utxos: [], address: '', } ], }, { slpUtxos: [ { utxos: [], address: '', } ], } ] return [ { slpUtxos: [ { utxos: [], address: '' }, { utxos: [], address: '' }, ] } */ const flattenedBatchedHydratedUtxos = { slpUtxos: [] }; for (let i = 0; i < batchedHydratedUtxoDetails.length; i += 1) { const theseSlpUtxos = batchedHydratedUtxoDetails[i].slpUtxos[0]; flattenedBatchedHydratedUtxos.slpUtxos.push(theseSlpUtxos); } return flattenedBatchedHydratedUtxos; }; export const flattenContactList = contactList => { /* Converts contactList from array of objects of type {address: , name: } 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 = normalizeBalance(slpBalancesAndUtxos); liveWalletState.balances = balancesRebased; return liveWalletState; }; export const normalizeBalance = slpBalancesAndUtxos => { const totalBalanceInSatoshis = slpBalancesAndUtxos.nonSlpUtxos.reduce( (previousBalance, utxo) => previousBalance + utxo.value, 0, ); return { totalBalanceInSatoshis, totalBalance: fromSmallestDenomination(totalBalanceInSatoshis), }; }; 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; } export const confirmNonEtokenUtxos = (hydratedUtxos, nonEtokenUtxos) => { // scan through hydratedUtxoDetails for (let i = 0; i < hydratedUtxos.length; i += 1) { // Find utxos with txids matching nonEtokenUtxos if (nonEtokenUtxos.includes(hydratedUtxos[i].txid)) { // Confirm that such utxos are not eToken utxos hydratedUtxos[i].isValid = false; } } return hydratedUtxos; }; export const checkNullUtxosForTokenStatus = txDataResults => { const nonEtokenUtxos = []; for (let j = 0; j < txDataResults.length; j += 1) { const thisUtxoTxid = txDataResults[j].txid; const thisUtxoVout = txDataResults[j].details.vout; // Iterate over outputs for (let k = 0; k < thisUtxoVout.length; k += 1) { const thisOutput = thisUtxoVout[k]; if (thisOutput.scriptPubKey.type === 'nulldata') { const asmOutput = thisOutput.scriptPubKey.asm; if (asmOutput.includes('OP_RETURN 5262419')) { // then it's an eToken tx that has not been properly validated // Do not include it in nonEtokenUtxos // App will ignore it until SLPDB is able to validate it /* console.log( `utxo ${thisUtxoTxid} requires further eToken validation, ignoring`, );*/ } else { // Otherwise it's just an OP_RETURN tx that SLPDB has some issue with // It should still be in the user's utxo set // Include it in nonEtokenUtxos /* console.log( `utxo ${thisUtxoTxid} is not an eToken tx, adding to nonSlpUtxos`, ); */ nonEtokenUtxos.push(thisUtxoTxid); } } } } return nonEtokenUtxos; }; /* 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.Path245.publicKey + !wallet.Path145.hash160 || + !wallet.Path245.publicKey || + !wallet.Path245.hash160 ) { return true; } return false; }; export const isExcludedUtxo = (utxo, utxoArray) => { /* utxo is a single utxo of model { height: 724992 tx_hash: "8d4bdedb7c4443412e0c2f316a330863aef54d9ba73560ca60cca6408527b247" tx_pos: 0 value: 10200 } utxoArray is an array of utxos */ let isExcludedUtxo = true; const { tx_hash, tx_pos, value } = utxo; for (let i = 0; i < utxoArray.length; i += 1) { const thisUtxo = utxoArray[i]; // NOTE // You can't match height, as this changes from 0 to blockheight after confirmation //const thisUtxoHeight = thisUtxo.height; const thisUtxoTxid = thisUtxo.tx_hash; const thisUtxoTxPos = thisUtxo.tx_pos; const thisUtxoValue = thisUtxo.value; // If you find a utxo such that each object key is identical if ( tx_hash === thisUtxoTxid && tx_pos === thisUtxoTxPos && value === thisUtxoValue ) { // Then this utxo is not excluded from the array isExcludedUtxo = false; } } return isExcludedUtxo; }; export const whichUtxosWereAdded = (previousUtxos, currentUtxos) => { let utxosAddedFlag = false; const utxosAdded = []; // Iterate over currentUtxos // For each currentUtxo -- does it exist in previousUtxos? // If no, it's added // Note that the inputs are arrays of arrays, model /* previousUtxos = [{address: 'string', utxos: []}, ...] */ // Iterate over the currentUtxos array of {address: 'string', utxos: []} objects for (let i = 0; i < currentUtxos.length; i += 1) { // Take the first object const thisCurrentUtxoObject = currentUtxos[i]; const thisCurrentUtxoObjectAddress = thisCurrentUtxoObject.address; const thisCurrentUtxoObjectUtxos = thisCurrentUtxoObject.utxos; // Iterate over the previousUtxos array of {address: 'string', utxos: []} objects for (let j = 0; j < previousUtxos.length; j += 1) { const thisPreviousUtxoObject = previousUtxos[j]; const thisPreviousUtxoObjectAddress = thisPreviousUtxoObject.address; // When you find the utxos object at the same address if ( thisCurrentUtxoObjectAddress === thisPreviousUtxoObjectAddress ) { // Create a utxosAddedObject with the address const utxosAddedObject = { address: thisCurrentUtxoObjectAddress, utxos: [], }; utxosAdded.push(utxosAddedObject); // Grab the previousUtxoObject utxos array. thisCurrentUtxoObjectUtxos has changed compared to thisPreviousUtxoObjectUtxos const thisPreviousUtxoObjectUtxos = thisPreviousUtxoObject.utxos; // To see if any utxos exist in thisCurrentUtxoObjectUtxos that do not exist in thisPreviousUtxoObjectUtxos // iterate over thisPreviousUtxoObjectUtxos for each utxo in thisCurrentUtxoObjectUtxos for (let k = 0; k < thisCurrentUtxoObjectUtxos.length; k += 1) { const thisCurrentUtxo = thisCurrentUtxoObjectUtxos[k]; if ( isExcludedUtxo( thisCurrentUtxo, thisPreviousUtxoObjectUtxos, ) ) { // If thisCurrentUtxo was not in the corresponding previous utxos // Then it was added utxosAdded[j].utxos.push(thisCurrentUtxo); utxosAddedFlag = true; } } } } } // If utxos were added, return them if (utxosAddedFlag) { return utxosAdded; } // Else return false return utxosAddedFlag; }; export const whichUtxosWereConsumed = (previousUtxos, currentUtxos) => { let utxosConsumedFlag = false; const utxosConsumed = []; // Iterate over previousUtxos // For each previousUtxo -- does it exist in currentUtxos? // If no, it's consumed // Note that the inputs are arrays of arrays, model /* previousUtxos = [{address: 'string', utxos: []}, ...] */ // Iterate over the previousUtxos array of {address: 'string', utxos: []} objects for (let i = 0; i < previousUtxos.length; i += 1) { // Take the first object const thisPreviousUtxoObject = previousUtxos[i]; const thisPreviousUtxoObjectAddress = thisPreviousUtxoObject.address; const thisPreviousUtxoObjectUtxos = thisPreviousUtxoObject.utxos; // Iterate over the currentUtxos array of {address: 'string', utxos: []} objects for (let j = 0; j < currentUtxos.length; j += 1) { const thisCurrentUtxoObject = currentUtxos[j]; const thisCurrentUtxoObjectAddress = thisCurrentUtxoObject.address; // When you find the utxos object at the same address if ( thisCurrentUtxoObjectAddress === thisPreviousUtxoObjectAddress ) { // Create a utxosConsumedObject with the address const utxosConsumedObject = { address: thisCurrentUtxoObjectAddress, utxos: [], }; utxosConsumed.push(utxosConsumedObject); // Grab the currentUtxoObject utxos array. thisCurrentUtxoObjectUtxos has changed compared to thisPreviousUtxoObjectUtxos const thisCurrentUtxoObjectUtxos = thisCurrentUtxoObject.utxos; // To see if any utxos exist in thisPreviousUtxoObjectUtxos that do not exist in thisCurrentUtxoObjectUtxos // iterate over thisCurrentUtxoObjectUtxos for each utxo in thisPreviousUtxoObjectUtxos for ( let k = 0; k < thisPreviousUtxoObjectUtxos.length; k += 1 ) { const thisPreviousUtxo = thisPreviousUtxoObjectUtxos[k]; // If thisPreviousUtxo was not in the corresponding current utxos if ( isExcludedUtxo( thisPreviousUtxo, thisCurrentUtxoObjectUtxos, ) ) { // Then it was consumed utxosConsumed[j].utxos.push(thisPreviousUtxo); utxosConsumedFlag = true; } } } } } // If utxos were consumed, return them if (utxosConsumedFlag) { return utxosConsumed; } // Else return false return utxosConsumedFlag; }; export const addNewHydratedUtxos = ( addedHydratedUtxos, hydratedUtxoDetails, ) => { const theseAdditionalHydratedUtxos = addedHydratedUtxos.slpUtxos; for (let i = 0; i < theseAdditionalHydratedUtxos.length; i += 1) { const thisHydratedUtxoObj = theseAdditionalHydratedUtxos[i]; hydratedUtxoDetails.slpUtxos.push(thisHydratedUtxoObj); } return hydratedUtxoDetails; // Add hydrateUtxos(addedUtxos) to hydratedUtxoDetails /* e.g. add this { "slpUtxos": [ { "utxos": [ { "height": 725886, "tx_hash": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "tx_pos": 0, "value": 3300, "txid": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "vout": 0, "isValid": false } ], "address": "bitcoincash:qz2708636snqhsxu8wnlka78h6fdp77ar5ulhz04hr" } ] } to this { "slpUtxos": [ { "utxos": [ { "height": 725886, "tx_hash": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "tx_pos": 0, "value": 3300, "txid": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "vout": 0, "isValid": false } ... up to 20 ], "address": "bitcoincash:qz2708636snqhsxu8wnlka78h6fdp77ar5ulhz04hr" }, { "utxos": [ { "height": 725886, "tx_hash": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "tx_pos": 0, "value": 3300, "txid": "29985c01444bf80ade764e5d40d7ec2c12317e03301243170139c75f20c51f78", "vout": 0, "isValid": false } ... up to 20 ], "address": "bitcoincash:qz2708636snqhsxu8wnlka78h6fdp77ar5ulhz04hr" } , ... a bunch of these in batches of 20 ] } */ }; export const removeConsumedUtxos = (consumedUtxos, hydratedUtxoDetails) => { let hydratedUtxoDetailsWithConsumedUtxosRemoved = hydratedUtxoDetails; const slpUtxosArray = hydratedUtxoDetails.slpUtxos; // Iterate over consumedUtxos // Every utxo in consumedUtxos must be removed from hydratedUtxoDetails for (let i = 0; i < consumedUtxos.length; i += 1) { const thisConsumedUtxoObject = consumedUtxos[i]; // {address: 'string', utxos: [{},{},...{}]} const thisConsumedUtxoObjectAddr = thisConsumedUtxoObject.address; const thisConsumedUtxoObjectUtxoArray = thisConsumedUtxoObject.utxos; for (let j = 0; j < thisConsumedUtxoObjectUtxoArray.length; j += 1) { const thisConsumedUtxo = thisConsumedUtxoObjectUtxoArray[j]; // Iterate through slpUtxosArray to find thisConsumedUtxo slpUtxosArrayLoop: for ( let k = 0; k < slpUtxosArray.length; k += 1 ) { const thisSlpUtxosArrayUtxoObject = slpUtxosArray[k]; // {address: 'string', utxos: [{},{},...{}]} const thisSlpUtxosArrayUtxoObjectAddr = thisSlpUtxosArrayUtxoObject.address; // If this address matches the address of the consumed utxo, check for a consumedUtxo match // Note, slpUtxos may have many utxo objects with the same address, need to check them all until you find and remove this consumed utxo if ( thisConsumedUtxoObjectAddr === thisSlpUtxosArrayUtxoObjectAddr ) { const thisSlpUtxosArrayUtxoObjectUtxoArray = thisSlpUtxosArrayUtxoObject.utxos; // Iterate to find it and remove it for ( let m = 0; m < thisSlpUtxosArrayUtxoObjectUtxoArray.length; m += 1 ) { const thisHydratedUtxo = thisSlpUtxosArrayUtxoObjectUtxoArray[m]; if ( thisConsumedUtxo.tx_hash === thisHydratedUtxo.tx_hash && thisConsumedUtxo.tx_pos === thisHydratedUtxo.tx_pos && thisConsumedUtxo.value === thisHydratedUtxo.value ) { // remove it hydratedUtxoDetailsWithConsumedUtxosRemoved.slpUtxos[ k ].utxos.splice(m, 1); // go to the next consumedUtxo break slpUtxosArrayLoop; } } } } } } return hydratedUtxoDetailsWithConsumedUtxosRemoved; }; export const getUtxoCount = utxos => { // return how many utxos // return false if input is invalid /* Both utxos and hydratedUtxoDetails.slpUtxos are build like so [ { address: 'string', utxos: [{}, {}, {}...{}] }, { address: 'string', utxos: [{}, {}, {}...{}] }, { address: 'string', utxos: [{}, {}, {}...{}] }, ] We want a function that quickly determines how many utxos are here */ // First, validate that you are getting a valid bch-api utxo set // if you are not, then return false -- which would cause areAllUtxosIncludedInIncrementallyHydratedUtxos to return false and calculate utxo set the legacy way const isValidUtxoObject = isValidBchApiUtxoObject(utxos); if (!isValidUtxoObject) { return false; } let utxoCount = 0; for (let i = 0; i < utxos.length; i += 1) { const thisUtxoArrLength = utxos[i].utxos.length; utxoCount += thisUtxoArrLength; } return utxoCount; }; export const areAllUtxosIncludedInIncrementallyHydratedUtxos = ( utxos, incrementallyHydratedUtxos, ) => { let incrementallyHydratedUtxosIncludesAllUtxosInLatestUtxoApiFetch = false; // check const { slpUtxos } = incrementallyHydratedUtxos; // Iterate over utxos array for (let i = 0; i < utxos.length; i += 1) { const thisUtxoObject = utxos[i]; const thisUtxoObjectAddr = thisUtxoObject.address; const thisUtxoObjectUtxos = thisUtxoObject.utxos; let utxoFound; for (let j = 0; j < thisUtxoObjectUtxos.length; j += 1) { const thisUtxo = thisUtxoObjectUtxos[j]; utxoFound = false; // Now iterate over slpUtxos to find it slpUtxosLoop: for (let k = 0; k < slpUtxos.length; k += 1) { const thisSlpUtxosObject = slpUtxos[k]; const thisSlpUtxosObjectAddr = thisSlpUtxosObject.address; if (thisUtxoObjectAddr === thisSlpUtxosObjectAddr) { const thisSlpUtxosObjectUtxos = thisSlpUtxosObject.utxos; for ( let m = 0; m < thisSlpUtxosObjectUtxos.length; m += 1 ) { const thisSlpUtxo = thisSlpUtxosObjectUtxos[m]; if ( thisUtxo.tx_hash === thisSlpUtxo.tx_hash && thisUtxo.tx_pos === thisSlpUtxo.tx_pos && thisUtxo.value === thisSlpUtxo.value ) { utxoFound = true; // goto next utxo break slpUtxosLoop; } } } if (k === slpUtxos.length - 1 && !utxoFound) { // return false return incrementallyHydratedUtxosIncludesAllUtxosInLatestUtxoApiFetch; } } } } // It's possible that hydratedUtxoDetails includes every utxo from the utxos array, but for some reason also includes additional utxos const utxosInUtxos = getUtxoCount(utxos); const utxosInIncrementallyHydratedUtxos = getUtxoCount(slpUtxos); if ( !utxosInUtxos || !utxosInIncrementallyHydratedUtxos || utxosInUtxos !== utxosInIncrementallyHydratedUtxos ) { return incrementallyHydratedUtxosIncludesAllUtxosInLatestUtxoApiFetch; } // If you make it here, good to go incrementallyHydratedUtxosIncludesAllUtxosInLatestUtxoApiFetch = true; return incrementallyHydratedUtxosIncludesAllUtxosInLatestUtxoApiFetch; };