diff --git a/cashtab/src/components/Send/Send.js b/cashtab/src/components/Send/Send.js
index 36dddfe07..67fffe1df 100644
--- a/cashtab/src/components/Send/Send.js
+++ b/cashtab/src/components/Send/Send.js
@@ -1,1010 +1,1009 @@
import React, { useState, useEffect } from 'react';
import { useLocation } from 'react-router-dom';
import PropTypes from 'prop-types';
import { WalletContext } from 'utils/context';
import {
AntdFormWrapper,
SendBchInput,
DestinationAddressSingle,
DestinationAddressMulti,
} from 'components/Common/EnhancedInputs';
import { ThemedMailOutlined } from 'components/Common/CustomIcons';
import { CustomCollapseCtn } from 'components/Common/StyledCollapse';
import { Form, message, Modal, Alert, Input } from 'antd';
import { Row, Col, Switch } from 'antd';
import PrimaryButton, { DisabledButton } from 'components/Common/PrimaryButton';
import useWindowDimensions from 'hooks/useWindowDimensions';
import {
sendXecNotification,
errorNotification,
} from 'components/Common/Notifications';
import { isMobile, isIOS, isSafari } from 'react-device-detect';
import {
parseAddressForParams,
sumOneToManyXec,
toSatoshis,
} from 'utils/cashMethods';
import { Event } from 'utils/GoogleAnalytics';
import {
fiatToCrypto,
shouldRejectAmountInput,
isValidXecAddress,
isValidEtokenAddress,
isAliasFormat,
isValidMultiSendUserInput,
} from 'utils/validation';
import BalanceHeader from 'components/Common/BalanceHeader';
import BalanceHeaderFiat from 'components/Common/BalanceHeaderFiat';
import {
ZeroBalanceHeader,
ConvertAmount,
AlertMsg,
WalletInfoCtn,
SidePaddingCtn,
FormLabel,
TxLink,
MsgBytesizeError,
} from 'components/Common/Atoms';
-import {
- getWalletState,
- fromSatoshisToXec,
- calcFee,
- getMessageByteSize,
-} from 'utils/cashMethods';
+import { getWalletState, fromSatoshisToXec, calcFee } from 'utils/cashMethods';
import { sendXec, getMultisendTargetOutputs } from 'transactions';
-import { getCashtabMsgTargetOutput, getAirdropTargetOutput } from 'opreturn';
+import {
+ getCashtabMsgTargetOutput,
+ getAirdropTargetOutput,
+ getCashtabMsgByteCount,
+} from 'opreturn';
import ApiError from 'components/Common/ApiError';
import { formatFiatBalance, formatBalance } from 'utils/formatting';
import styled from 'styled-components';
import WalletLabel from 'components/Common/WalletLabel.js';
import { opReturn as opreturnConfig } from 'config/opreturn';
import { explorer } from 'config/explorer';
import { queryAliasServer } from 'utils/aliasUtils';
import { supportedFiatCurrencies } from 'config/cashtabSettings';
import appConfig from 'config/app';
import aliasSettings from 'config/alias';
const { TextArea } = Input;
const TextAreaLabel = styled.div`
text-align: left;
color: ${props => props.theme.forms.text};
padding-left: 1px;
white-space: nowrap;
`;
const AliasAddressPreviewLabel = styled.div`
text-align: center;
color: ${props => props.theme.forms.text};
padding-left: 1px;
white-space: nowrap;
`;
const AmountPreviewCtn = styled.div`
display: flex;
flex-direction: column;
justify-content: top;
max-height: 1rem;
`;
const SendInputCtn = styled.div`
.ant-form-item-explain-error {
@media (max-width: 300px) {
font-size: 12px;
}
}
`;
const LocaleFormattedValue = styled.h3`
color: ${props => props.theme.contrast};
font-weight: bold;
margin-bottom: 0;
`;
const SendAddressHeader = styled.div`
display: flex;
align-items: center;
`;
const DestinationAddressSingleCtn = styled.div``;
const DestinationAddressMultiCtn = styled.div``;
const ExpandingAddressInputCtn = styled.div`
min-height: 14rem;
${DestinationAddressSingleCtn} {
overflow: hidden;
transition: ${props =>
props.open
? 'max-height 200ms ease-in, opacity 200ms ease-out'
: 'max-height 200ms cubic-bezier(0, 1, 0, 1), opacity 200ms ease-in'};
max-height: ${props => (props.open ? '0rem' : '12rem')};
opacity: ${props => (props.open ? 0 : 1)};
}
${DestinationAddressMultiCtn} {
overflow: hidden;
transition: ${props =>
props.open
? 'max-height 200ms ease-in, transform 200ms ease-out, opacity 200ms ease-in'
: 'max-height 200ms cubic-bezier(0, 1, 0, 1), transform 200ms ease-out'};
max-height: ${props => (props.open ? '13rem' : '0rem')};
transform: ${props =>
props.open ? 'translateY(0%)' : 'translateY(100%)'};
opacity: ${props => (props.open ? 1 : 0)};
}
`;
const PanelHeaderCtn = styled.div`
display: flex;
justify-content: center;
align-items: center;
gap: 1rem;
`;
const SendBCH = ({ passLoadingStatus }) => {
// use balance parameters from wallet.state object and not legacy balances parameter from walletState, if user has migrated wallet
// this handles edge case of user with old wallet who has not opened latest Cashtab version yet
// If the wallet object from ContextValue has a `state key`, then check which keys are in the wallet object
// Else set it as blank
const ContextValue = React.useContext(WalletContext);
const location = useLocation();
const {
wallet,
fiatPrice,
apiError,
cashtabSettings,
changeCashtabSettings,
chronik,
cashtabCache,
} = ContextValue;
const walletState = getWalletState(wallet);
const { balances, nonSlpUtxos } = walletState;
// Modal settings
const [isOneToManyXECSend, setIsOneToManyXECSend] = useState(false);
const [opReturnMsg, setOpReturnMsg] = useState(false);
// Get device window width
// If this is less than 769, the page will open with QR scanner open
const { width } = useWindowDimensions();
// Load with QR code open if device is mobile and NOT iOS + anything but safari
const scannerSupported =
cashtabSettings &&
cashtabSettings.autoCameraOn === true &&
width < 769 &&
isMobile &&
!(isIOS && !isSafari);
const [formData, setFormData] = useState({
value: '',
address: '',
airdropTokenId: '',
});
const [queryStringText, setQueryStringText] = useState(null);
const [sendBchAddressError, setSendBchAddressError] = useState(false);
const [sendBchAmountError, setSendBchAmountError] = useState(false);
const [isMsgError, setIsMsgError] = useState(false);
const [aliasInputAddress, setAliasInputAddress] = useState(false);
const [selectedCurrency, setSelectedCurrency] = useState(appConfig.ticker);
// Support cashtab button from web pages
const [txInfoFromUrl, setTxInfoFromUrl] = useState(false);
// Show a confirmation modal on transactions created by populating form from web page button
const [isModalVisible, setIsModalVisible] = useState(false);
// Airdrop transactions embed the additional tokenId (32 bytes), along with prefix (4 bytes) and two pushdata (2 bytes)
// hence setting airdrop tx message limit to 38 bytes less than opreturnConfig.cashtabMsgByteLimit
const pushDataByteCount = 1;
const prefixByteCount = 4;
const tokenIdByteCount = 32;
const localAirdropTxAddedBytes =
pushDataByteCount +
tokenIdByteCount +
pushDataByteCount +
prefixByteCount; // 38
const [airdropFlag, setAirdropFlag] = useState(false);
const userLocale = navigator.language;
const clearInputForms = () => {
setFormData({
value: '',
address: '',
});
setOpReturnMsg(''); // OP_RETURN message has its own state field
setAliasInputAddress(false); // clear alias address preview
};
const checkForConfirmationBeforeSendXec = () => {
if (txInfoFromUrl || queryStringText !== null) {
setIsModalVisible(true);
} else if (cashtabSettings.sendModal) {
setIsModalVisible(cashtabSettings.sendModal);
} else {
// if the user does not have the send confirmation enabled in settings then send directly
send();
}
};
const handleOk = () => {
setIsModalVisible(false);
send();
};
const handleCancel = () => {
setIsModalVisible(false);
};
// If the balance has changed, unlock the UI
// This is redundant, if backend has refreshed in 1.75s timeout below, UI will already be unlocked
useEffect(() => {
passLoadingStatus(false);
}, [balances.totalBalance]);
useEffect(() => {
// only run this useEffect block if cashtabCache is defined
if (!cashtabCache || typeof cashtabCache === 'undefined') {
return;
}
// Manually parse for txInfo object on page load when Send.js is loaded with a query string
// if this was routed from Wallet screen's Reply to message link then prepopulate the address and value field
if (location && location.state && location.state.replyAddress) {
setFormData({
address: location.state.replyAddress,
value: `${fromSatoshisToXec(appConfig.dustSats).toString()}`,
});
}
// if this was routed from the Contact List
if (location && location.state && location.state.contactSend) {
setFormData({
address: location.state.contactSend,
});
// explicitly trigger the address validation upon navigation from contact list
handleAddressChange({
target: {
name: 'address',
value: location.state.contactSend,
},
});
}
// if this was routed from the Airdrop screen's Airdrop Calculator then
// switch to multiple recipient mode and prepopulate the recipients field
if (
location &&
location.state &&
location.state.airdropRecipients &&
location.state.airdropTokenId
) {
setIsOneToManyXECSend(true);
setFormData({
address: location.state.airdropRecipients,
airdropTokenId: location.state.airdropTokenId,
});
// validate the airdrop outputs from the calculator
handleMultiAddressChange({
target: {
value: location.state.airdropRecipients,
},
});
setAirdropFlag(true);
}
// Do not set txInfo in state if query strings are not present
if (
!window.location ||
!window.location.hash ||
window.location.hash === '#/send'
) {
return;
}
const txInfoArr = window.location.hash.split('?')[1].split('&');
// Iterate over this to create object
const txInfo = {};
for (let i = 0; i < txInfoArr.length; i += 1) {
let txInfoKeyValue = txInfoArr[i].split('=');
let key = txInfoKeyValue[0];
let value = txInfoKeyValue[1];
txInfo[key] = value;
}
console.log(`txInfo from page params`, txInfo);
setTxInfoFromUrl(txInfo);
populateFormsFromUrl(txInfo);
}, [cashtabCache]);
function populateFormsFromUrl(txInfo) {
if (txInfo && txInfo.address && txInfo.value) {
setFormData({
address: txInfo.address,
value: txInfo.value,
});
}
}
function handleSendXecError(errorObj, oneToManyFlag) {
// Set loading to false here as well, as balance may not change depending on where error occured in try loop
passLoadingStatus(false);
let message;
if (
errorObj.error &&
errorObj.error.includes(
'too-long-mempool-chain, too many unconfirmed ancestors [limit: 50] (code 64)',
)
) {
message = `The ${appConfig.ticker} you are trying to send has too many unconfirmed ancestors to send (limit 50). Sending will be possible after a block confirmation. Try again in about 10 minutes.`;
} else {
message =
errorObj.message || errorObj.error || JSON.stringify(errorObj);
}
if (oneToManyFlag) {
errorNotification(errorObj, message, 'Sending XEC one to many');
} else {
errorNotification(errorObj, message, 'Sending XEC');
}
}
async function send() {
setFormData({
...formData,
});
// Initialize targetOutputs for this tx
let targetOutputs = [];
// If you have an OP_RETURN output, add it at index 0
// Aesthetic choice, easier to see when checking on block explorer
if (airdropFlag) {
// Airdrop txs require special OP_RETURN handling
targetOutputs.push(
getAirdropTargetOutput(
formData.airdropTokenId,
opReturnMsg ? opReturnMsg : '',
),
);
} else if (opReturnMsg !== false && opReturnMsg !== '') {
// If not an airdrop msg, add opReturnMsg as a Cashtab Msg, if it exists
targetOutputs.push(getCashtabMsgTargetOutput(opReturnMsg));
}
if (isOneToManyXECSend) {
// Handle XEC send to multiple addresses
targetOutputs = targetOutputs.concat(
getMultisendTargetOutputs(formData.address),
);
Event('Send.js', 'SendToMany', selectedCurrency);
} else {
// Handle XEC send to one address
let cleanAddress;
// check state on whether this is an alias or ecash address
if (aliasInputAddress) {
cleanAddress = aliasInputAddress;
} else {
// Get the non-alias param-free address
cleanAddress = formData.address.split('?')[0];
}
// Calculate the amount in XEC
let xecSendValue = formData.value;
if (selectedCurrency !== 'XEC') {
// If fiat send is selected, calculate send amount in XEC
xecSendValue = fiatToCrypto(xecSendValue, fiatPrice);
}
const satoshisToSend = toSatoshis(xecSendValue);
targetOutputs.push({
address: cleanAddress,
value: satoshisToSend,
});
Event('Send.js', 'Send', selectedCurrency);
}
passLoadingStatus(true);
// Send and notify
try {
const txObj = await sendXec(
chronik,
wallet,
targetOutputs,
appConfig.defaultFee,
);
sendXecNotification(
`${explorer.blockExplorerUrl}/tx/${txObj.response.txid}`,
);
clearInputForms();
setAirdropFlag(false);
} catch (err) {
handleSendXecError(err, isOneToManyXECSend);
}
}
const handleAddressChange = async e => {
setAliasInputAddress(false); // clear alias address preview
const { value, name } = e.target;
let error = false;
let addressString = value;
// parse address for parameters
const addressInfo = parseAddressForParams(addressString);
const { address, queryString, amount } = addressInfo;
// validate address
const isValid = isValidXecAddress(addressInfo.address);
// Store query string in state (disable currency selection if loaded from query string)
setQueryStringText(queryString);
// Is this valid address?
if (!isValid) {
error = `Invalid address`;
// If valid address but token format
if (isValidEtokenAddress(address)) {
error = `eToken addresses are not supported for ${appConfig.ticker} sends`;
}
}
// if input is invalid as an ecash address, check if it's a valid alias
// otherwise the invalid address error above will be displayed
const isAliasInput = isAliasFormat(address);
if (isAliasInput) {
// reset the invalid address check from above
error = false;
// extract alias without the `.xec`
const aliasName = address.slice(0, address.length - 4);
// retrieve the alias details for `aliasName` from alias-server
let aliasDetails;
try {
aliasDetails = await queryAliasServer('alias', aliasName);
if (!aliasDetails.address) {
error =
'eCash Alias does not exist or yet to receive 1 confirmation';
setAliasInputAddress(false);
} else {
// Valid address response returned
setAliasInputAddress(aliasDetails.address);
}
} catch (err) {
console.log(`handleAddressChange(): error retrieving alias`);
setAliasInputAddress(false);
errorNotification(null, 'Error retrieving alias info');
}
}
setSendBchAddressError(error);
// Set amount if it's in the query string
if (amount !== null) {
// Set currency to BCHA
setSelectedCurrency(appConfig.ticker);
// Use this object to mimic user input and get validation for the value
let amountObj = {
target: {
name: 'value',
value: amount,
},
};
handleBchAmountChange(amountObj);
setFormData({
...formData,
value: amount,
});
}
// Set address field to user input
setFormData(p => ({
...p,
[name]: value,
}));
};
const handleMultiAddressChange = e => {
const { value, name } = e.target;
let errorOrIsValid = isValidMultiSendUserInput(value);
// If you get an error msg, set it. If validation is good, clear error msg.
setSendBchAddressError(
typeof errorOrIsValid === 'string' ? errorOrIsValid : false,
);
// Set address field to user input
setFormData(p => ({
...p,
[name]: value,
}));
};
const handleSelectedCurrencyChange = e => {
setSelectedCurrency(e);
// Clear input field to prevent accidentally sending 1 BCH instead of 1 USD
setFormData(p => ({
...p,
value: '',
}));
};
const handleBchAmountChange = e => {
const { value, name } = e.target;
let bchValue = value;
const error = shouldRejectAmountInput(
bchValue,
selectedCurrency,
fiatPrice,
balances.totalBalance,
);
setSendBchAmountError(error);
setFormData(p => ({
...p,
[name]: value,
}));
};
const handleMsgChange = e => {
const { value } = e.target;
let msgError = false;
- const msgByteSize = getMessageByteSize(value);
+ const msgByteSize = getCashtabMsgByteCount(value);
const maxSize =
location && location.state && location.state.airdropTokenId
? opreturnConfig.cashtabMsgByteLimit - localAirdropTxAddedBytes
: opreturnConfig.cashtabMsgByteLimit;
if (msgByteSize > maxSize) {
msgError = `Message can not exceed ${maxSize} bytes`;
}
setIsMsgError(msgError);
setOpReturnMsg(e.target.value);
};
const onMax = async () => {
// Clear amt error
setSendBchAmountError(false);
// Set currency to BCH
setSelectedCurrency(appConfig.ticker);
try {
const txFeeSats = calcFee(nonSlpUtxos);
const txFeeBch = txFeeSats / 10 ** appConfig.cashDecimals;
let value =
balances.totalBalance - txFeeBch >= 0
? (balances.totalBalance - txFeeBch).toFixed(
appConfig.cashDecimals,
)
: 0;
setFormData({
...formData,
value,
});
} catch (err) {
console.log(`Error in onMax:`);
console.log(err);
message.error(
'Unable to calculate the max value due to network errors',
);
}
};
// Display price in USD below input field for send amount, if it can be calculated
let fiatPriceString = '';
if (fiatPrice !== null && !isNaN(formData.value)) {
if (selectedCurrency === appConfig.ticker) {
// calculate conversion to fiatPrice
fiatPriceString = `${(fiatPrice * Number(formData.value)).toFixed(
2,
)}`;
// formats to fiat locale style
fiatPriceString = formatFiatBalance(
Number(fiatPriceString),
userLocale,
);
// insert symbol and currency before/after the locale formatted fiat balance
fiatPriceString = `${
cashtabSettings
? `${
supportedFiatCurrencies[cashtabSettings.fiatCurrency]
.symbol
} `
: '$ '
} ${fiatPriceString} ${
cashtabSettings && cashtabSettings.fiatCurrency
? cashtabSettings.fiatCurrency.toUpperCase()
: 'USD'
}`;
} else {
fiatPriceString = `${
formData.value
? formatFiatBalance(
Number(fiatToCrypto(formData.value, fiatPrice)),
userLocale,
)
: formatFiatBalance(0, userLocale)
} ${appConfig.ticker}`;
}
}
const priceApiError = fiatPrice === null && selectedCurrency !== 'XEC';
return (
<>
<Modal
title="Confirm Send"
open={isModalVisible}
onOk={handleOk}
onCancel={handleCancel}
>
<p>
{isOneToManyXECSend ? (
<>
Are you sure you want to send{' '}
{sumOneToManyXec(
formData.address.split('\n'),
).toLocaleString(userLocale, {
maximumFractionDigits: 2,
})}{' '}
XEC in the following transaction?
<br />
<br />
{formData.address}
</>
) : (
`Are you sure you want to send ${formData.value}${' '}
${selectedCurrency} to ${
queryStringText === null
? formData.address
: formData.address.slice(
0,
formData.address.indexOf('?'),
)
}?`
)}
</p>
</Modal>
<WalletInfoCtn>
<WalletLabel
name={wallet.name}
cashtabSettings={cashtabSettings}
changeCashtabSettings={changeCashtabSettings}
></WalletLabel>
{!balances.totalBalance ? (
<ZeroBalanceHeader>
You currently have 0 {appConfig.ticker}
<br />
Deposit some funds to use this feature
</ZeroBalanceHeader>
) : (
<>
<BalanceHeader
balance={balances.totalBalance}
ticker={appConfig.ticker}
cashtabSettings={cashtabSettings}
/>
<BalanceHeaderFiat
balance={balances.totalBalance}
settings={cashtabSettings}
fiatPrice={fiatPrice}
/>
</>
)}
</WalletInfoCtn>
<SidePaddingCtn>
<Row type="flex">
<Col span={24}>
<Form
style={{
width: 'auto',
marginTop: '40px',
}}
>
<SendAddressHeader>
{' '}
<FormLabel>Send to</FormLabel>
<TextAreaLabel>
Multiple Recipients:
<Switch
defaultunchecked="true"
checked={isOneToManyXECSend}
onChange={() => {
setIsOneToManyXECSend(
!isOneToManyXECSend,
);
// Do not persist multisend input to single send and vice versa
clearInputForms();
}}
style={{
marginBottom: '7px',
}}
/>
</TextAreaLabel>
</SendAddressHeader>
<ExpandingAddressInputCtn open={isOneToManyXECSend}>
<SendInputCtn>
<DestinationAddressSingleCtn>
<DestinationAddressSingle
style={{ marginBottom: '0px' }}
loadWithCameraOpen={
location &&
location.state &&
location.state.replyAddress
? false
: scannerSupported
}
validateStatus={
sendBchAddressError
? 'error'
: ''
}
help={
sendBchAddressError
? sendBchAddressError
: ''
}
onScan={result =>
handleAddressChange({
target: {
name: 'address',
value: result,
},
})
}
inputProps={{
placeholder:
aliasSettings.aliasEnabled
? `Address or Alias`
: `Address`,
name: 'address',
onChange: e =>
handleAddressChange(e),
required: true,
value: formData.address,
}}
></DestinationAddressSingle>
<AliasAddressPreviewLabel>
<TxLink
key={aliasInputAddress}
href={`${explorer.blockExplorerUrl}/address/${aliasInputAddress}`}
target="_blank"
rel="noreferrer"
>
{aliasInputAddress &&
`${aliasInputAddress.slice(
0,
10,
)}...${aliasInputAddress.slice(
-5,
)}`}
</TxLink>
</AliasAddressPreviewLabel>
<FormLabel>Amount</FormLabel>
<SendBchInput
activeFiatCode={
cashtabSettings &&
cashtabSettings.fiatCurrency
? cashtabSettings.fiatCurrency.toUpperCase()
: 'USD'
}
validateStatus={
sendBchAmountError
? 'error'
: ''
}
help={
sendBchAmountError
? sendBchAmountError
: ''
}
onMax={onMax}
inputProps={{
name: 'value',
dollar:
selectedCurrency === 'USD'
? 1
: 0,
placeholder: 'Amount',
onChange: e =>
handleBchAmountChange(e),
required: true,
value: formData.value,
disabled: priceApiError,
}}
selectProps={{
value: selectedCurrency,
disabled:
queryStringText !== null,
onChange: e =>
handleSelectedCurrencyChange(
e,
),
}}
></SendBchInput>
</DestinationAddressSingleCtn>
{priceApiError && (
<AlertMsg>
Error fetching fiat price. Setting
send by{' '}
{supportedFiatCurrencies[
cashtabSettings.fiatCurrency
].slug.toUpperCase()}{' '}
disabled
</AlertMsg>
)}
</SendInputCtn>
<>
<DestinationAddressMultiCtn>
<DestinationAddressMulti
validateStatus={
sendBchAddressError
? 'error'
: ''
}
help={
sendBchAddressError
? sendBchAddressError
: ''
}
inputProps={{
placeholder: `One address & value per line, separated by comma \ne.g. \necash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8,500 \necash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,700`,
name: 'address',
onChange: e =>
handleMultiAddressChange(e),
required: true,
value: formData.address,
}}
></DestinationAddressMulti>
</DestinationAddressMultiCtn>
</>
<AmountPreviewCtn>
{!priceApiError && !isOneToManyXECSend && (
<>
<LocaleFormattedValue>
{!isNaN(formData.value)
? formatBalance(
formData.value,
userLocale,
) +
' ' +
selectedCurrency
: ''}
</LocaleFormattedValue>
<ConvertAmount>
{fiatPriceString !== '' && '='}{' '}
{fiatPriceString}
</ConvertAmount>
</>
)}
</AmountPreviewCtn>
</ExpandingAddressInputCtn>
<div
style={{
paddingTop: '1rem',
}}
>
{!balances.totalBalance ||
apiError ||
sendBchAmountError ||
sendBchAddressError ||
isMsgError ||
priceApiError ||
(!isOneToManyXECSend &&
isNaN(formData.value)) ? (
<DisabledButton>Send</DisabledButton>
) : (
<>
{txInfoFromUrl ? (
<PrimaryButton
onClick={() =>
checkForConfirmationBeforeSendXec()
}
>
Send
</PrimaryButton>
) : (
<PrimaryButton
onClick={() => {
checkForConfirmationBeforeSendXec();
}}
>
Send
</PrimaryButton>
)}
</>
)}
</div>
<CustomCollapseCtn
panelHeader={
<PanelHeaderCtn>
<ThemedMailOutlined /> Message
</PanelHeaderCtn>
}
optionalDefaultActiveKey={
location &&
location.state &&
location.state.replyAddress
? ['1']
: ['0']
}
optionalKey="1"
>
<AntdFormWrapper
style={{
marginBottom: '20px',
}}
>
<Alert
style={{
marginBottom: '10px',
}}
description="Please note this message will be public."
type="warning"
showIcon
/>
<TextArea
name="opReturnMsg"
placeholder={
location &&
location.state &&
location.state.airdropTokenId
? `(max ${
opreturnConfig.cashtabMsgByteLimit -
localAirdropTxAddedBytes
} bytes)`
: `(max ${opreturnConfig.cashtabMsgByteLimit} bytes)`
}
value={opReturnMsg ? opReturnMsg : ''}
onChange={e => handleMsgChange(e)}
onKeyDown={e =>
e.keyCode == 13
? e.preventDefault()
: ''
}
/>
<MsgBytesizeError>
{isMsgError ? isMsgError : ''}
</MsgBytesizeError>
</AntdFormWrapper>
</CustomCollapseCtn>
{apiError && <ApiError />}
</Form>
</Col>
</Row>
</SidePaddingCtn>
</>
);
};
/*
passLoadingStatus must receive a default prop that is a function
in order to pass the rendering unit test in Send.test.js
status => {console.log(status)} is an arbitrary stub function
*/
SendBCH.defaultProps = {
passLoadingStatus: status => {
console.log(status);
},
};
SendBCH.propTypes = {
passLoadingStatus: PropTypes.func,
};
export default SendBCH;
diff --git a/cashtab/src/opreturn/__tests__/index.test.js b/cashtab/src/opreturn/__tests__/index.test.js
index f8a9c3b66..4d5766a7a 100644
--- a/cashtab/src/opreturn/__tests__/index.test.js
+++ b/cashtab/src/opreturn/__tests__/index.test.js
@@ -1,112 +1,133 @@
// Copyright (c) 2023 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
import {
getCashtabMsgTargetOutput,
getAirdropTargetOutput,
getAliasTargetOutput,
getAliasByteCount,
+ getCashtabMsgByteCount,
} from 'opreturn';
import { opReturnVectors } from '../fixtures/vectors';
describe('Cashtab Msg building functions', () => {
const { expectedReturns, expectedErrors } = opReturnVectors.cashtabMsgs;
// Successfully created targetOutputs
expectedReturns.forEach(expectedReturn => {
const { description, cashtabMsg, outputScriptHex } = expectedReturn;
it(`getCashtabMsgTargetOutput: ${description}`, () => {
const targetOutput = getCashtabMsgTargetOutput(cashtabMsg);
// Output value should be zero for OP_RETURN
expect(targetOutput.value).toStrictEqual(0);
// Test vs hex string as cannot store buffer type in vectors
expect(targetOutput.script.toString('hex')).toStrictEqual(
outputScriptHex,
);
});
});
// Error cases
expectedErrors.forEach(expectedError => {
const { description, cashtabMsg, errorMsg } = expectedError;
it(`getCashtabMsgTargetOutput throws error for: ${description}`, () => {
expect(() => getCashtabMsgTargetOutput(cashtabMsg)).toThrow(
errorMsg,
);
});
});
});
describe('getAirdropTargetOutput', () => {
const { expectedReturns, expectedErrors } = opReturnVectors.airdrops;
// Successfully created targetOutputs
expectedReturns.forEach(expectedReturn => {
const { description, tokenId, airdropMsg, outputScriptHex } =
expectedReturn;
it(`${description}`, () => {
const targetOutput = getAirdropTargetOutput(tokenId, airdropMsg);
// Output value should be zero for OP_RETURN
expect(targetOutput.value).toStrictEqual(0);
// Test vs hex string as cannot store buffer type in vectors
expect(targetOutput.script.toString('hex')).toStrictEqual(
outputScriptHex,
);
});
});
// Error cases
expectedErrors.forEach(expectedError => {
const { description, tokenId, airdropMsg, errorMsg } = expectedError;
it(`getAirdropTargetOutput throws error for: ${description}`, () => {
expect(() => getAirdropTargetOutput(tokenId, airdropMsg)).toThrow(
errorMsg,
);
});
});
});
describe('Alias registration target output building functions', () => {
const { expectedReturns, expectedErrors } =
opReturnVectors.aliasRegistrations;
// Successfully created targetOutputs
expectedReturns.forEach(expectedReturn => {
const { description, alias, address, outputScriptHex } = expectedReturn;
it(`getAliasTargetOutput: ${description}`, () => {
const targetOutput = getAliasTargetOutput(alias, address);
// Output value should be zero for OP_RETURN
expect(targetOutput.value).toStrictEqual(0);
// Test vs hex string as cannot store buffer type in vectors
expect(targetOutput.script.toString('hex')).toStrictEqual(
outputScriptHex,
);
});
});
// Error cases
expectedErrors.forEach(expectedError => {
const { description, alias, address, errorMsg } = expectedError;
it(`getAliasTargetOutput throws error for: ${description}`, () => {
expect(() => getAliasTargetOutput(alias, address)).toThrow(
errorMsg,
);
});
});
});
describe('Determines byte count of user input alias registrations', () => {
const { expectedReturns, expectedErrors } = opReturnVectors.aliasByteCounts;
// Successfully calculates alias bytecounts
expectedReturns.forEach(expectedReturn => {
const { description, alias, byteCount } = expectedReturn;
it(`getAliasByteCount: ${description}`, () => {
expect(getAliasByteCount(alias)).toBe(byteCount);
});
});
// Error cases
expectedErrors.forEach(expectedError => {
const { description, alias, errorMsg } = expectedError;
it(`getAliasByteCount throws error for: ${description}`, () => {
expect(() => getAliasByteCount(alias)).toThrow(errorMsg);
});
});
});
+
+describe('Determines bytecount of user input Cashtab Msg', () => {
+ const { expectedReturns, expectedErrors } =
+ opReturnVectors.cashtabMsgByteCounts;
+
+ // Successfully calculates Cashtab Msg bytecounts
+ expectedReturns.forEach(expectedReturn => {
+ const { description, cashtabMsg, byteCount } = expectedReturn;
+ it(`getCashtabMsgByteCount: ${description}`, () => {
+ expect(getCashtabMsgByteCount(cashtabMsg)).toBe(byteCount);
+ });
+ });
+ // Error cases
+ expectedErrors.forEach(expectedError => {
+ const { description, cashtabMsg, errorMsg } = expectedError;
+ it(`getCashtabMsgByteCount throws error for: ${description}`, () => {
+ expect(() => getCashtabMsgByteCount(cashtabMsg)).toThrow(errorMsg);
+ });
+ });
+});
diff --git a/cashtab/src/opreturn/fixtures/vectors.js b/cashtab/src/opreturn/fixtures/vectors.js
index b0df53555..6d2f1a48a 100644
--- a/cashtab/src/opreturn/fixtures/vectors.js
+++ b/cashtab/src/opreturn/fixtures/vectors.js
@@ -1,206 +1,254 @@
// Copyright (c) 2023 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
import { opReturn } from 'config/opreturn';
// Test vectors for opreturn output generating functions
export const opReturnVectors = {
cashtabMsgs: {
expectedReturns: [
{
description: 'Alphanumeric string',
cashtabMsg: 'This is a Cashtab Msg',
outputScriptHex:
'6a0400746162155468697320697320612043617368746162204d7367',
},
{
description: 'String with emojis',
cashtabMsg: '๐๐ฌ๐ซก๐๐ต๏ธ๐๐๐ช๐๐ฏ',
outputScriptHex:
'6a04007461622bf09f998ff09f93acf09faba1f09f9180f09f95b5efb88ff09f9191f09f8e83f09faa96f09f908bf09f8eaf',
},
{
description: 'String of max length for Cashtab Msg',
cashtabMsg:
'00000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000112345',
outputScriptHex:
'6a04007461624cd73030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313132333435',
},
],
expectedErrors: [
{
description:
'String exceeding max length for Cashtab Msg by 1 byte',
cashtabMsg:
'000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001123456',
errorMsg: `Cashtab msg is 216 bytes. Exceeds ${opReturn.cashtabMsgByteLimit} byte limit.`,
},
{
description: 'non-string input',
cashtabMsg: { cashtabMsg: 'good to go' },
errorMsg: 'getCashtabMsgTargetOutput requires string input',
},
{
description: 'Empty string',
cashtabMsg: '',
errorMsg: 'Cashtab Msg cannot be an empty string',
},
],
},
airdrops: {
expectedReturns: [
{
description: 'Airdrop with no optional msg',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg: '',
outputScriptHex:
'6a0464726f702050d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
},
{
description:
'Airdrop with many spaces for optional msg treated as no optional msg',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg: ' ',
outputScriptHex:
'6a0464726f702050d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
},
{
description: 'Airdrop with optional alphanumeric msg',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg: 'Test airdrop msg',
outputScriptHex:
'6a0464726f702050d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e10546573742061697264726f70206d7367',
},
{
description:
'Airdrop with optional emoji and special characters msg',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg:
'30~40 ํ๋ก ์์น์ผ๋ก ๋ง์กฑ๋ชปํ๊ฒ ์ผ๋ 300~400ํ๋ก ํํ ํจ ๊ฐ์ฆ์~ ์์ฒด๋ฐญ๋๊ณ ~๐ค',
outputScriptHex:
'6a0464726f702050d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e4c6833307e343020ed9484eba19c20ec8381ec8ab9ec9cbceba19c20eba78ceca1b1ebaabbed9598eab2a0ec9cbceb8b88203330307e343030ed9484eba19c20ed8e8ced959120ed95a820eab080eca688ec95847e20ec8b9cecb2b4ebb0adeb8498eab3a07ef09fa494',
},
{
description:
'Airdrop with optional msg of max allowable length',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg:
'00000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000112',
outputScriptHex:
'6a0464726f702050d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e4cb63030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313030303030303030303130303030303030303031303030303030303030313132',
},
],
expectedErrors: [
{
description: 'Invalid tokenId provided',
tokenId:
'0d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg:
'000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001123',
errorMsg: `Invalid tokenId: 0d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e`,
},
{
description:
'Airdrop msg exceeding max length for airdrop msg by 1 byte',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg:
'000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001123',
errorMsg: `Airdrop msg is 183 bytes. Exceeds ${opReturn.airdropMsgByteLimit} byte limit.`,
},
{
description: 'non-string input for airdrop msg',
tokenId:
'50d8292c6255cda7afc6c8566fed3cf42a2794e9619740fe8f4c95431271410e',
airdropMsg: { airdropMsg: 'good to go' },
errorMsg:
'getAirdropTargetOutput requires string input for tokenId and airdropMsg',
},
],
},
aliasRegistrations: {
expectedReturns: [
{
description: 'Valid alias to p2pkh address',
alias: 'test',
address: 'ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035',
outputScriptHex:
'6a042e786563000474657374150095e79f51d4260bc0dc3ba7fb77c7be92d0fbdd1d',
},
{
description: 'Valid alias to p2sh address',
alias: 'testtwo',
address: 'ecash:prfhcnyqnl5cgrnmlfmms675w93ld7mvvqd0y8lz07',
outputScriptHex:
'6a042e78656300077465737474776f1508d37c4c809fe9840e7bfa77b86bd47163f6fb6c60',
},
],
expectedErrors: [
{
description: 'Invalid alias',
alias: 'test_WITH_badchars',
address: 'ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035',
errorMsg: 'Invalid alias "test_WITH_badchars"',
},
{
description: 'Invalid address',
alias: 'test',
address: 'not an address',
errorMsg: 'Invalid address "not an address"',
},
],
},
aliasByteCounts: {
expectedReturns: [
{ description: 'Alias with emoji', alias: '๐', byteCount: 4 },
{
description: 'Alias with emoji and text',
alias: 'monkey๐',
byteCount: 10,
},
{
description: 'Alias with special characters',
alias: 'monkeyยฉยฎสโขฬแดฅโขฬสใฃโก',
byteCount: 33,
},
{
description: 'Alias with Korean text',
alias: '์์ฃผ',
byteCount: 6,
},
{
description: 'Alias with Arabic text',
alias: 'ู
ุญูุท',
byteCount: 8,
},
{
description: 'Alias with Chinese text',
alias: 'ๅฐๆทๆท',
byteCount: 9,
},
{
description: 'Alias with mixed foreign alphabets and emoji',
alias: '๐ยฉๅฐ์์ฃผ',
byteCount: 15,
},
{
description: 'Alphanumeric valid v0 alias',
alias: 'justanormalalias',
byteCount: 16,
},
],
expectedErrors: [
{
description: 'non-text input',
alias: null,
errorMsg: 'alias input must be a string',
},
],
},
+ cashtabMsgByteCounts: {
+ expectedReturns: [
+ {
+ description: 'a single emoji',
+ cashtabMsg: '๐',
+ byteCount: 4,
+ },
+ {
+ description: 'msg input with characters and emojis',
+ cashtabMsg: 'monkey๐',
+ byteCount: 10,
+ },
+ {
+ description: 'msg input with special characters',
+ cashtabMsg: 'monkeyยฉยฎสโขฬแดฅโขฬสใฃโก',
+ byteCount: 33,
+ },
+ {
+ description:
+ 'msg input with a mixture of symbols, multilingual characters and emojis',
+ cashtabMsg: '๐ยฉๅฐ์์ฃผ',
+ byteCount: 15,
+ },
+ {
+ description: 'Alphanumeric string',
+ cashtabMsg: 'This is a Cashtab Msg',
+ byteCount: 21,
+ },
+ {
+ description: 'String with emojis',
+ cashtabMsg: '๐๐ฌ๐ซก๐๐ต๏ธ๐๐๐ช๐๐ฏ',
+ byteCount: 43,
+ },
+ {
+ description: 'String of max length for Cashtab Msg',
+ cashtabMsg:
+ '00000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000112345',
+ byteCount: 215,
+ },
+ ],
+ expectedErrors: [
+ {
+ description: 'non-text input',
+ cashtabMsg: null,
+ errorMsg: 'cashtabMsg must be a string',
+ },
+ ],
+ },
};
diff --git a/cashtab/src/opreturn/index.js b/cashtab/src/opreturn/index.js
index a20dea6b0..70f41ddb3 100644
--- a/cashtab/src/opreturn/index.js
+++ b/cashtab/src/opreturn/index.js
@@ -1,183 +1,200 @@
// Copyright (c) 2023 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
import * as utxolib from '@bitgo/utxo-lib';
import cashaddr from 'ecashaddrjs';
import { opReturn } from 'config/opreturn';
import { isValidTokenId, isValidAlias } from 'utils/validation';
/**
* Initialize an OP_RETURN script element in a way that utxolib.script.compile(script) accepts
* utxolib.script.compile(script) will add pushdata bytes for each buffer
* utxolib.script.compile(script) will not add pushdata bytes for raw data
* Initialize script array with OP_RETURN byte (6a) as rawdata (i.e. you want compiled result of 6a, not 016a)
*/
const initializeScript = () => {
return [opReturn.opReturnPrefixDec];
};
/**
* Get targetOutput for a Cashtab Msg from user input string
* @param {string} cashtabMsg string
* @throws {error} if msg exceeds opReturnByteLimit of 223 or invalid input
* @returns {object} targetOutput, e.g. {value: 0, script: <encoded cashtab msg>}
*/
export const getCashtabMsgTargetOutput = cashtabMsg => {
if (typeof cashtabMsg !== 'string') {
throw new Error('getCashtabMsgTargetOutput requires string input');
}
if (cashtabMsg === '') {
throw new Error('Cashtab Msg cannot be an empty string');
}
let script = initializeScript();
// Push Cashtab Msg protocol identifier
script.push(Buffer.from(opReturn.appPrefixesHex.cashtab, 'hex'));
// Cashtab msgs are utf8 encoded
const cashtabMsgScript = Buffer.from(cashtabMsg, 'utf8');
const cashtabMsgByteCount = cashtabMsgScript.length;
if (cashtabMsgByteCount > opReturn.cashtabMsgByteLimit) {
throw new Error(
`Error: Cashtab msg is ${cashtabMsgByteCount} bytes. Exceeds ${opReturn.cashtabMsgByteLimit} byte limit.`,
);
}
script.push(cashtabMsgScript);
script = utxolib.script.compile(script);
// Create output
return { value: 0, script };
};
+/**
+ * Calculates the bytecount of a Cashtab Msg as part of an OP_RETURN output
+ * Used to validate user input in Send.js
+ *
+ * @param {string} cashtabMsg alias input from a text input field
+ * @returns {number} aliasInputByteSize the byte size of the alias input
+ */
+export const getCashtabMsgByteCount = cashtabMsg => {
+ if (typeof cashtabMsg !== 'string') {
+ throw new Error('cashtabMsg must be a string');
+ }
+
+ // Cashtab msgs are utf8 encoded
+ const cashtabMsgScript = Buffer.from(cashtabMsg, 'utf8');
+ return cashtabMsgScript.length;
+};
+
/**
* Get targetOutput for an Airdrop tx OP_RETURN from token id and optional user message
* Airdrop tx spec: <Airdrop Protocol Identifier> <tokenId> <optionalMsg>
* @param {string} tokenId tokenId of the token receiving this airdrop tx
* @param {string} airdropMsg optional brief msg accompanying the airdrop
* @throws {error} if msg exceeds opReturnByteLimit of 223 or invalid input
* @returns {object} targetOutput, e.g. {value: 0, script: <encoded airdrop msg>}
*/
export const getAirdropTargetOutput = (tokenId, airdropMsg = '') => {
if (!isValidTokenId(tokenId)) {
throw new Error(`Invalid tokenId: ${tokenId}`);
}
if (typeof airdropMsg !== 'string') {
throw new Error(
'getAirdropTargetOutput requires string input for tokenId and airdropMsg',
);
}
let script = initializeScript();
// Push Airdrop protocol identifier
script.push(Buffer.from(opReturn.appPrefixesHex.airdrop, 'hex'));
// add the airdrop token ID to script
script.push(Buffer.from(tokenId, 'hex'));
if (airdropMsg.trim() !== '') {
// Cashtab msgs are utf8 encoded
const airdropMsgScript = Buffer.from(airdropMsg, 'utf8');
const airdropMsgByteCount = airdropMsgScript.length;
if (airdropMsgByteCount > opReturn.airdropMsgByteLimit) {
throw new Error(
`Error: Airdrop msg is ${airdropMsgByteCount} bytes. Exceeds ${opReturn.airdropMsgByteLimit} byte limit.`,
);
}
script.push(airdropMsgScript);
}
script = utxolib.script.compile(script);
// Create output
return { value: 0, script };
};
/**
* Generate an OP_RETURN targetOutput for use in broadcasting a v0 alias registration
*
* @param {string} alias
* @param {string} address
* @throws {error} validation errors on alias or address
* @returns {object} targetOutput ready for transaction building, see sendXec function at src/transactions
*/
export const getAliasTargetOutput = (alias, address) => {
if (!isValidAlias(alias)) {
throw new Error(`Invalid alias "${alias}"`);
}
let script = initializeScript();
// Push alias protocol identifier
script.push(
Buffer.from(opReturn.appPrefixesHex.aliasRegistration, 'hex'), // '.xec'
);
// Push alias protocol tx version to stack
// Per spec, push this as OP_0
script.push(0);
// Push alias to the stack
script.push(Buffer.from(alias, 'utf8'));
// Get the type and hash of the address in string format
let decoded;
try {
decoded = cashaddr.decode(address, true);
} catch (err) {
throw new Error(`Invalid address "${address}"`);
}
const { type, hash } = decoded;
// Determine address type and corresponding address version byte
let addressVersionByte;
// Version bytes per cashaddr spec,https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
if (type === 'p2pkh') {
addressVersionByte = '00'; // one byte 0 in hex
} else if (type === 'p2sh') {
addressVersionByte = '08'; // one byte 8 in hex
} else {
throw new Error(
`Unsupported address type ${type}. Only p2pkh and p2sh addresses are supported.`,
);
}
// Push <addressVersionByte> and <addressPayload>
script.push(Buffer.from(`${addressVersionByte}${hash}`, 'hex'));
script = utxolib.script.compile(script);
// Create output
return { value: 0, script };
};
/**
* Calculates the bytecount of the alias input
*
* @param {string} alias alias input from a text input field
* @returns {number} aliasInputByteSize the byte size of the alias input
*/
export const getAliasByteCount = alias => {
if (typeof alias !== 'string') {
// Make sure .trim() is available
throw new Error('alias input must be a string');
}
// Do not validate the specific alias as the user may type in invalid aliases
// We still want to return a size
if (alias.trim() === '') {
return 0;
}
// Get alias as utf8
const aliasUtf8Hex = Buffer.from(alias, 'utf8');
// Return bytecount
return aliasUtf8Hex.length;
};
diff --git a/cashtab/src/utils/__tests__/cashMethods.test.js b/cashtab/src/utils/__tests__/cashMethods.test.js
index d0edf60a5..1f92bdef5 100644
--- a/cashtab/src/utils/__tests__/cashMethods.test.js
+++ b/cashtab/src/utils/__tests__/cashMethods.test.js
@@ -1,1886 +1,1644 @@
import BigNumber from 'bignumber.js';
import * as utxolib from '@bitgo/utxo-lib';
import cashaddr from 'ecashaddrjs';
import {
fromSatoshisToXec,
flattenContactList,
loadStoredWallet,
isValidStoredWallet,
fromLegacyDecimals,
convertToEcashPrefix,
isLegacyMigrationRequired,
convertEtokenToEcashAddr,
parseOpReturn,
convertEcashtoEtokenAddr,
getHashArrayFromWallet,
isActiveWebsocket,
getChangeAddressFromInputUtxos,
generateAliasOpReturnScript,
- generateOpReturnScript,
generateTxInput,
generateTxOutput,
generateTokenTxInput,
signAndBuildTx,
fromXecToSatoshis,
getWalletBalanceFromUtxos,
signUtxosByAddress,
generateTokenTxOutput,
getCashtabByteCount,
calcFee,
toHash160,
generateGenesisOpReturn,
generateSendOpReturn,
generateBurnOpReturn,
hash160ToAddress,
outputScriptToAddress,
- getMessageByteSize,
parseAddressForParams,
sumOneToManyXec,
toSatoshis,
} from 'utils/cashMethods';
import { validAddressArrayInput } from '../__mocks__/mockAddressArray';
import {
mockGenesisOpReturnScript,
mockSendOpReturnScript,
mockSendOpReturnTokenUtxos,
mockBurnOpReturnScript,
mockBurnOpReturnTokenUtxos,
} from '../__mocks__/mockOpReturnScript';
import {
cachedUtxos,
utxosLoadedFromCache,
} from '../__mocks__/mockCachedUtxos';
import {
validStoredWallet,
invalidStoredWallet,
invalidpreChronikStoredWallet,
validStoredWalletAfter20221123Streamline,
invalidStoredWalletMissingPath1899AndMnemonic,
} from '../__mocks__/mockStoredWallets';
import {
missingPath1899Wallet,
missingPublicKeyInPath1899Wallet,
missingPublicKeyInPath145Wallet,
missingPublicKeyInPath245Wallet,
notLegacyWallet,
missingHash160,
} from '../__mocks__/mockLegacyWalletsUtils';
import {
shortCashtabMessageInputHex,
longCashtabMessageInputHex,
shortExternalMessageInputHex,
longExternalMessageInputHex,
shortSegmentedExternalMessageInputHex,
longSegmentedExternalMessageInputHex,
mixedSegmentedExternalMessageInputHex,
mockParsedShortCashtabMessageArray,
mockParsedLongCashtabMessageArray,
mockParsedShortExternalMessageArray,
mockParsedLongExternalMessageArray,
mockParsedShortSegmentedExternalMessageArray,
mockParsedLongSegmentedExternalMessageArray,
mockParsedMixedSegmentedExternalMessageArray,
eTokenInputHex,
mockParsedETokenOutputArray,
mockAirdropHexOutput,
mockParsedAirdropMessageArray,
} from '../__mocks__/mockOpReturnParsedArray';
import mockLegacyWallets from 'hooks/__mocks__/mockLegacyWallets';
import sendBCHMock from '../__mocks__/sendBCH';
import {
activeWebsocketAlpha,
disconnectedWebsocketAlpha,
unsubscribedWebsocket,
} from '../__mocks__/chronikWs';
import mockNonSlpUtxos from '../../hooks/__mocks__/mockNonSlpUtxos';
import mockSlpUtxos from '../../hooks/__mocks__/mockSlpUtxos';
import {
mockOneToOneSendXecTxBuilderObj,
mockOneToManySendXecTxBuilderObj,
mockCreateTokenOutputsTxBuilderObj,
mockSendTokenOutputsTxBuilderObj,
mockBurnTokenOutputsTxBuilderObj,
mockCreateTokenTxBuilderObj,
mockSendTokenTxBuilderObj,
mockBurnTokenTxBuilderObj,
} from '../__mocks__/mockTxBuilderObj';
import {
mockSingleInputUtxo,
mockMultipleInputUtxos,
mockSingleOutput,
mockMultipleOutputs,
} from '../__mocks__/mockTxBuilderData';
import createTokenMock from '../__mocks__/createToken';
import { opReturn as opreturnConfig } from 'config/opreturn';
import appConfig from 'config/app';
test('parseAddressForParams() returns valid info for query string based input', () => {
const inputString =
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx?amount=500000';
const expectedObject = {
address: 'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx',
amount: '500000',
queryString: 'amount=500000',
};
const addressInfo = parseAddressForParams(inputString);
expect(addressInfo).toStrictEqual(expectedObject);
});
test('parseAddressForParams() returns no amount for a malformed query string input', () => {
const inputString =
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx?*&@^&%@amount=-500000';
const expectedObject = {
address: 'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx',
amount: null,
queryString: '*&@^&%@amount=-500000',
};
const addressInfo = parseAddressForParams(inputString);
expect(addressInfo).toStrictEqual(expectedObject);
});
test('parseAddressForParams() returns valid address info for a non-query string based input', () => {
const inputString = 'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx';
const expectedObject = {
address: 'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx',
amount: null,
queryString: null,
};
const addressInfo = parseAddressForParams(inputString);
expect(addressInfo).toStrictEqual(expectedObject);
});
test('parseAddressForParams() returns valid address info for a valid prefix-less eCash address', () => {
const inputString = 'qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx';
const expectedObject = {
address: 'qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx',
amount: null,
queryString: null,
};
const addressInfo = parseAddressForParams(inputString);
expect(addressInfo).toStrictEqual(expectedObject);
});
-it(`OP_RETURN msg byte length matches for an encrypted msg input with a single emoji`, () => {
- const msgInput = '๐';
- const encryptedEjMock = {
- type: 'Buffer',
- data: [
- 2, 241, 30, 211, 127, 184, 181, 145, 219, 158, 127, 99, 178, 221,
- 90, 234, 194, 108, 152, 147, 60, 77, 74, 176, 112, 249, 23, 170,
- 186, 204, 20, 209, 135, 98, 156, 215, 47, 144, 123, 71, 111, 123,
- 199, 26, 89, 67, 76, 135, 250, 112, 226, 74, 182, 186, 79, 52, 15,
- 88, 214, 142, 141, 145, 103, 89, 66, 158, 107, 191, 144, 255, 139,
- 65, 21, 141, 128, 61, 33, 172, 31, 246, 145, 72, 62, 161, 173, 23,
- 249, 4, 79, 245, 183, 202, 115, 140, 0, 83, 42,
- ],
- };
- const opReturnMsgByteLength = getMessageByteSize(
- msgInput,
- true,
- encryptedEjMock,
- );
- expect(opReturnMsgByteLength).toStrictEqual(97);
-});
-
-it(`OP_RETURN msg byte length matches for an encrypted msg input with characters and emojis`, () => {
- const msgInput = 'monkey๐';
- const encryptedEjMock = {
- type: 'Buffer',
- data: [
- 2, 74, 145, 240, 12, 210, 143, 66, 224, 155, 246, 106, 238, 186,
- 167, 192, 123, 39, 44, 165, 231, 97, 166, 149, 93, 121, 10, 107, 45,
- 12, 235, 45, 158, 251, 183, 245, 6, 206, 9, 153, 146, 208, 40, 156,
- 106, 3, 140, 137, 68, 126, 240, 70, 87, 131, 54, 91, 115, 164, 223,
- 109, 199, 173, 127, 106, 94, 82, 200, 83, 77, 157, 55, 195, 16, 17,
- 99, 1, 148, 226, 150, 243, 120, 133, 80, 17, 226, 109, 17, 154, 226,
- 59, 203, 36, 203, 230, 236, 12, 104,
- ],
- };
- const opReturnMsgByteLength = getMessageByteSize(
- msgInput,
- true,
- encryptedEjMock,
- );
- expect(opReturnMsgByteLength).toStrictEqual(97);
-});
-
-it(`OP_RETURN msg byte length matches for an encrypted msg input with special characters`, () => {
- const msgInput = 'monkeyยฉยฎสโขฬแดฅโขฬสใฃโก';
- const encryptedEjMock = {
- type: 'Buffer',
- data: [
- 2, 137, 237, 42, 23, 72, 146, 79, 69, 190, 11, 115, 20, 173, 218,
- 99, 121, 188, 45, 14, 219, 135, 46, 91, 165, 121, 166, 149, 100,
- 140, 231, 143, 38, 1, 169, 226, 26, 136, 124, 82, 59, 223, 210, 65,
- 50, 241, 86, 155, 225, 85, 167, 213, 235, 24, 143, 118, 136, 87, 38,
- 161, 153, 18, 110, 198, 168, 196, 77, 250, 255, 2, 132, 13, 44, 44,
- 220, 93, 61, 73, 89, 160, 16, 247, 115, 174, 238, 80, 102, 26, 158,
- 44, 28, 173, 174, 3, 120, 130, 221, 220, 147, 143, 252, 137, 109,
- 143, 28, 106, 73, 253, 145, 161, 118, 109, 54, 95, 13, 137, 214,
- 253, 11, 238, 115, 89, 84, 241, 227, 103, 78, 246, 22,
- ],
- };
- const opReturnMsgByteLength = getMessageByteSize(
- msgInput,
- true,
- encryptedEjMock,
- );
- expect(opReturnMsgByteLength).toStrictEqual(129);
-});
-
-it(`OP_RETURN msg byte length matches for an encrypted msg input with a mixture of symbols, multilingual characters and emojis`, () => {
- const msgInput = '๐ยฉๅฐ์์ฃผ';
- const encryptedEjMock = {
- type: 'Buffer',
- data: [
- 3, 237, 190, 133, 5, 192, 187, 247, 209, 218, 154, 239, 194, 148,
- 24, 151, 26, 150, 97, 190, 245, 27, 226, 249, 75, 203, 36, 128, 170,
- 209, 250, 181, 239, 253, 242, 53, 181, 198, 37, 123, 236, 120, 192,
- 179, 194, 103, 119, 70, 108, 242, 144, 120, 52, 205, 123, 158, 244,
- 27, 127, 232, 106, 215, 201, 88, 22, 146, 129, 6, 35, 160, 147, 198,
- 131, 236, 202, 200, 137, 39, 80, 241, 168, 158, 211, 113, 123, 76,
- 89, 81, 82, 250, 220, 162, 226, 63, 154, 76, 23,
- ],
- };
- const opReturnMsgByteLength = getMessageByteSize(
- msgInput,
- true,
- encryptedEjMock,
- );
- expect(opReturnMsgByteLength).toStrictEqual(97);
-});
-
-it(`OP_RETURN msg byte length matches for a msg input with a single emoji`, () => {
- const msgInput = '๐';
- const opReturnMsgByteLength = getMessageByteSize(msgInput);
- expect(opReturnMsgByteLength).toStrictEqual(4);
-});
-
-it(`OP_RETURN msg byte length matches for a msg input with characters and emojis`, () => {
- const msgInput = 'monkey๐';
- const opReturnMsgByteLength = getMessageByteSize(msgInput);
- expect(opReturnMsgByteLength).toStrictEqual(10);
-});
-
-it(`OP_RETURN msg byte length matches for a msg input with special characters`, () => {
- const msgInput = 'monkeyยฉยฎสโขฬแดฅโขฬสใฃโก';
- const opReturnMsgByteLength = getMessageByteSize(msgInput);
- expect(opReturnMsgByteLength).toStrictEqual(33);
-});
-
-it(`OP_RETURN msg byte length matches for a msg input with a mixture of symbols, multilingual characters and emojis`, () => {
- const msgInput = '๐ยฉๅฐ์์ฃผ';
- const opReturnMsgByteLength = getMessageByteSize(msgInput);
- expect(opReturnMsgByteLength).toStrictEqual(15);
-});
-
it(`generateSendOpReturn() returns correct script object for valid tokenUtxo and send quantity`, () => {
const tokensToSend = 50;
const sendOpReturnScriptObj = generateSendOpReturn(
mockSendOpReturnTokenUtxos,
tokensToSend,
);
expect(JSON.stringify(sendOpReturnScriptObj.script)).toStrictEqual(
JSON.stringify(mockSendOpReturnScript),
);
});
it(`generateSendOpReturnScript() throws error on invalid input`, () => {
const mockSendOpReturnTokenUtxos = null;
const tokensToSend = 50;
let errorThrown;
try {
generateSendOpReturn(mockSendOpReturnTokenUtxos, tokensToSend);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid send token parameter');
});
it(`generateBurnOpReturn() returns correct script for valid tokenUtxo and burn quantity`, () => {
const tokensToBurn = 7000;
const burnOpReturnScript = generateBurnOpReturn(
mockBurnOpReturnTokenUtxos,
tokensToBurn,
);
expect(JSON.stringify(burnOpReturnScript)).toStrictEqual(
JSON.stringify(mockBurnOpReturnScript),
);
});
it(`generateBurnOpReturn() throws error on invalid input`, () => {
const tokensToBurn = 7000;
let errorThrown;
try {
generateBurnOpReturn(null, tokensToBurn);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid burn token parameter');
});
it(`generateGenesisOpReturn() returns correct script for a valid configObj`, () => {
const configObj = {
name: 'ethantest',
ticker: 'ETN',
documentUrl: 'https://cashtab.com/',
decimals: '3',
initialQty: '5000',
documentHash: '',
mintBatonVout: null,
};
const genesisOpReturnScript = generateGenesisOpReturn(configObj);
expect(JSON.stringify(genesisOpReturnScript)).toStrictEqual(
JSON.stringify(mockGenesisOpReturnScript),
);
});
it(`generateGenesisOpReturn() throws error on invalid configObj`, () => {
const configObj = null;
let errorThrown;
try {
generateGenesisOpReturn(configObj);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid token configuration');
});
it(`signUtxosByAddress() successfully returns a txBuilder object for a one to one XEC tx`, () => {
const isOneToMany = false;
const { destinationAddress, wallet, utxos } = sendBCHMock;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const satoshisToSendInput = new BigNumber(2184);
const feeInSatsPerByte = appConfig.defaultFee;
// mock tx input
const inputObj = generateTxInput(
isOneToMany,
utxos,
txBuilder,
null,
satoshisToSendInput,
feeInSatsPerByte,
);
// mock tx output
const totalInputUtxoValue =
mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
const singleSendValue = new BigNumber(
fromSatoshisToXec(
mockOneToOneSendXecTxBuilderObj.transaction.tx.outs[0].value,
),
);
const satoshisToSendOutput = fromXecToSatoshis(
new BigNumber(singleSendValue),
);
const txFee = new BigNumber(totalInputUtxoValue).minus(
new BigNumber(satoshisToSendOutput),
);
const changeAddress = wallet.Path1899.cashAddress;
const outputObj = generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSendOutput,
totalInputUtxoValue,
destinationAddress,
null,
changeAddress,
txFee,
inputObj.txBuilder,
);
const txBuilderResponse = signUtxosByAddress(
mockSingleInputUtxo,
wallet,
outputObj,
);
expect(txBuilderResponse.toString()).toStrictEqual(
mockOneToOneSendXecTxBuilderObj.toString(),
);
});
it(`signUtxosByAddress() successfully returns a txBuilder object for a one to many XEC tx`, () => {
const isOneToMany = true;
const { wallet, utxos } = sendBCHMock;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
let destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
];
const satoshisToSendInput = new BigNumber(900000);
const feeInSatsPerByte = appConfig.defaultFee;
// mock tx input
const inputObj = generateTxInput(
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSendInput,
feeInSatsPerByte,
);
// mock tx output
const totalInputUtxoValue =
mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
const singleSendValue = null;
const satoshisToSendOutput = new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
);
const txFee = new BigNumber(totalInputUtxoValue)
.minus(satoshisToSendOutput)
.minus(
new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
),
); // change value
destinationAddressAndValueArray = validAddressArrayInput;
const changeAddress = wallet.Path1899.cashAddress;
const outputObj = generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSendOutput,
totalInputUtxoValue,
null,
destinationAddressAndValueArray,
changeAddress,
txFee,
inputObj.txBuilder,
);
const txBuilderResponse = signUtxosByAddress(
mockSingleInputUtxo,
wallet,
outputObj,
);
expect(txBuilderResponse.toString()).toStrictEqual(
mockOneToManySendXecTxBuilderObj.toString(),
);
});
it(`getChangeAddressFromInputUtxos() returns a correct change address from a valid inputUtxo`, () => {
const { wallet } = sendBCHMock;
const inputUtxo = [
{
height: 669639,
tx_hash:
'0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
tx_pos: 0,
value: 1000,
txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
vout: 0,
isValid: false,
address: 'bitcoincash:qphpmfj0qn7znklqhrfn5dq7qh36l3vxavu346vqcl',
wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
},
];
const changeAddress = getChangeAddressFromInputUtxos(inputUtxo, wallet);
expect(changeAddress).toStrictEqual(inputUtxo[0].address);
});
it(`getChangeAddressFromInputUtxos() returns a correct change address from a valid inputUtxo and accepts ecash: format`, () => {
const { wallet } = sendBCHMock;
const inputUtxo = [
{
height: 669639,
tx_hash:
'0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
tx_pos: 0,
value: 1000,
txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
vout: 0,
isValid: false,
address: 'ecash:qphpmfj0qn7znklqhrfn5dq7qh36l3vxav9up3h67g',
wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
},
];
const changeAddress = getChangeAddressFromInputUtxos(inputUtxo, wallet);
expect(changeAddress).toStrictEqual(inputUtxo[0].address);
});
it(`getChangeAddressFromInputUtxos() throws error upon a malformed input utxo`, () => {
const { wallet } = sendBCHMock;
const invalidInputUtxo = [
{
height: 669639,
tx_hash:
'0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
tx_pos: 0,
value: 1000,
txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
vout: 0,
isValid: false,
wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
},
];
let thrownError;
try {
getChangeAddressFromInputUtxos(invalidInputUtxo, wallet);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid input utxo');
});
it(`getChangeAddressFromInputUtxos() throws error upon a valid input utxo with invalid address param`, () => {
const { wallet } = sendBCHMock;
const invalidInputUtxo = [
{
height: 669639,
tx_hash:
'0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
tx_pos: 0,
value: 1000,
address: 'bitcoincash:1qphpmfj0qn7znklqhrfn5dq7qh36l3vxavu346vqcl', // invalid cash address
txid: '0da6d49cf95d4603958e53360ad1e90bfccef41bfb327d6b2e8a77e242fa2d58',
vout: 0,
isValid: false,
wif: 'L58jqHoi5ynSdsskPVBJuGuVqTP8ZML1MwHQsBJY32Pv7cqDSCeH',
},
];
let thrownError;
try {
getChangeAddressFromInputUtxos(invalidInputUtxo, wallet);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid input utxo');
});
it(`getChangeAddressFromInputUtxos() throws an error upon a null inputUtxos param`, () => {
const { wallet } = sendBCHMock;
const inputUtxo = null;
let thrownError;
try {
getChangeAddressFromInputUtxos(inputUtxo, wallet);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual(
'Invalid getChangeAddressFromWallet input parameter',
);
});
it(`sumOneToManyXec() correctly parses the value for a valid one to many send XEC transaction`, () => {
const destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,1',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,2',
'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3',
];
expect(sumOneToManyXec(destinationAddressAndValueArray)).toStrictEqual(6);
});
it(`sumOneToManyXec() correctly parses the value for a valid one to many send XEC transaction with decimals`, () => {
const destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,1.23',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,2.45',
'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3.67',
];
expect(sumOneToManyXec(destinationAddressAndValueArray)).toStrictEqual(
7.35,
);
});
it(`sumOneToManyXec() returns NaN for an address and value array that is partially typed or has invalid format`, () => {
const destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,1',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,',
];
expect(sumOneToManyXec(destinationAddressAndValueArray)).toStrictEqual(NaN);
});
it('generateAliasOpReturnScript() correctly generates OP_RETURN script for a valid alias registration for a p2pkh address', () => {
const alias = 'test';
const address = 'ecash:qz2708636snqhsxu8wnlka78h6fdp77ar59jrf5035';
const { hash } = cashaddr.decode(address, true);
// Manually build the expected outputScript
const opReturn = '6a';
// push protocol identifier
const prefixBytesHex = '04';
const aliasIdentifier = '2e786563';
// push alias tx version
const aliasProtocolVersionNumberHex = '00';
// push the alias
const aliasHexBytes = '04'; // alias.length in one byte of hex
const aliasHex = Buffer.from(alias).toString('hex');
// push the address
const aliasAddressBytesHex = '15'; // (1 + 20) in one byte of hex
const p2pkhVersionByteHex = '00';
const aliasTxOpReturnOutputScript = [
opReturn,
prefixBytesHex,
aliasIdentifier,
aliasProtocolVersionNumberHex,
aliasHexBytes,
aliasHex,
aliasAddressBytesHex,
p2pkhVersionByteHex,
hash,
].join('');
// Calculate the expected outputScript with the tested function
const aliasOutputScript = generateAliasOpReturnScript(alias, address);
// aliasOutputScript.toString('hex')
// 6a042e78656301000474657374150095e79f51d4260bc0dc3ba7fb77c7be92d0fbdd1d
expect(aliasOutputScript.toString('hex')).toBe(aliasTxOpReturnOutputScript);
});
it('generateAliasOpReturnScript() correctly generates OP_RETURN script for a valid alias registration for a p2sh address', () => {
const alias = 'testtwo';
const address = 'ecash:prfhcnyqnl5cgrnmlfmms675w93ld7mvvqd0y8lz07';
const { hash } = cashaddr.decode(address, true);
// Manually build the expected outputScript
const opReturn = '6a';
// push protocol identifier
const prefixBytesHex = '04';
const aliasIdentifier = '2e786563';
// push alias tx version
const aliasProtocolVersionNumberHex = '00';
// push the alias
const aliasHexBytes = '07'; // alias.length in one byte of hex
const aliasHex = Buffer.from(alias).toString('hex');
// push the address
const aliasAddressBytesHex = '15'; // (1 + 20) in one byte of hex
const p2shVersionByteHex = '08';
const aliasTxOpReturnOutputScript = [
opReturn,
prefixBytesHex,
aliasIdentifier,
aliasProtocolVersionNumberHex,
aliasHexBytes,
aliasHex,
aliasAddressBytesHex,
p2shVersionByteHex,
hash,
].join('');
// Calculate the expected outputScript with the tested function
const aliasOutputScript = generateAliasOpReturnScript(alias, address);
// aliasOutputScript.toString('hex')
// 6a042e7865630100077465737474776f1508d37c4c809fe9840e7bfa77b86bd47163f6fb6c60
expect(aliasOutputScript.toString('hex')).toBe(aliasTxOpReturnOutputScript);
});
-it('generateOpReturnScript() correctly generates an encrypted message script', () => {
- const optionalOpReturnMsg = 'testing generateOpReturnScript()';
- const encryptionFlag = true;
- const airdropFlag = false;
- const airdropTokenId = null;
- const mockEncryptedEj =
- '04688f9907fe3c7c0b78a73c4ab4f75e15e7e2b79641add519617086126fe6f6b1405a14eed48e90c9c8c0fc77f0f36984a78173e76ce51f0a44af94b59e9da703c9ff82758cfdb9cc46437d662423400fb731d3bfc1df0599279356ca261213fbb40d398c041e1bac966afed1b404581ab1bcfcde1fa039d53b7c7b70e8edf26d64bea9fbeed24cc80909796e6af5863707fa021f2a2ebaa2fe894904702be19d';
-
- const encodedScript = generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- mockEncryptedEj,
- );
- expect(encodedScript.toString('hex')).toBe(
- '6a04657461624d420130343638386639393037666533633763306237386137336334616234663735653135653765326237393634316164643531393631373038363132366665366636623134303561313465656434386539306339633863306663373766306633363938346137383137336537366365353166306134346166393462353965396461373033633966663832373538636664623963633436343337643636323432333430306662373331643362666331646630353939323739333536636132363132313366626234306433393863303431653162616339363661666564316234303435383161623162636663646531666130333964353362376337623730653865646632366436346265613966626565643234636338303930393739366536616635383633373037666130323166326132656261613266653839343930343730326265313964',
- );
-});
-
-it('generateOpReturnScript() correctly generates an un-encrypted non-airdrop message script', () => {
- const optionalOpReturnMsg = 'testing generateOpReturnScript()';
- const encryptionFlag = false;
- const airdropFlag = false;
-
- const encodedScript = generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- );
- expect(encodedScript.toString('hex')).toBe(
- '6a04007461622074657374696e672067656e65726174654f7052657475726e5363726970742829',
- );
-});
-
-it('generateOpReturnScript() correctly generates an un-encrypted airdrop message script', () => {
- const optionalOpReturnMsg = 'testing generateOpReturnScript()';
- const encryptionFlag = false;
- const airdropFlag = true;
- const airdropTokenId =
- '1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
-
- const encodedScript = generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- );
- expect(encodedScript.toString('hex')).toBe(
- '6a0464726f70201c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e04007461622074657374696e672067656e65726174654f7052657475726e5363726970742829',
- );
-});
-
-it('generateOpReturnScript() correctly generates an un-encrypted airdrop with no message script', () => {
- const optionalOpReturnMsg = null;
- const encryptionFlag = false;
- const airdropFlag = true;
- const airdropTokenId =
- '1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
-
- const encodedScript = generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- );
- expect(encodedScript.toString('hex')).toBe(
- '6a0464726f70201c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e0400746162',
- );
-});
-
-it('generateOpReturnScript() correctly throws an error on an invalid encryption input', () => {
- const optionalOpReturnMsg = null;
- const encryptionFlag = true;
- const airdropFlag = false;
- const airdropTokenId = null;
- const mockEncryptedEj = null; // invalid given encryptionFlag is true
- let thrownError;
-
- try {
- generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- mockEncryptedEj,
- );
- } catch (err) {
- thrownError = err;
- }
- expect(thrownError.message).toStrictEqual('Invalid OP RETURN script input');
-});
-
-it('generateOpReturnScript() correctly throws an error on an invalid airdrop input', () => {
- const optionalOpReturnMsg = null;
- const encryptionFlag = false;
- const airdropFlag = true;
- const airdropTokenId = null; // invalid given airdropFlag is true
-
- let thrownError;
-
- try {
- generateOpReturnScript(
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- );
- } catch (err) {
- thrownError = err;
- }
- expect(thrownError.message).toStrictEqual('Invalid OP RETURN script input');
-});
-
-it('generateOpReturnScript() correctly generates an alias registration script', () => {
- const optionalOpReturnMsg = 'nfs'; // the alias name to be registered
- const encodedScript = generateOpReturnScript(
- optionalOpReturnMsg,
- false,
- false,
- null,
- null,
- true, // alias registration flag
- );
- expect(encodedScript.toString('hex')).toBe('6a042e786563036e6673');
-});
it(`generateTokenTxInput() returns a valid object for a valid create token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const tokenId =
'1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
const tokenInputObj = generateTokenTxInput(
'GENESIS',
mockNonSlpUtxos,
null, // no slpUtxos used for genesis tx
tokenId,
null, // no token send/burn amount for genesis tx
appConfig.defaultFee,
txBuilder,
);
expect(tokenInputObj.inputXecUtxos).toStrictEqual([mockNonSlpUtxos[0]]);
expect(tokenInputObj.txBuilder.toString()).toStrictEqual(
mockCreateTokenTxBuilderObj.toString(),
);
expect(tokenInputObj.remainderXecValue).toStrictEqual(
new BigNumber(698999), // tokenInputObj.inputXecUtxos - appConfig.etokenSats 546 - txFee
);
});
it(`generateTokenTxInput() returns a valid object for a valid send token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const tokenId = mockSlpUtxos[0].tokenId;
const tokenInputObj = generateTokenTxInput(
'SEND',
mockNonSlpUtxos,
mockSlpUtxos,
tokenId,
new BigNumber(500), // sending 500 of these tokens
appConfig.defaultFee,
txBuilder,
);
expect(tokenInputObj.inputTokenUtxos).toStrictEqual(
[mockSlpUtxos[0]].concat([mockSlpUtxos[1]]), // mockSlpUtxos[0] 400 + mockSlpUtxos[1] 6500
);
expect(tokenInputObj.remainderTokenValue).toStrictEqual(
new BigNumber(6400), // token change is mockSlpUtxos[0] 400 + mockSlpUtxos[1] 6500 - [tokenAmount] 500
);
expect(tokenInputObj.txBuilder.toString()).toStrictEqual(
mockSendTokenTxBuilderObj.toString(),
);
});
it(`generateTokenTxInput() returns a valid object for a valid burn token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const tokenId = mockSlpUtxos[0].tokenId;
const tokenInputObj = generateTokenTxInput(
'BURN',
mockNonSlpUtxos,
mockSlpUtxos,
tokenId,
new BigNumber(500), // burning 500 of these tokens
appConfig.defaultFee,
txBuilder,
);
expect(tokenInputObj.inputTokenUtxos).toStrictEqual(
[mockSlpUtxos[0]].concat([mockSlpUtxos[1]]), // mockSlpUtxos[0] 400 + mockSlpUtxos[1] 6500
);
expect(tokenInputObj.remainderTokenValue).toStrictEqual(
new BigNumber(6400), // token change is mockSlpUtxos[0] 400 + mockSlpUtxos[1] 6500 - [tokenAmount] 500
);
expect(tokenInputObj.txBuilder.toString()).toStrictEqual(
mockBurnTokenTxBuilderObj.toString(),
);
});
it(`generateTokenTxOutput() returns a valid object for a valid create token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const { configObj, wallet } = createTokenMock;
const tokenSenderCashAddress = wallet.Path1899.cashAddress;
const tokenOutputObj = generateTokenTxOutput(
txBuilder,
'GENESIS',
tokenSenderCashAddress,
null, // optional, for SEND or BURN amount
new BigNumber(500), // remainder XEC value
configObj,
);
expect(tokenOutputObj.toString()).toStrictEqual(
mockCreateTokenOutputsTxBuilderObj.toString(),
);
});
it(`generateTokenTxOutput() returns a valid object for a valid send token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const { wallet } = createTokenMock;
const tokenSenderCashAddress = wallet.Path1899.cashAddress;
const tokenRecipientTokenAddress = wallet.Path1899.cashAddress;
const tokenOutputObj = generateTokenTxOutput(
txBuilder,
'SEND',
tokenSenderCashAddress,
mockSlpUtxos,
new BigNumber(500), // remainder XEC value
null, // only for genesis tx
tokenRecipientTokenAddress, // recipient token address
new BigNumber(50),
);
expect(tokenOutputObj.toString()).toStrictEqual(
mockSendTokenOutputsTxBuilderObj.toString(),
);
});
it(`generateTokenTxOutput() returns a valid object for a valid burn token tx`, async () => {
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const { wallet } = createTokenMock;
const tokenSenderCashAddress = wallet.Path1899.cashAddress;
const tokenOutputObj = generateTokenTxOutput(
txBuilder,
'BURN',
tokenSenderCashAddress,
mockSlpUtxos,
new BigNumber(500), // remainder XEC value
null, // only for genesis tx
null, // no token recipients for burn tx
new BigNumber(50),
);
expect(tokenOutputObj.toString()).toStrictEqual(
mockBurnTokenOutputsTxBuilderObj.toString(),
);
});
it(`generateTxInput() returns an input object for a valid one to one XEC tx`, async () => {
const isOneToMany = false;
const utxos = mockNonSlpUtxos;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const destinationAddressAndValueArray = null;
const satoshisToSend = new BigNumber(2184);
const feeInSatsPerByte = appConfig.defaultFee;
const inputObj = generateTxInput(
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSend,
feeInSatsPerByte,
);
expect(inputObj.txBuilder).not.toStrictEqual(null);
expect(inputObj.totalInputUtxoValue).toStrictEqual(new BigNumber(700000));
expect(inputObj.txFee).toStrictEqual(455);
expect(inputObj.inputUtxos.length).not.toStrictEqual(0);
});
it(`generateTxInput() returns an input object for a valid one to many XEC tx`, async () => {
const isOneToMany = true;
const utxos = mockNonSlpUtxos;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
];
const satoshisToSend = new BigNumber(900000);
const feeInSatsPerByte = appConfig.defaultFee;
const inputObj = generateTxInput(
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSend,
feeInSatsPerByte,
);
expect(inputObj.txBuilder).not.toStrictEqual(null);
expect(inputObj.totalInputUtxoValue).toStrictEqual(new BigNumber(1400000));
expect(inputObj.txFee).toStrictEqual(889);
expect(inputObj.inputUtxos.length).not.toStrictEqual(0);
});
it(`generateTxInput() throws error for a one to many XEC tx with invalid destinationAddressAndValueArray input`, async () => {
const isOneToMany = true;
const utxos = mockNonSlpUtxos;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const destinationAddressAndValueArray = null; // invalid since isOneToMany is true
const satoshisToSend = new BigNumber(900000);
const feeInSatsPerByte = appConfig.defaultFee;
let thrownError;
try {
generateTxInput(
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSend,
feeInSatsPerByte,
);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
});
it(`generateTxInput() throws error for a one to many XEC tx with invalid utxos input`, async () => {
const isOneToMany = true;
const utxos = null;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const destinationAddressAndValueArray = [
'ecash:qrmz0egsqxj35x5jmzf8szrszdeu72fx0uxgwk3r48,3000',
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx,3000',
'ecash:qzvydd4n3lm3xv62cx078nu9rg0e3srmqq0knykfed,3000',
];
const satoshisToSend = new BigNumber(900000);
const feeInSatsPerByte = appConfig.defaultFee;
let thrownError;
try {
generateTxInput(
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSend,
feeInSatsPerByte,
);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
});
it(`generateTxOutput() returns a txBuilder instance for a valid one to one XEC tx`, () => {
// txbuilder output params
const { destinationAddress, wallet } = sendBCHMock;
const isOneToMany = false;
const singleSendValue = fromSatoshisToXec(
mockOneToOneSendXecTxBuilderObj.transaction.tx.outs[0].value,
);
const totalInputUtxoValue =
mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
const satoshisToSend = fromXecToSatoshis(new BigNumber(singleSendValue));
// for unit test purposes, calculate fee by subtracting satoshisToSend from totalInputUtxoValue
// no change output to be subtracted in this tx
const txFee = new BigNumber(totalInputUtxoValue).minus(
new BigNumber(satoshisToSend),
);
const destinationAddressAndValueArray = null;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const changeAddress = wallet.Path1899.cashAddress;
const outputObj = generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSend,
totalInputUtxoValue,
destinationAddress,
destinationAddressAndValueArray,
changeAddress,
txFee,
txBuilder,
);
expect(outputObj.toString()).toStrictEqual(
mockOneToOneSendXecTxBuilderObj.toString(),
);
});
it(`generateTxOutput() returns a txBuilder instance for a valid one to many XEC tx`, () => {
// txbuilder output params
const { destinationAddress, wallet } = sendBCHMock;
const isOneToMany = true;
const singleSendValue = null;
const totalInputUtxoValue =
mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
const satoshisToSend = new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
);
// for unit test purposes, calculate fee by subtracting satoshisToSend and change amount from totalInputUtxoValue
const txFee = new BigNumber(totalInputUtxoValue)
.minus(satoshisToSend)
.minus(
new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
),
); // change value
const destinationAddressAndValueArray = validAddressArrayInput;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const changeAddress = wallet.Path1899.cashAddress;
const outputObj = generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSend,
totalInputUtxoValue,
destinationAddress,
destinationAddressAndValueArray,
changeAddress,
txFee,
txBuilder,
);
expect(outputObj.toString()).toStrictEqual(
mockOneToManySendXecTxBuilderObj.toString(),
);
});
it(`generateTxOutput() throws an error on invalid input params for a one to one XEC tx`, () => {
// txbuilder output params
const { wallet } = sendBCHMock;
const isOneToMany = false;
const singleSendValue = null; // invalid due to singleSendValue being mandatory when isOneToMany is false
const totalInputUtxoValue =
mockOneToOneSendXecTxBuilderObj.transaction.inputs[0].value;
const satoshisToSend = fromXecToSatoshis(new BigNumber(singleSendValue));
// for unit test purposes, calculate fee by subtracting satoshisToSend from totalInputUtxoValue
// no change output to be subtracted in this tx
const txFee = new BigNumber(totalInputUtxoValue).minus(satoshisToSend);
const destinationAddressAndValueArray = null;
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const changeAddress = wallet.Path1899.cashAddress;
let thrownError;
try {
generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSend,
totalInputUtxoValue,
null,
destinationAddressAndValueArray,
changeAddress,
txFee,
txBuilder,
);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
});
it(`generateTxOutput() throws an error on invalid input params for a one to many XEC tx`, () => {
// txbuilder output params
const { wallet } = sendBCHMock;
const isOneToMany = true;
const singleSendValue = null;
const totalInputUtxoValue =
mockOneToManySendXecTxBuilderObj.transaction.inputs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.inputs[2].value;
const satoshisToSend = new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[0].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[1].value +
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[2].value,
);
// for unit test purposes, calculate fee by subtracting satoshisToSend and change amount from totalInputUtxoValue
const txFee = new BigNumber(totalInputUtxoValue)
.minus(satoshisToSend)
.minus(
new BigNumber(
mockOneToManySendXecTxBuilderObj.transaction.tx.outs[3].value,
),
); // change value
const destinationAddressAndValueArray = null; // invalid as this is mandatory when isOneToMany is true
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const changeAddress = wallet.Path1899.cashAddress;
let thrownError;
try {
generateTxOutput(
isOneToMany,
singleSendValue,
satoshisToSend,
totalInputUtxoValue,
null,
destinationAddressAndValueArray,
changeAddress,
txFee,
txBuilder,
);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid tx input parameter');
});
it(`signAndBuildTx() successfully returns a raw tx hex for a tx with a single input and a single output`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
// Use legacy sequencing for legacy unit tests
txBuilder.DEFAULT_SEQUENCE = 0xffffffff;
const { wallet } = sendBCHMock;
// add inputs to txBuilder
txBuilder.addInput(
mockSingleInputUtxo[0].txid,
mockSingleInputUtxo[0].vout,
);
// add outputs to txBuilder
const outputAddressAndValue = mockSingleOutput.split(',');
txBuilder.addOutput(
cashaddr.toLegacy(outputAddressAndValue[0]), // address
parseInt(fromXecToSatoshis(new BigNumber(outputAddressAndValue[1]))), // value
);
const rawTxHex = signAndBuildTx(mockSingleInputUtxo, txBuilder, wallet);
expect(rawTxHex).toStrictEqual(
'0200000001582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006b483045022100b4ee5268cb64c4f097e739df7c6934d1df7e75a4f217d5824db18ae2e12554b102204faf039738181aae80c064b928b3d8079a82cdb080ce9a2d5453939a588f4372412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0158020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
);
});
it(`signAndBuildTx() successfully returns a raw tx hex for a tx with a single input and multiple outputs`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
// Use legacy sequencing for legacy unit tests
txBuilder.DEFAULT_SEQUENCE = 0xffffffff;
const { wallet } = sendBCHMock;
// add inputs to txBuilder
txBuilder.addInput(
mockSingleInputUtxo[0].txid,
mockSingleInputUtxo[0].vout,
);
// add outputs to txBuilder
for (let i = 0; i < mockMultipleOutputs.length; i++) {
const outputAddressAndValue = mockMultipleOutputs[i].split(',');
txBuilder.addOutput(
cashaddr.toLegacy(outputAddressAndValue[0]), // address
parseInt(
fromXecToSatoshis(new BigNumber(outputAddressAndValue[1])),
), // value
);
}
const rawTxHex = signAndBuildTx(mockSingleInputUtxo, txBuilder, wallet);
expect(rawTxHex).toStrictEqual(
'0200000001582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006b483045022100df29734c4fb348b0e8b613ce522c10c5ac14cb3ecd32843dc7fcf004d60f1b8a022023c4ae02b38c7272e29f344902ae2afa4db1ec37d582a31c16650a0abc4f480c412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0326020000000000001976a914f627e51001a51a1a92d8927808701373cf29267f88ac26020000000000001976a9140b7d35fda03544a08e65464d54cfae4257eb6db788ac26020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
);
});
it(`signAndBuildTx() successfully returns a raw tx hex for a tx with multiple inputs and a single output`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
// Use legacy sequencing for legacy unit tests
txBuilder.DEFAULT_SEQUENCE = 0xffffffff;
const { wallet } = sendBCHMock;
// add inputs to txBuilder
for (let i = 0; i < mockMultipleInputUtxos.length; i++) {
txBuilder.addInput(
mockMultipleInputUtxos[i].txid,
mockMultipleInputUtxos[i].vout,
);
}
// add outputs to txBuilder
const outputAddressAndValue = mockSingleOutput.split(',');
txBuilder.addOutput(
cashaddr.toLegacy(outputAddressAndValue[0]), // address
parseInt(fromXecToSatoshis(new BigNumber(outputAddressAndValue[1]))), // value
);
const rawTxHex = signAndBuildTx(mockMultipleInputUtxos, txBuilder, wallet);
expect(rawTxHex).toStrictEqual(
'0200000003582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006a4730440220541366dd5ea25d65d3044dbde16fc6118ab1aee07c7d0d4c25c9e8aa299f040402203ed2f540948197d4c6a4ae963ad187d145a9fb339e311317b03c6172732e267b412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff7313e804af08113dfa290515390a8ec3ac01448118f2eb556ee168a96ee6acdd000000006b483045022100c1d02c5023f83b87a4f2dd26a7306ed9be9d53ab972bd935b440e45eb54a304302200b99aa2f1a728b3bb1dcbff80742c5fcab991bb74e80fa231255a31d58a6ff7d412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff960dd2f0c47e8a3cf1486b046d879f45a047da3b51aedfb5594138ac857214f1000000006b483045022100bd24d11d7070988848cb4aa2b10748aa0aeb79dc8af39c1f22dc1034b3121e5f02201491026e5f8f6eb566eb17cb195e3da3ff0d9cf01bdd34c944964d33a8d3b1ad412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0158020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
);
});
it(`signAndBuildTx() successfully returns a raw tx hex for a tx with multiple inputs and multiple outputs`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
// Use legacy sequencing for legacy unit tests
txBuilder.DEFAULT_SEQUENCE = 0xffffffff;
const { wallet } = sendBCHMock;
// add inputs to txBuilder
for (let i = 0; i < mockMultipleInputUtxos.length; i++) {
txBuilder.addInput(
mockMultipleInputUtxos[i].txid,
mockMultipleInputUtxos[i].vout,
);
}
// add outputs to txBuilder
for (let i = 0; i < mockMultipleOutputs.length; i++) {
const outputAddressAndValue = mockMultipleOutputs[i].split(',');
txBuilder.addOutput(
cashaddr.toLegacy(outputAddressAndValue[0]), // address
parseInt(
fromXecToSatoshis(new BigNumber(outputAddressAndValue[1])),
), // value
);
}
const rawTxHex = signAndBuildTx(mockMultipleInputUtxos, txBuilder, wallet);
expect(rawTxHex).toStrictEqual(
'0200000003582dfa42e2778a2e6b7d32fb1bf4cefc0be9d10a36538e9503465df99cd4a60d000000006a47304402203de4e6a512a6bec1d378b6444008484e1be5a0c621dc4b201d67addefffe864602202daf82e76b7594fe1ab54a49380c6b1226ab65551ae6ab9164216b66266f34a1412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff7313e804af08113dfa290515390a8ec3ac01448118f2eb556ee168a96ee6acdd000000006a473044022029f5fcbc9356beb9eae6b9ff9a479e8c8331b95406b6be456fccf9d90f148ea1022028f4e7fa7234f9429535360c8f5dad303e2c5044431615997861b10f26fa8a88412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff960dd2f0c47e8a3cf1486b046d879f45a047da3b51aedfb5594138ac857214f1000000006a473044022049a67738d99006b3523cff818f3626104cf5106bd463be70d22ad179a8cb403b022025829baf67f964202ea77ea7462a5447e32415e7293cdee382ea7ae9374364e8412102322fe90c5255fe37ab321c386f9446a86e80c3940701d430f22325094fdcec60ffffffff0326020000000000001976a914f627e51001a51a1a92d8927808701373cf29267f88ac26020000000000001976a9140b7d35fda03544a08e65464d54cfae4257eb6db788ac26020000000000001976a9149846b6b38ff713334ac19fe3cf851a1f98c07b0088ac00000000',
);
});
it(`signAndBuildTx() throws error on an empty inputUtxo param`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const { wallet } = sendBCHMock;
let thrownError;
try {
signAndBuildTx([], txBuilder, wallet);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid buildTx parameter');
});
it(`signAndBuildTx() throws error on a null inputUtxo param`, () => {
// txbuilder output params
let txBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(
utxolib.networks.ecash,
);
const inputUtxo = null; // invalid input param
const { wallet } = sendBCHMock;
let thrownError;
try {
signAndBuildTx(inputUtxo, txBuilder, wallet);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toStrictEqual('Invalid buildTx parameter');
});
describe('Correctly executes cash utility functions', () => {
it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 2`, () => {
expect(fromSatoshisToXec(1, 2)).toStrictEqual(new BigNumber(0.01));
});
it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 2`, () => {
expect(fromSatoshisToXec(1000000012345678, 2)).toStrictEqual(
new BigNumber(10000000123456.78),
);
});
it(`Correctly converts smallest base unit to smallest decimal for cashDecimals = 8`, () => {
expect(fromSatoshisToXec(1, 8)).toStrictEqual(
new BigNumber(0.00000001),
);
});
it(`Correctly converts largest base unit to smallest decimal for cashDecimals = 8`, () => {
expect(fromSatoshisToXec(1000000012345678, 8)).toStrictEqual(
new BigNumber(10000000.12345678),
);
});
it(`Accepts a cachedWalletState that has not preserved BigNumber object types, and returns the same wallet state with BigNumber type re-instituted`, () => {
expect(loadStoredWallet(cachedUtxos)).toStrictEqual(
utxosLoadedFromCache,
);
});
it(`loadStoredWallet accepts undefined wallet state as input and outputs a zero balance wallet state`, () => {
expect(loadStoredWallet(undefined)).toStrictEqual({
balances: {
totalBalanceInSatoshis: '0',
totalBalance: '0',
},
});
});
it(`Correctly determines a wallet's balance from its set of non-eToken utxos (nonSlpUtxos)`, () => {
expect(
getWalletBalanceFromUtxos(
validStoredWalletAfter20221123Streamline.state.nonSlpUtxos,
),
).toStrictEqual(validStoredWallet.state.balances);
});
it(`Correctly determines a wallet's zero balance from its empty set of non-eToken utxos (nonSlpUtxos)`, () => {
expect(
getWalletBalanceFromUtxos(utxosLoadedFromCache.nonSlpUtxos),
).toStrictEqual(utxosLoadedFromCache.balances);
});
it(`Recognizes a stored wallet as valid if it has all required fields prior to 20221123 updated format`, () => {
expect(isValidStoredWallet(validStoredWallet)).toBe(true);
});
it(`Recognizes a stored wallet as valid if it has all required fields in 20221123 updated format`, () => {
expect(
isValidStoredWallet(validStoredWalletAfter20221123Streamline),
).toBe(true);
});
it(`Recognizes a stored wallet as invalid if it is missing required fields`, () => {
expect(isValidStoredWallet(invalidStoredWallet)).toBe(false);
});
it(`Recognizes a stored wallet as invalid if it includes hydratedUtxoDetails in the state field`, () => {
expect(isValidStoredWallet(invalidpreChronikStoredWallet)).toBe(false);
});
it(`Recognizes a stored wallet as invalid if it's missing the Path1899 and mnemonic keys`, () => {
expect(
isValidStoredWallet(invalidStoredWalletMissingPath1899AndMnemonic),
).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 appConfig.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(`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('toHash160() converts a valid bitcoincash: prefix address to a hash160', () => {
const result = toHash160(
'bitcoincash:qq9h6d0a5q65fgywv4ry64x04ep906mdku7ymranw3',
);
expect(result).toStrictEqual(
'0b7d35fda03544a08e65464d54cfae4257eb6db7',
);
});
test('toHash160 throws error if input address is an invalid bitcoincash: address', () => {
const address = 'bitcoincash:qqd3qnINVALIDDDDDDDDDza25m';
let errorThrown;
try {
toHash160(address);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid address: ' + address + '.');
});
test('toHash160() converts a valid ecash: prefix address to a hash160', () => {
const result = toHash160(
'ecash:qq9h6d0a5q65fgywv4ry64x04ep906mdku8f0gxfgx',
);
expect(result).toStrictEqual(
'0b7d35fda03544a08e65464d54cfae4257eb6db7',
);
});
test('toHash160 throws error if input address is an invalid ecash address', () => {
const address = 'ecash:qqd3qn4zINVALIDDDDDtfza25m';
let errorThrown;
try {
toHash160(address);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid address: ' + address + '.');
});
test('toHash160() converts a valid etoken: address to a hash160', () => {
const result = toHash160(
'etoken:qq9h6d0a5q65fgywv4ry64x04ep906mdkufhx2swv3',
);
expect(result).toStrictEqual(
'0b7d35fda03544a08e65464d54cfae4257eb6db7',
);
});
test('toHash160 throws error if input address is an invalid etoken: address', () => {
const address = 'etoken:qq9h6d0a5INVALIDDDDDDx2swv3';
let errorThrown;
try {
toHash160(address);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid address: ' + address + '.');
});
test('toHash160() converts a valid simpleledger: address to a hash160', () => {
const result = toHash160(
'simpleledger:qq9h6d0a5q65fgywv4ry64x04ep906mdkujlscgns0',
);
expect(result).toStrictEqual(
'0b7d35fda03544a08e65464d54cfae4257eb6db7',
);
});
test('toHash160 throws error if input address is an invalid simpleledger: address', () => {
const address = 'simpleledger:qq9h6d0a5qINVALIDDDjlscgns0';
let errorThrown;
try {
toHash160(address);
} catch (err) {
errorThrown = err.message;
}
expect(errorThrown).toStrictEqual('Invalid address: ' + 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 === opreturnConfig.appPrefixesHex.airdrop,
),
).toStrictEqual(opreturnConfig.appPrefixesHex.airdrop);
});
test('convertEtokenToEcashAddr successfully converts a valid eToken address to eCash', async () => {
const result = convertEtokenToEcashAddr(
'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs',
);
expect(result).toStrictEqual(
'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
);
});
test('convertEtokenToEcashAddr successfully converts prefixless eToken address as input', async () => {
const result = convertEtokenToEcashAddr(
'qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs',
);
expect(result).toStrictEqual(
'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
);
});
test('convertEtokenToEcashAddr throws error with an invalid eToken address as input', async () => {
const result = convertEtokenToEcashAddr('etoken:qpj9gcldpffcs');
expect(result).toStrictEqual(
new Error(
'cashMethods.convertToEcashAddr() error: etoken:qpj9gcldpffcs is not a valid etoken address',
),
);
});
test('convertEtokenToEcashAddr throws error with an ecash address as input', async () => {
const result = convertEtokenToEcashAddr(
'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8',
);
expect(result).toStrictEqual(
new Error(
'cashMethods.convertToEcashAddr() error: ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8 is not a valid etoken address',
),
);
});
test('convertEtokenToEcashAddr throws error with null input', async () => {
const result = convertEtokenToEcashAddr(null);
expect(result).toStrictEqual(
new Error(
'cashMethods.convertToEcashAddr() error: No etoken address provided',
),
);
});
test('convertEtokenToEcashAddr throws error with empty string input', async () => {
const result = convertEtokenToEcashAddr('');
expect(result).toStrictEqual(
new Error(
'cashMethods.convertToEcashAddr() error: No etoken address provided',
),
);
});
test('convertEcashtoEtokenAddr successfully converts a valid ecash address into an etoken address', async () => {
const eCashAddress = 'ecash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8';
const eTokenAddress =
'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
const result = convertEcashtoEtokenAddr(eCashAddress);
expect(result).toStrictEqual(eTokenAddress);
});
test('convertEcashtoEtokenAddr successfully converts a valid prefix-less ecash address into an etoken address', async () => {
const eCashAddress = 'qpatql05s9jfavnu0tv6lkjjk25n6tmj9gkpyrlwu8';
const eTokenAddress =
'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
const result = convertEcashtoEtokenAddr(eCashAddress);
expect(result).toStrictEqual(eTokenAddress);
});
test('convertEcashtoEtokenAddr throws error with invalid ecash address input', async () => {
const eCashAddress = 'ecash:qpaNOTVALIDADDRESSwu8';
const result = convertEcashtoEtokenAddr(eCashAddress);
expect(result).toStrictEqual(
new Error(eCashAddress + ' is not a valid ecash address'),
);
});
test('convertEcashtoEtokenAddr throws error with a valid etoken address input', async () => {
const eTokenAddress =
'etoken:qpatql05s9jfavnu0tv6lkjjk25n6tmj9gcldpffcs';
const result = convertEcashtoEtokenAddr(eTokenAddress);
expect(result).toStrictEqual(
new Error(eTokenAddress + ' is not a valid ecash address'),
);
});
test('convertEcashtoEtokenAddr throws error with a valid bitcoincash address input', async () => {
const bchAddress =
'bitcoincash:qpatql05s9jfavnu0tv6lkjjk25n6tmj9g0vsgy56s';
const result = convertEcashtoEtokenAddr(bchAddress);
expect(result).toStrictEqual(
new Error(bchAddress + ' is not a valid ecash address'),
);
});
test('convertEcashtoEtokenPrefix throws error with null ecash address input', async () => {
const eCashAddress = null;
const result = convertEcashtoEtokenAddr(eCashAddress);
expect(result).toStrictEqual(
new Error(eCashAddress + ' is not a valid ecash address'),
);
});
it(`flattenContactList flattens contactList array by returning an array of addresses`, () => {
expect(
flattenContactList([
{
address: 'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
name: 'Alpha',
},
{
address: 'ecash:qpq235n3l3u6ampc8slapapnatwfy446auuv64ylt2',
name: 'Beta',
},
{
address: 'ecash:qz50e58nkeg2ej2f34z6mhwylp6ven8emy8pp52r82',
name: 'Gamma',
},
]),
).toStrictEqual([
'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
'ecash:qpq235n3l3u6ampc8slapapnatwfy446auuv64ylt2',
'ecash:qz50e58nkeg2ej2f34z6mhwylp6ven8emy8pp52r82',
]);
});
it(`flattenContactList flattens contactList array of length 1 by returning an array of 1 address`, () => {
expect(
flattenContactList([
{
address: 'ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr',
name: 'Alpha',
},
]),
).toStrictEqual(['ecash:qpdkc5p7f25hwkxsr69m3evlj4h7wqq9xcgmjc8sxr']);
});
it(`flattenContactList returns an empty array for invalid input`, () => {
expect(flattenContactList(false)).toStrictEqual([]);
});
it(`getHashArrayFromWallet returns false for a legacy wallet`, () => {
expect(
getHashArrayFromWallet(mockLegacyWallets.legacyAlphaMainnet),
).toBe(false);
});
it(`Successfully extracts a hash160 array from a migrated wallet object`, () => {
expect(
getHashArrayFromWallet(
mockLegacyWallets.migratedLegacyAlphaMainnet,
),
).toStrictEqual([
'960c9ed561f1699f0c49974d50b3bb7cdc118625',
'2be0e0c999e7e77a443ea726f82c441912fca92b',
'ba8257db65f40359989c7b894c5e88ed7b6344f6',
]);
});
it(`isActiveWebsocket returns true for an active chronik websocket connection`, () => {
expect(isActiveWebsocket(activeWebsocketAlpha)).toBe(true);
});
it(`isActiveWebsocket returns false for a disconnected chronik websocket connection`, () => {
expect(isActiveWebsocket(disconnectedWebsocketAlpha)).toBe(false);
});
it(`isActiveWebsocket returns false for a null chronik websocket connection`, () => {
expect(isActiveWebsocket(null)).toBe(false);
});
it(`isActiveWebsocket returns false for an active websocket connection with no subscriptions`, () => {
expect(isActiveWebsocket(unsubscribedWebsocket)).toBe(false);
});
it(`getCashtabByteCount for 2 inputs, 2 outputs returns the same value as BCH.BitcoinCash.getByteCount(
{ P2PKH: utxos.length },
{ P2PKH: p2pkhOutputNumber },
);`, () => {
expect(getCashtabByteCount(2, 2)).toBe(374);
});
it(`getCashtabByteCount for 1 input, 2 outputs returns the same value as BCH.BitcoinCash.getByteCount(
{ P2PKH: utxos.length },
{ P2PKH: p2pkhOutputNumber },
);`, () => {
expect(getCashtabByteCount(1, 2)).toBe(226);
});
it(`getCashtabByteCount for 173 input, 1 outputs returns the same value as BCH.BitcoinCash.getByteCount(
{ P2PKH: utxos.length },
{ P2PKH: p2pkhOutputNumber },
);`, () => {
expect(getCashtabByteCount(173, 1)).toBe(25648);
});
it(`getCashtabByteCount for 1 input, 2000 outputs returns the same value as BCH.BitcoinCash.getByteCount(
{ P2PKH: utxos.length },
{ P2PKH: p2pkhOutputNumber },
);`, () => {
expect(getCashtabByteCount(1, 2000)).toBe(68158);
});
it('calculates fee correctly for 2 P2PKH outputs', () => {
const utxosMock = [{}, {}];
expect(calcFee(utxosMock, 2, appConfig.defaultFee)).toBe(752);
});
it(`Converts a hash160 to an ecash address`, () => {
expect(
hash160ToAddress('76458db0ed96fe9863fc1ccec9fa2cfab884b0f6'),
).toBe('ecash:qpmytrdsakt0axrrlswvaj069nat3p9s7cjctmjasj');
});
it(`outputScriptToAddress determines P2PKH address type from output script and returns the ecash address`, () => {
expect(
outputScriptToAddress(
'76a914da45fd71b76e34c88e97ccbebb454d7cd395e52c88ac',
),
).toBe('ecash:qrdytlt3kahrfjywjlxtaw69f47d89099s393kne5c');
});
it(`outputScriptToAddress determines P2SH address type from output script and returns the ecash address`, () => {
expect(
outputScriptToAddress(
'a914c5e60aad8d98f298a76434750630dc1b46a2382187',
),
).toBe('ecash:prz7vz4d3kv09x98vs682p3smsd5dg3cyykjye6grt');
});
it(`outputScriptToAddress throws correct error for an output script that does not parse as P2PKH or P2SH`, () => {
let thrownError;
try {
outputScriptToAddress('notAnOutputScript');
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toBe('Unrecognized outputScript format');
});
it(`outputScriptToAddress throws correct error for an output script that for some reason is bracketed by P2PKH markers but is not a valid hash160`, () => {
let thrownError;
try {
outputScriptToAddress(
'76a914da45fd71b76eeeeeeeee34c88e97ccbebb454d7cd395e52c88ac',
);
} catch (err) {
thrownError = err;
}
expect(thrownError.message).toBe('Parsed hash160 is incorrect length');
});
it(`toSatoshis returns expected integers for all possible decimal places at extreme limit of XEC supply`, () => {
const xecMaxSupply = 21000000000000;
const xecMaxSupplyLessOne = xecMaxSupply - 1;
for (let i = 1; i < 100; i += 1) {
const thisDecimal = parseFloat((i / 100).toFixed(2));
const testValue = xecMaxSupplyLessOne + thisDecimal;
const result = toSatoshis(testValue);
// Confirm you get an integer
expect(Number.isInteger(result)).toBe(true);
// Confirm you aren't rounding to the wrong decimal
expect(result.toString().slice(-2)).toBe(
thisDecimal.toFixed(2).slice(-2),
);
}
});
});
diff --git a/cashtab/src/utils/cashMethods.js b/cashtab/src/utils/cashMethods.js
index fe8531737..10da56401 100644
--- a/cashtab/src/utils/cashMethods.js
+++ b/cashtab/src/utils/cashMethods.js
@@ -1,1352 +1,1237 @@
import {
isValidXecAddress,
isValidEtokenAddress,
isValidContactList,
isValidBchAddress,
} from 'utils/validation';
import BigNumber from 'bignumber.js';
import cashaddr from 'ecashaddrjs';
import bs58 from 'bs58';
import * as slpMdm from 'slp-mdm';
import * as utxolib from '@bitgo/utxo-lib';
import { opReturn as opreturnConfig } from 'config/opreturn';
import appConfig from 'config/app';
-export const getMessageByteSize = (
- msgInputStr,
- encryptionFlag,
- encryptedEj,
-) => {
- if (!msgInputStr || msgInputStr.trim() === '') {
- return 0;
- }
-
- // generate the OP_RETURN script
- let opReturnData;
- if (encryptionFlag && encryptedEj) {
- opReturnData = generateOpReturnScript(
- msgInputStr,
- encryptionFlag, // encryption flag
- false, // airdrop use
- null, // airdrop use
- encryptedEj, // serialized encryption data object
- false, // alias registration flag
- );
- } else {
- opReturnData = generateOpReturnScript(
- msgInputStr,
- encryptionFlag, // encryption use
- false, // airdrop use
- null, // airdrop use
- null, // serialized encryption data object
- false, // alias registration flag
- );
- }
- // extract the msg input from the OP_RETURN script and check the backend size
- const hexString = opReturnData.toString('hex'); // convert to hex
- const opReturnMsg = parseOpReturn(hexString)[1]; // extract the message
- const msgInputByteSize = opReturnMsg.length / 2; // calculate the byte size
-
- return msgInputByteSize;
-};
-
// function is based on BCH-JS' generateBurnOpReturn() however it's been trimmed down for Cashtab use
// Reference: https://github.com/Permissionless-Software-Foundation/bch-js/blob/62e56c832b35731880fe448269818b853c76dd80/src/slp/tokentype1.js#L217
export const generateBurnOpReturn = (tokenUtxos, burnQty) => {
try {
if (!tokenUtxos || !burnQty) {
throw new Error('Invalid burn token parameter');
} // sendToken component already prevents burning of a value greater than the token utxo total held by the wallet
const tokenId = tokenUtxos[0].tokenId;
const decimals = tokenUtxos[0].decimals;
// account for token decimals
const finalBurnTokenQty = new BigNumber(burnQty).times(10 ** decimals);
// Calculate the total amount of tokens owned by the wallet.
const totalTokens = tokenUtxos.reduce(
(tot, txo) =>
tot.plus(new BigNumber(txo.tokenQty).times(10 ** decimals)),
new BigNumber(0),
);
// calculate the token change
const tokenChange = totalTokens.minus(finalBurnTokenQty);
const tokenChangeStr = tokenChange.toString();
// Generate the burn OP_RETURN as a Buffer
// No need for separate .send() calls for change and non-change burns as
// nil change values do not generate token outputs as the full balance is burnt
const script = slpMdm.TokenType1.send(tokenId, [
new slpMdm.BN(tokenChangeStr),
]);
return script;
} catch (err) {
console.log('Error in generateBurnOpReturn(): ' + err);
throw err;
}
};
// Function originally based on BCH-JS' generateSendOpReturn function however trimmed down for Cashtab
// Reference: https://github.com/Permissionless-Software-Foundation/bch-js/blob/62e56c832b35731880fe448269818b853c76dd80/src/slp/tokentype1.js#L95
export const generateSendOpReturn = (tokenUtxos, sendQty) => {
try {
if (!tokenUtxos || !sendQty) {
throw new Error('Invalid send token parameter');
}
const tokenId = tokenUtxos[0].tokenId;
const decimals = tokenUtxos[0].decimals;
// account for token decimals
const finalSendTokenQty = new BigNumber(sendQty).times(10 ** decimals);
const finalSendTokenQtyStr = finalSendTokenQty.toString();
// Calculate the total amount of tokens owned by the wallet.
const totalTokens = tokenUtxos.reduce(
(tot, txo) =>
tot.plus(new BigNumber(txo.tokenQty).times(10 ** decimals)),
new BigNumber(0),
);
// calculate token change
const tokenChange = totalTokens.minus(finalSendTokenQty);
const tokenChangeStr = tokenChange.toString();
// When token change output is required
let script, outputs;
if (tokenChange > 0) {
outputs = 2;
// Generate the OP_RETURN as a Buffer.
script = slpMdm.TokenType1.send(tokenId, [
new slpMdm.BN(finalSendTokenQtyStr),
new slpMdm.BN(tokenChangeStr),
]);
} else {
// no token change needed
outputs = 1;
// Generate the OP_RETURN as a Buffer.
script = slpMdm.TokenType1.send(tokenId, [
new slpMdm.BN(finalSendTokenQtyStr),
]);
}
return { script, outputs };
} catch (err) {
console.log('Error in generateSendOpReturn(): ' + err);
throw err;
}
};
// function is based on BCH-JS' generateGenesisOpReturn() however it's been trimmed down for Cashtab use
// Reference: https://github.com/Permissionless-Software-Foundation/bch-js/blob/62e56c832b35731880fe448269818b853c76dd80/src/slp/tokentype1.js#L286
export const generateGenesisOpReturn = configObj => {
try {
if (!configObj) {
throw new Error('Invalid token configuration');
}
// adjust initial quantity for token decimals
const initialQty = new BigNumber(configObj.initialQty)
.times(10 ** configObj.decimals)
.toString();
const script = slpMdm.TokenType1.genesis(
configObj.ticker,
configObj.name,
configObj.documentUrl,
configObj.documentHash,
configObj.decimals,
configObj.mintBatonVout,
new slpMdm.BN(initialQty),
);
return script;
} catch (err) {
console.log('Error in generateGenesisOpReturn(): ' + err);
throw err;
}
};
export const getUtxoWif = (utxo, wallet) => {
if (!wallet) {
throw new Error('Invalid wallet parameter');
}
const accounts = [wallet.Path245, wallet.Path145, wallet.Path1899];
const wif = accounts
.filter(acc => acc.cashAddress === utxo.address)
.pop().fundingWif;
return wif;
};
export const signUtxosByAddress = (inputUtxos, wallet, txBuilder) => {
for (let i = 0; i < inputUtxos.length; i++) {
const utxo = inputUtxos[i];
const accounts = [wallet.Path245, wallet.Path145, wallet.Path1899];
const wif = accounts
.filter(acc => acc.cashAddress === utxo.address)
.pop().fundingWif;
const utxoECPair = utxolib.ECPair.fromWIF(wif, utxolib.networks.ecash);
// Specify hash type
// This should be handled at the utxo-lib level, pending latest published version
const hashTypes = {
SIGHASH_ALL: 0x01,
SIGHASH_FORKID: 0x40,
};
txBuilder.sign(
i, // vin
utxoECPair, // keyPair
undefined, // redeemScript
hashTypes.SIGHASH_ALL | hashTypes.SIGHASH_FORKID, // hashType
parseInt(utxo.value), // value
);
}
return txBuilder;
};
export const getCashtabByteCount = (p2pkhInputCount, p2pkhOutputCount) => {
// Simplifying bch-js function for P2PKH txs only, as this is all Cashtab supports for now
// https://github.com/Permissionless-Software-Foundation/bch-js/blob/master/src/bitcoincash.js#L408
// The below magic numbers refer to:
// const types = {
// inputs: {
// 'P2PKH': 148 * 4,
// },
// outputs: {
// P2PKH: 34 * 4,
// },
// };
const inputCount = new BigNumber(p2pkhInputCount);
const outputCount = new BigNumber(p2pkhOutputCount);
const inputWeight = new BigNumber(148 * 4);
const outputWeight = new BigNumber(34 * 4);
const nonSegwitWeightConstant = new BigNumber(10 * 4);
let totalWeight = new BigNumber(0);
totalWeight = totalWeight
.plus(inputCount.times(inputWeight))
.plus(outputCount.times(outputWeight))
.plus(nonSegwitWeightConstant);
const byteCount = totalWeight.div(4).integerValue(BigNumber.ROUND_CEIL);
return Number(byteCount);
};
export const calcFee = (
utxos,
p2pkhOutputNumber = 2,
satoshisPerByte = appConfig.defaultFee,
opReturnByteCount = 0,
) => {
const byteCount = getCashtabByteCount(utxos.length, p2pkhOutputNumber);
const txFee = Math.ceil(satoshisPerByte * (byteCount + opReturnByteCount));
return txFee;
};
export const generateTokenTxOutput = (
txBuilder,
tokenAction,
legacyCashOriginAddress,
tokenUtxosBeingSpent = [], // optional - send or burn tx only
remainderXecValue = new BigNumber(0), // optional - only if > dust
tokenConfigObj = {}, // optional - genesis only
tokenRecipientAddress = false, // optional - send tx only
tokenAmount = false, // optional - send or burn amount for send/burn tx only
) => {
try {
if (!tokenAction || !legacyCashOriginAddress || !txBuilder) {
throw new Error('Invalid token tx output parameter');
}
let script, opReturnObj, destinationAddress;
switch (tokenAction) {
case 'GENESIS':
script = generateGenesisOpReturn(tokenConfigObj);
destinationAddress = legacyCashOriginAddress;
break;
case 'SEND':
opReturnObj = generateSendOpReturn(
tokenUtxosBeingSpent,
tokenAmount.toString(),
);
script = opReturnObj.script;
destinationAddress = tokenRecipientAddress;
break;
case 'BURN':
script = generateBurnOpReturn(
tokenUtxosBeingSpent,
tokenAmount,
);
destinationAddress = legacyCashOriginAddress;
break;
default:
throw new Error('Invalid token transaction type');
}
// OP_RETURN needs to be the first output in the transaction.
txBuilder.addOutput(script, 0);
// add XEC dust output as fee for genesis, send or burn token output
txBuilder.addOutput(
cashaddr.toLegacy(destinationAddress),
parseInt(appConfig.etokenSats),
);
// Return any token change back to the sender for send and burn txs
if (
tokenAction !== 'GENESIS' ||
(opReturnObj && opReturnObj.outputs > 1)
) {
// add XEC dust output as fee
txBuilder.addOutput(
cashaddr.toLegacy(tokenUtxosBeingSpent[0].address), // etoken address
parseInt(appConfig.etokenSats),
);
}
// Send xec change to own address
if (remainderXecValue.gte(new BigNumber(appConfig.dustSats))) {
txBuilder.addOutput(
cashaddr.toLegacy(legacyCashOriginAddress),
parseInt(remainderXecValue),
);
}
} catch (err) {
console.log(`generateTokenTxOutput() error: ` + err);
throw err;
}
return txBuilder;
};
export const generateTxInput = (
isOneToMany,
utxos,
txBuilder,
destinationAddressAndValueArray,
satoshisToSend,
feeInSatsPerByte,
opReturnByteCount,
) => {
let txInputObj = {};
const inputUtxos = [];
let txFee = 0;
let totalInputUtxoValue = new BigNumber(0);
try {
if (
(isOneToMany && !destinationAddressAndValueArray) ||
!utxos ||
!txBuilder ||
!satoshisToSend ||
!feeInSatsPerByte
) {
throw new Error('Invalid tx input parameter');
}
// A normal tx will have 2 outputs, destination and change
// A one to many tx will have n outputs + 1 change output, where n is the number of recipients
const txOutputs = isOneToMany
? destinationAddressAndValueArray.length + 1
: 2;
for (let i = 0; i < utxos.length; i++) {
const utxo = utxos[i];
totalInputUtxoValue = totalInputUtxoValue.plus(utxo.value);
const vout = utxo.outpoint.outIdx;
const txid = utxo.outpoint.txid;
// add input with txid and index of vout
txBuilder.addInput(txid, vout);
inputUtxos.push(utxo);
txFee = calcFee(
inputUtxos,
txOutputs,
feeInSatsPerByte,
opReturnByteCount,
);
if (totalInputUtxoValue.minus(satoshisToSend).minus(txFee).gte(0)) {
break;
}
}
} catch (err) {
console.log(`generateTxInput() error: ` + err);
throw err;
}
txInputObj.txBuilder = txBuilder;
txInputObj.totalInputUtxoValue = totalInputUtxoValue;
txInputObj.inputUtxos = inputUtxos;
txInputObj.txFee = txFee;
return txInputObj;
};
export const generateTokenTxInput = (
tokenAction, // GENESIS, SEND or BURN
totalXecUtxos,
totalTokenUtxos,
tokenId,
tokenAmount, // optional - only for sending or burning
feeInSatsPerByte,
txBuilder,
) => {
let totalXecInputUtxoValue = new BigNumber(0);
let remainderXecValue = new BigNumber(0);
let remainderTokenValue = new BigNumber(0);
let totalXecInputUtxos = [];
let txFee = 0;
let tokenUtxosBeingSpent = [];
try {
if (
!tokenAction ||
!totalXecUtxos ||
(tokenAction !== 'GENESIS' && !tokenId) ||
!feeInSatsPerByte ||
!txBuilder
) {
throw new Error('Invalid token tx input parameter');
}
// collate XEC UTXOs for this token tx
const txOutputs =
tokenAction === 'GENESIS'
? 2 // one for genesis OP_RETURN output and one for change
: 4; // for SEND/BURN token txs see T2645 on why this is not dynamically generated
for (let i = 0; i < totalXecUtxos.length; i++) {
const thisXecUtxo = totalXecUtxos[i];
totalXecInputUtxoValue = totalXecInputUtxoValue.plus(
new BigNumber(thisXecUtxo.value),
);
const vout = thisXecUtxo.outpoint.outIdx;
const txid = thisXecUtxo.outpoint.txid;
// add input with txid and index of vout
txBuilder.addInput(txid, vout);
totalXecInputUtxos.push(thisXecUtxo);
txFee = calcFee(totalXecInputUtxos, txOutputs, feeInSatsPerByte);
remainderXecValue =
tokenAction === 'GENESIS'
? totalXecInputUtxoValue
.minus(new BigNumber(appConfig.etokenSats))
.minus(new BigNumber(txFee))
: totalXecInputUtxoValue
.minus(new BigNumber(appConfig.etokenSats * 2)) // one for token send/burn output, one for token change
.minus(new BigNumber(txFee));
if (remainderXecValue.gte(0)) {
break;
}
}
if (remainderXecValue.lt(0)) {
throw new Error(`Insufficient funds`);
}
let filteredTokenInputUtxos = [];
let finalTokenAmountSpent = new BigNumber(0);
let tokenAmountBeingSpent = new BigNumber(tokenAmount);
if (tokenAction === 'SEND' || tokenAction === 'BURN') {
// filter for token UTXOs matching the token being sent/burnt
filteredTokenInputUtxos = totalTokenUtxos.filter(utxo => {
if (
utxo && // UTXO is associated with a token.
utxo.slpMeta.tokenId === tokenId && // UTXO matches the token ID.
!utxo.slpToken.isMintBaton // UTXO is not a minting baton.
) {
return true;
}
return false;
});
if (filteredTokenInputUtxos.length === 0) {
throw new Error(
'No token UTXOs for the specified token could be found.',
);
}
// collate token UTXOs to cover the token amount being sent/burnt
for (let i = 0; i < filteredTokenInputUtxos.length; i++) {
finalTokenAmountSpent = finalTokenAmountSpent.plus(
new BigNumber(filteredTokenInputUtxos[i].tokenQty),
);
txBuilder.addInput(
filteredTokenInputUtxos[i].outpoint.txid,
filteredTokenInputUtxos[i].outpoint.outIdx,
);
tokenUtxosBeingSpent.push(filteredTokenInputUtxos[i]);
if (tokenAmountBeingSpent.lte(finalTokenAmountSpent)) {
break;
}
}
// calculate token change
remainderTokenValue = finalTokenAmountSpent.minus(
new BigNumber(tokenAmount),
);
if (remainderTokenValue.lt(0)) {
throw new Error(
'Insufficient token UTXOs for the specified token amount.',
);
}
}
} catch (err) {
console.log(`generateTokenTxInput() error: ` + err);
throw err;
}
return {
txBuilder: txBuilder,
inputXecUtxos: totalXecInputUtxos,
inputTokenUtxos: tokenUtxosBeingSpent,
remainderXecValue: remainderXecValue,
remainderTokenValue: remainderTokenValue,
};
};
export const getChangeAddressFromInputUtxos = (inputUtxos, wallet) => {
if (!inputUtxos || !wallet) {
throw new Error('Invalid getChangeAddressFromWallet input parameter');
}
// Assume change address is input address of utxo at index 0
let changeAddress;
// Validate address
try {
changeAddress = inputUtxos[0].address;
if (
!isValidXecAddress(changeAddress) &&
!isValidBchAddress(changeAddress)
) {
throw new Error('Invalid change address');
}
} catch (err) {
throw new Error('Invalid input utxo');
}
return changeAddress;
};
/**
* Get the total XEC amount sent in a one-to-many XEC tx
* @param {array} destinationAddressAndValueArray
* Array constructed by user input of addresses and values
* e.g. [
* "<address>, <value>",
* "<address>, <value>"
* ]
* @returns {number} total value of XEC
*/
export const sumOneToManyXec = destinationAddressAndValueArray => {
return destinationAddressAndValueArray.reduce((prev, curr) => {
return parseFloat(prev) + parseFloat(curr.split(',')[1]);
}, 0);
};
/**
* Return an integer that is the given amountXEC in satoshis
* @param {Number} amountXec
* @returns {Integer} satoshis
*/
export const toSatoshis = amountXec => {
const SATOSHIS_PER_XEC = 100;
// Math.round returns the nearest integer value
// e.g. in JS, 151.52 * 100 = 15152.000000000002
// We need to return 15152
return Math.round(SATOSHIS_PER_XEC * amountXec);
};
/*
* Generates an OP_RETURN script for a version 0 alias registration tx
*
* Returns the final encoded script object ready to be added as a transaction output
*/
export const generateAliasOpReturnScript = (alias, address) => {
// Note: utxolib.script.compile(script) will add pushdata bytes for each buffer
// utxolib.script.compile(script) will not add pushdata bytes for raw data
// Initialize script array with OP_RETURN byte (6a) as rawdata (i.e. you want compiled result of 6a, not 016a)
let script = [opreturnConfig.opReturnPrefixDec];
// Push alias protocol identifier
script.push(
Buffer.from(opreturnConfig.appPrefixesHex.aliasRegistration, 'hex'), // '.xec'
);
// Push alias protocol tx version to stack
// Per spec, push this as OP_0
script.push(0);
// Push alias to the stack
script.push(Buffer.from(alias, 'utf8'));
// Get the type and hash of the address in string format
const { type, hash } = cashaddr.decode(address, true);
// Determine address type and corresponding address version byte
let addressVersionByte;
// Version bytes per cashaddr spec,https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
if (type === 'p2pkh') {
addressVersionByte = '00'; // one byte 0 in hex
} else if (type === 'p2sh') {
addressVersionByte = '08'; // one byte 8 in hex
} else {
throw new Error('Unsupported address type');
}
// Push <addressVersionByte> and <addressPayload>
script.push(Buffer.from(`${addressVersionByte}${hash}`, 'hex'));
return utxolib.script.compile(script);
};
-/*
- * Generates an OP_RETURN script to reflect the various send XEC permutations
- * involving messaging, encryption, eToken IDs and airdrop flags.
- *
- * Returns the final encoded script object
- */
-export const generateOpReturnScript = (
- optionalOpReturnMsg,
- encryptionFlag,
- airdropFlag,
- airdropTokenId,
- encryptedEj,
- optionalAliasRegistrationFlag = false,
-) => {
- // encrypted mesage is mandatory when encryptionFlag is true
- // airdrop token id is mandatory when airdropFlag is true
- if ((encryptionFlag && !encryptedEj) || (airdropFlag && !airdropTokenId)) {
- throw new Error('Invalid OP RETURN script input');
- }
-
- // Note: script.push(Buffer.from(opreturnConfig.opReturnPrefixHex, 'hex')); actually evaluates to '016a'
- // instead of keeping the hex string intact. This behavour is specific to the initial script array element.
- // To get around this, the bch-js approach of directly using the opReturn prefix in decimal form for the initial entry is used here.
- let script = [opreturnConfig.opReturnPrefixDec]; // initialize script with the OP_RETURN op code (6a) in decimal form (106)
-
- try {
- if (encryptionFlag) {
- // if the user has opted to encrypt this message
-
- // add the encrypted cashtab messaging prefix and encrypted msg to script
- script.push(
- Buffer.from(
- opreturnConfig.appPrefixesHex.cashtabEncrypted,
- 'hex',
- ), // 65746162
- );
-
- // add the encrypted message to script
- script.push(Buffer.from(encryptedEj));
- } else {
- // this is an un-encrypted message
-
- if (airdropFlag) {
- // if this was routed from the airdrop component
- // add the airdrop prefix to script
- script.push(
- Buffer.from(opreturnConfig.appPrefixesHex.airdrop, 'hex'), // drop
- );
- // add the airdrop token ID to script
- script.push(Buffer.from(airdropTokenId, 'hex'));
- }
-
- if (optionalAliasRegistrationFlag) {
- script.push(
- Buffer.from(
- opreturnConfig.appPrefixesHex.aliasRegistration,
- 'hex',
- ), // '.xec'
- );
- } else {
- // add the cashtab prefix to script
- script.push(
- Buffer.from(opreturnConfig.appPrefixesHex.cashtab, 'hex'), // 00746162
- );
- }
- // add the un-encrypted message to script if supplied
- if (optionalOpReturnMsg) {
- script.push(Buffer.from(optionalOpReturnMsg));
- }
- }
- } catch (err) {
- console.log('Error in generateOpReturnScript(): ' + err);
- throw err;
- }
-
- return utxolib.script.compile(script);
-};
export const generateTxOutput = (
isOneToMany,
singleSendValue,
satoshisToSend,
totalInputUtxoValue,
destinationAddress,
destinationAddressAndValueArray,
changeAddress,
txFee,
txBuilder,
) => {
try {
if (
(isOneToMany && !destinationAddressAndValueArray) ||
(!isOneToMany && !destinationAddress && !singleSendValue) ||
!changeAddress ||
!satoshisToSend ||
!totalInputUtxoValue ||
!txFee ||
!txBuilder
) {
throw new Error('Invalid tx input parameter');
}
// amount to send back to the remainder address.
const remainder = new BigNumber(totalInputUtxoValue)
.minus(satoshisToSend)
.minus(txFee);
if (remainder.lt(0)) {
throw new Error(`Insufficient funds`);
}
if (isOneToMany) {
// for one to many mode, add the multiple outputs from the array
let arrayLength = destinationAddressAndValueArray.length;
for (let i = 0; i < arrayLength; i++) {
// add each send tx from the array as an output
let outputAddress = destinationAddressAndValueArray[i]
.split(',')[0]
.trim();
let outputValue = new BigNumber(
destinationAddressAndValueArray[i].split(',')[1],
);
txBuilder.addOutput(
cashaddr.toLegacy(outputAddress),
parseInt(fromXecToSatoshis(outputValue)),
);
}
} else {
// for one to one mode, add output w/ single address and amount to send
txBuilder.addOutput(
cashaddr.toLegacy(destinationAddress),
parseInt(fromXecToSatoshis(singleSendValue)),
);
}
// if a remainder exists, return to change address as the final output
if (remainder.gte(new BigNumber(appConfig.dustSats))) {
txBuilder.addOutput(
cashaddr.toLegacy(changeAddress),
parseInt(remainder),
);
}
} catch (err) {
console.log('Error in generateTxOutput(): ' + err);
throw err;
}
return txBuilder;
};
export const signAndBuildTx = (inputUtxos, txBuilder, wallet) => {
if (!inputUtxos || inputUtxos.length === 0 || !txBuilder || !wallet) {
throw new Error('Invalid buildTx parameter');
}
// Sign each XEC UTXO being consumed and refresh transactionBuilder
txBuilder = signUtxosByAddress(inputUtxos, wallet, txBuilder);
let hex;
try {
// build tx
const tx = txBuilder.build();
// output rawhex
hex = tx.toHex();
} catch (err) {
throw new Error('Transaction build failed');
}
return hex;
};
export function parseOpReturn(hexStr) {
if (
!hexStr ||
typeof hexStr !== 'string' ||
hexStr.substring(0, 2) !== opreturnConfig.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 === opreturnConfig.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 === opreturnConfig.appPrefixesHex.eToken) {
// add the extracted eToken prefix to array then exit loop
resultArray[i] = opreturnConfig.appPrefixesHex.eToken;
break;
} else if (
i === 0 &&
message === opreturnConfig.appPrefixesHex.cashtab
) {
// add the extracted Cashtab prefix to array
resultArray[i] = opreturnConfig.appPrefixesHex.cashtab;
} else if (
i === 0 &&
message === opreturnConfig.appPrefixesHex.cashtabEncrypted
) {
// add the Cashtab encryption prefix to array
resultArray[i] = opreturnConfig.appPrefixesHex.cashtabEncrypted;
} else if (
i === 0 &&
message === opreturnConfig.appPrefixesHex.airdrop
) {
// add the airdrop prefix to array
resultArray[i] = opreturnConfig.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 = appConfig.cashDecimals,
) => {
// Input 0.00000546 BCH
// Output 5.46 XEC or 0.00000546 BCH, depending on appConfig.cashDecimals
const amountBig = new BigNumber(amount);
const conversionFactor = new BigNumber(10 ** (8 - cashDecimals));
const amountSmallestDenomination = amountBig
.times(conversionFactor)
.toNumber();
return amountSmallestDenomination;
};
export const fromSatoshisToXec = (
amount,
cashDecimals = appConfig.cashDecimals,
) => {
const amountBig = new BigNumber(amount);
const multiplier = new BigNumber(10 ** (-1 * cashDecimals));
const amountInBaseUnits = amountBig.times(multiplier);
return amountInBaseUnits;
};
export const fromXecToSatoshis = (
sendAmount,
cashDecimals = appConfig.cashDecimals,
) => {
// Replace the BCH.toSatoshi method with an equivalent function that works for arbitrary decimal places
// Example, for an 8 decimal place currency like Bitcoin
// Input: a BigNumber of the amount of Bitcoin to be sent
// Output: a BigNumber of the amount of satoshis to be sent, or false if input is invalid
// Validate
// Input should be a BigNumber with no more decimal places than cashDecimals
const isValidSendAmount =
BigNumber.isBigNumber(sendAmount) && sendAmount.dp() <= cashDecimals;
if (!isValidSendAmount) {
return false;
}
const conversionFactor = new BigNumber(10 ** cashDecimals);
const sendAmountSmallestDenomination = sendAmount.times(conversionFactor);
return sendAmountSmallestDenomination;
};
export const flattenContactList = contactList => {
/*
Converts contactList from array of objects of type {address: <valid XEC address>, name: <string>} to array of addresses only
If contact list is invalid, returns and empty array
*/
if (!isValidContactList(contactList)) {
return [];
}
let flattenedContactList = [];
for (let i = 0; i < contactList.length; i += 1) {
const thisAddress = contactList[i].address;
flattenedContactList.push(thisAddress);
}
return flattenedContactList;
};
export const loadStoredWallet = walletStateFromStorage => {
// Accept cached tokens array that does not save BigNumber type of BigNumbers
// Return array with BigNumbers converted
// See BigNumber.js api for how to create a BigNumber object from an object
// https://mikemcl.github.io/bignumber.js/
const liveWalletState =
typeof walletStateFromStorage !== 'undefined'
? walletStateFromStorage
: {};
const keysInLiveWalletState = Object.keys(liveWalletState);
// Newly created wallets may not have a state field
// You only need to do this if you are loading a wallet
// that hasn't yet saved tokens[i].balance as a string
// instead of a BigNumber
if (keysInLiveWalletState.includes('tokens')) {
const { tokens } = liveWalletState;
if (
tokens.length > 0 &&
tokens[0] &&
tokens[0].balance &&
typeof tokens[0].balance !== 'string'
) {
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 appConfig.decimals changed since last startup
let nonSlpUtxosToParseForBalance;
let balancesRebased;
if (keysInLiveWalletState.length !== 0) {
if (keysInLiveWalletState.includes('slpBalancesAndUtxos')) {
// If this wallet still includes the wallet.state.slpBalancesAndUtxos field
nonSlpUtxosToParseForBalance =
liveWalletState.slpBalancesAndUtxos.nonSlpUtxos;
} else {
nonSlpUtxosToParseForBalance = liveWalletState.nonSlpUtxos;
}
balancesRebased = getWalletBalanceFromUtxos(
nonSlpUtxosToParseForBalance,
);
} else {
balancesRebased = {
totalBalanceInSatoshis: '0',
totalBalance: '0',
};
}
liveWalletState.balances = balancesRebased;
return liveWalletState;
};
export const getWalletBalanceFromUtxos = nonSlpUtxos => {
const totalBalanceInSatoshis = nonSlpUtxos.reduce(
(previousBalance, utxo) =>
previousBalance.plus(new BigNumber(utxo.value)),
new BigNumber(0),
);
return {
totalBalanceInSatoshis: totalBalanceInSatoshis.toString(),
totalBalance: fromSatoshisToXec(totalBalanceInSatoshis).toString(),
};
};
export const isValidStoredWallet = walletStateFromStorage => {
return (
typeof walletStateFromStorage === 'object' &&
'state' in walletStateFromStorage &&
'mnemonic' in walletStateFromStorage &&
'name' in walletStateFromStorage &&
'Path245' in walletStateFromStorage &&
'Path145' in walletStateFromStorage &&
'Path1899' in walletStateFromStorage &&
typeof walletStateFromStorage.state === 'object' &&
'balances' in walletStateFromStorage.state &&
!('hydratedUtxoDetails' in walletStateFromStorage.state) &&
('slpBalancesAndUtxos' in walletStateFromStorage.state ||
('slpUtxos' in walletStateFromStorage.state &&
'nonSlpUtxos' in walletStateFromStorage.state)) &&
'tokens' in walletStateFromStorage.state
);
};
export const getWalletState = wallet => {
if (!wallet || !wallet.state) {
return {
balances: { totalBalance: 0, totalBalanceInSatoshis: 0 },
hydratedUtxoDetails: {},
tokens: [],
slpUtxos: [],
nonSlpUtxos: [],
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;
}
// converts ecash, etoken, bitcoincash and simpleledger addresses to hash160
export function toHash160(addr) {
try {
// decode address hash
const { hash } = cashaddr.decode(addr);
// encode the address hash to legacy format (bitcoin)
const legacyAdress = bs58.encode(hash);
// convert legacy to hash160
const addrHash160 = Buffer.from(bs58.decode(legacyAdress)).toString(
'hex',
);
return addrHash160;
} catch (err) {
console.log('Error converting address to hash160');
throw err;
}
}
/* 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 isLegacyMigrationRequired = wallet => {
// If the wallet does not have Path1899,
// Or each Path1899, Path145, Path245 does not have a public key
// Then it requires migration
if (
!wallet.Path1899 ||
!wallet.Path1899.publicKey ||
!wallet.Path1899.hash160 ||
!wallet.Path145.publicKey ||
!wallet.Path145.hash160 ||
!wallet.Path245.publicKey ||
!wallet.Path245.hash160
) {
return true;
}
return false;
};
export const getHashArrayFromWallet = wallet => {
// If the wallet has wallet.Path1899.hash160, it's migrated and will have all of them
// Return false for an umigrated wallet
const hash160Array =
wallet && wallet.Path1899 && 'hash160' in wallet.Path1899
? [
wallet.Path245.hash160,
wallet.Path145.hash160,
wallet.Path1899.hash160,
]
: false;
return hash160Array;
};
export const isActiveWebsocket = ws => {
// Return true if websocket is connected and subscribed
// Otherwise return false
return (
ws !== null &&
ws &&
'_ws' in ws &&
'readyState' in ws._ws &&
ws._ws.readyState === 1 &&
'_subs' in ws &&
ws._subs.length > 0
);
};
export const hash160ToAddress = hash160 => {
const buffer = Buffer.from(hash160, 'hex');
// Because ecashaddrjs only accepts Uint8Array as input type, convert
const hash160ArrayBuffer = new ArrayBuffer(buffer.length);
const hash160Uint8Array = new Uint8Array(hash160ArrayBuffer);
for (let i = 0; i < hash160Uint8Array.length; i += 1) {
hash160Uint8Array[i] = buffer[i];
}
// Encode ecash: address
const ecashAddr = cashaddr.encode('ecash', 'P2PKH', hash160Uint8Array);
return ecashAddr;
};
export const outputScriptToAddress = outputScript => {
// returns P2SH or P2PKH address
// P2PKH addresses are in outputScript of type 76a914...88ac
// P2SH addresses are in outputScript of type a914...87
// Return false if cannot determine P2PKH or P2SH address
const typeTestSlice = outputScript.slice(0, 4);
let addressType;
let hash160;
switch (typeTestSlice) {
case '76a9':
addressType = 'P2PKH';
hash160 = outputScript.substring(
outputScript.indexOf('76a914') + '76a914'.length,
outputScript.lastIndexOf('88ac'),
);
break;
case 'a914':
addressType = 'P2SH';
hash160 = outputScript.substring(
outputScript.indexOf('a914') + 'a914'.length,
outputScript.lastIndexOf('87'),
);
break;
default:
throw new Error('Unrecognized outputScript format');
}
// Test hash160 for correct length
if (hash160.length !== 40) {
throw new Error('Parsed hash160 is incorrect length');
}
const buffer = Buffer.from(hash160, 'hex');
// Because ecashaddrjs only accepts Uint8Array as input type, convert
const hash160ArrayBuffer = new ArrayBuffer(buffer.length);
const hash160Uint8Array = new Uint8Array(hash160ArrayBuffer);
for (let i = 0; i < hash160Uint8Array.length; i += 1) {
hash160Uint8Array[i] = buffer[i];
}
// Encode ecash: address
const ecashAddress = cashaddr.encode(
'ecash',
addressType,
hash160Uint8Array,
);
return ecashAddress;
};
export function parseAddressForParams(addressString) {
// Build return obj
const addressInfo = {
address: '',
queryString: null,
amount: null,
};
// Parse address string for parameters
const paramCheck = addressString.split('?');
let cleanAddress = paramCheck[0];
addressInfo.address = cleanAddress;
// Check for parameters
// only the amount param is currently supported
let queryString = null;
let amount = null;
if (paramCheck.length > 1) {
queryString = paramCheck[1];
addressInfo.queryString = queryString;
const addrParams = new URLSearchParams(queryString);
if (addrParams.has('amount')) {
// Amount in XEC
try {
amount = new BigNumber(
parseFloat(addrParams.get('amount')),
).toString();
} catch (err) {
amount = null;
}
}
}
addressInfo.amount = amount;
return addressInfo;
}