std::shared_ptr<WalletInfo> generateWallet(CryptoNote::WalletGreen &wallet)
{
const std::string walletFileName = getNewWalletFileName();
const std::string msg = "Give your new wallet a password: "******"If you lose these your wallet cannot be ")
<< WarningMsg("recreated!")
<< std::endl << std::endl;
return std::make_shared<WalletInfo>(walletFileName, walletPass,
walletAddress, false, wallet);
}
void saveCSV(CryptoNote::WalletGreen &wallet, CryptoNote::INode &node)
{
const size_t numTransactions = wallet.getTransactionCount();
std::ofstream csv;
csv.open(WalletConfig::csvFilename);
if (!csv)
{
std::cout << WarningMsg("Couldn't open transactions.csv file for "
"saving!")
<< std::endl
<< WarningMsg("Ensure it is not open in any other "
"application.")
<< std::endl;
return;
}
std::cout << InformationMsg("Saving CSV file...") << std::endl;
/* Create CSV header */
csv << "Timestamp,Block Height,Hash,Amount,In/Out"
<< std::endl;
/* Loop through transactions */
for (size_t i = 0; i < numTransactions; i++)
{
const CryptoNote::WalletTransaction t = wallet.getTransaction(i);
/* Ignore fusion transactions */
if (t.totalAmount == 0)
{
continue;
}
const std::string amount = formatAmountBasic(std::abs(t.totalAmount));
const std::string direction = t.totalAmount > 0 ? "IN" : "OUT";
csv << unixTimeToDate(t.timestamp) << "," /* Timestamp */
<< t.blockHeight << "," /* Block Height */
<< Common::podToHex(t.hash) << "," /* Hash */
<< amount << "," /* Amount */
<< direction /* In/Out */
<< std::endl;
}
csv.close();
std::cout << SuccessMsg("CSV successfully written to ")
<< SuccessMsg(WalletConfig::csvFilename)
<< SuccessMsg("!")
<< std::endl;
}
void printPrivateKeys(CryptoNote::WalletGreen &wallet, bool viewWallet)
{
auto privateViewKey = wallet.getViewKey().secretKey;
if (viewWallet)
{
std::cout << SuccessMsg("Private view key:")
<< std::endl
<< SuccessMsg(Common::podToHex(privateViewKey))
<< std::endl;
return;
}
auto privateSpendKey = wallet.getAddressSpendKey(0).secretKey;
Crypto::SecretKey derivedPrivateViewKey;
CryptoNote::AccountBase::generateViewFromSpend(privateSpendKey,
derivedPrivateViewKey);
const bool deterministicPrivateKeys
= derivedPrivateViewKey == privateViewKey;
std::cout << SuccessMsg("Private spend key:")
<< std::endl
<< SuccessMsg(Common::podToHex(privateSpendKey))
<< std::endl
<< std::endl
<< SuccessMsg("Private view key:")
<< std::endl
<< SuccessMsg(Common::podToHex(privateViewKey))
<< std::endl;
if (deterministicPrivateKeys)
{
std::string mnemonicSeed;
Crypto::ElectrumWords::bytes_to_words(privateSpendKey,
mnemonicSeed,
"English");
std::cout << std::endl
<< SuccessMsg("Mnemonic seed:")
<< std::endl
<< SuccessMsg(mnemonicSeed)
<< std::endl;
}
std::cout << std::endl
<< SuccessMsg("GUI Importable Private Key:")
<< std::endl
<< SuccessMsg(getGUIPrivateKey(wallet))
<< std::endl;
}
void balance(CryptoNote::INode &node, CryptoNote::WalletGreen &wallet,
bool viewWallet)
{
const uint64_t unconfirmedBalance = wallet.getPendingBalance();
const uint64_t confirmedBalance = wallet.getActualBalance();
const uint64_t totalBalance = unconfirmedBalance + confirmedBalance;
const uint32_t localHeight = node.getLastLocalBlockHeight();
const uint32_t remoteHeight = node.getLastKnownBlockHeight();
const uint32_t walletHeight = wallet.getBlockCount();
std::cout << "Available balance: "
<< SuccessMsg(formatAmount(confirmedBalance)) << std::endl
<< "Locked (unconfirmed) balance: "
<< WarningMsg(formatAmount(unconfirmedBalance))
<< std::endl << "Total balance: "
<< InformationMsg(formatAmount(totalBalance)) << std::endl;
if (viewWallet)
{
std::cout << std::endl
<< InformationMsg("Please note that view only wallets "
"can only track incoming transactions,")
<< std::endl
<< InformationMsg("and so your wallet balance may appear "
"inflated.") << std::endl;
}
if (localHeight < remoteHeight)
{
std::cout << std::endl
<< InformationMsg("Your daemon is not fully synced with "
"the network!")
<< std::endl
<< "Your balance may be incorrect until you are fully "
<< "synced!" << std::endl;
}
/* Small buffer because wallet height doesn't update instantly like node
height does */
else if (walletHeight + 1000 < remoteHeight)
{
std::cout << std::endl
<< InformationMsg("The blockchain is still being scanned for "
"your transactions.")
<< std::endl
<< "Balances might be incorrect whilst this is ongoing."
<< std::endl;
}
}
void fullOptimize(CryptoNote::WalletGreen &wallet)
{
std::cout << "Attempting to optimize your wallet to allow you to "
<< "send large amounts at once. " << std::endl
<< WarningMsg("This may take a very long time!") << std::endl;
if (!confirm("Do you want to proceed?"))
{
std::cout << WarningMsg("Cancelling optimization.") << std::endl;
return;
}
for (int i = 1;;i++)
{
std::cout << InformationMsg("Running optimization round "
+ std::to_string(i) + "...")
<< std::endl;
/* Optimize as many times as possible until optimization is no longer
possible. */
if (!optimize(wallet, wallet.getActualBalance()))
{
break;
}
}
std::cout << SuccessMsg("Full optimization completed!") << std::endl;
}
/* This makes sure to call functions on the node which only return cached
data. This ensures it returns promptly, and doesn't hang waiting for a
response when the node is having issues. */
void status(CryptoNote::INode &node, CryptoNote::WalletGreen &wallet)
{
uint32_t localHeight = node.getLastLocalBlockHeight();
uint32_t remoteHeight = node.getLastKnownBlockHeight();
uint32_t walletHeight = wallet.getBlockCount() - 1;
/* Print the heights of local, remote, and wallet */
printHeights(localHeight, remoteHeight, walletHeight);
std::cout << std::endl;
/* Print the network and wallet sync status in percentage */
printSyncStatus(localHeight, remoteHeight, walletHeight);
std::cout << std::endl;
/* Print the network hashrate, based on the last local block */
printHashrate(node.getLastLocalBlockHeaderInfo().difficulty);
/* Print the amount of peers we have */
printPeerCount(node.getPeerCount());
std::cout << std::endl;
/* Print a summary of the sync status */
printSyncSummary(localHeight, remoteHeight, walletHeight);
}
size_t makeFusionTransaction(CryptoNote::WalletGreen &wallet,
uint64_t threshold)
{
uint64_t bestThreshold = threshold;
size_t optimizable = 0;
/* Find the best threshold by starting at threshold and decreasing by
half till we get to the minimum amount, storing the threshold that
gave us the most amount of optimizable amounts */
while (threshold > WalletConfig::minimumSend)
{
const auto fusionReadyCount
= wallet.estimate(threshold).fusionReadyCount;
if (fusionReadyCount > optimizable)
{
optimizable = fusionReadyCount;
bestThreshold = threshold;
}
threshold /= 2;
}
/* Can't optimize */
if (optimizable == 0)
{
return CryptoNote::WALLET_INVALID_TRANSACTION_ID;
}
try
{
return wallet.createFusionTransaction(bestThreshold,
WalletConfig::defaultMixin);
}
catch (const std::runtime_error &e)
{
std::cout << WarningMsg("Failed to send fusion transaction: ")
<< WarningMsg(e.what()) << std::endl;
return CryptoNote::WALLET_INVALID_TRANSACTION_ID;
}
}
void promptSaveKeys(CryptoNote::WalletGreen &wallet)
{
std::cout << "Welcome to your new wallet, here is your payment address:"
<< std::endl << InformationMsg(wallet.getAddress(0))
<< std::endl << std::endl
<< "Please copy your secret keys and mnemonic seed and store "
<< "them in a secure location: " << std::endl;
printPrivateKeys(wallet, false);
std::cout << std::endl;
}
std::shared_ptr<WalletInfo> createViewWallet(CryptoNote::WalletGreen &wallet)
{
std::cout << WarningMsg("View wallets are only for viewing incoming ")
<< WarningMsg("transactions, and cannot make transfers.")
<< std::endl;
bool create = confirm("Is this OK?");
std::cout << std::endl;
if (!create)
{
return nullptr;
}
Crypto::SecretKey privateViewKey = getPrivateKey("Private View Key: ");
std::string address;
while (true)
{
std::cout << InformationMsg("Enter your public ")
<< InformationMsg(WalletConfig::ticker)
<< InformationMsg(" address: ");
std::getline(std::cin, address);
boost::algorithm::trim(address);
if (parseAddress(address))
{
break;
}
}
const std::string walletFileName = getNewWalletFileName();
const std::string msg = "Give your new wallet a password: "******"Your view wallet ")
<< InformationMsg(address)
<< InformationMsg(" has been successfully imported!")
<< std::endl << std::endl;
viewWalletMsg();
return std::make_shared<WalletInfo>(walletFileName, walletPass,
address, true, wallet);
}
void listTransfers(bool incoming, bool outgoing,
CryptoNote::WalletGreen &wallet, CryptoNote::INode &node)
{
const size_t numTransactions = wallet.getTransactionCount();
int64_t totalSpent = 0;
int64_t totalReceived = 0;
for (size_t i = 0; i < numTransactions; i++)
{
const CryptoNote::WalletTransaction t = wallet.getTransaction(i);
if (t.totalAmount < 0 && outgoing)
{
printOutgoingTransfer(t, node);
totalSpent += -t.totalAmount;
}
else if (t.totalAmount > 0 && incoming)
{
printIncomingTransfer(t, node);
totalReceived += t.totalAmount;
}
}
if (incoming)
{
std::cout << SuccessMsg("Total received: "
+ formatAmount(totalReceived))
<< std::endl;
}
if (outgoing)
{
std::cout << WarningMsg("Total spent: " + formatAmount(totalSpent))
<< std::endl;
}
}
std::shared_ptr<WalletInfo> importFromKeys(CryptoNote::WalletGreen &wallet,
Crypto::SecretKey privateSpendKey,
Crypto::SecretKey privateViewKey)
{
const std::string walletFileName = getNewWalletFileName();
const std::string msg = "Give your new wallet a password: "******"Your wallet ")
<< InformationMsg(walletAddress)
<< InformationMsg(" has been successfully imported!")
<< std::endl << std::endl;
return std::make_shared<WalletInfo>(walletFileName, walletPass,
walletAddress, false, wallet);
}
std::string getGUIPrivateKey(CryptoNote::WalletGreen &wallet)
{
auto viewKey = wallet.getViewKey();
auto spendKey = wallet.getAddressSpendKey(0);
CryptoNote::AccountPublicAddress addr
{
spendKey.publicKey,
viewKey.publicKey,
};
CryptoNote::AccountKeys keys
{
addr,
spendKey.secretKey,
viewKey.secretKey,
};
return Tools::Base58::encode_addr
(
CryptoNote::parameters::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
std::string(reinterpret_cast<char*>(&keys), sizeof(keys))
);
}
bool fusionTX(CryptoNote::WalletGreen &wallet,
CryptoNote::TransactionParameters p)
{
std::cout << WarningMsg("Your transaction is too large to be accepted by "
"the network!")
<< std::endl << "We're attempting to optimize your "
<< "wallet, which hopefully will make the transaction small "
<< "enough to fit in a block." << std::endl
<< "Please wait, this will take some time..." << std::endl
<< std::endl;
/* We could check if optimization succeeded, but it's not really needed
because we then check if the transaction is too large... it could have
potentially become valid because another payment came in. */
optimize(wallet, p.destinations[0].amount + p.fee);
const auto startTime = std::chrono::system_clock::now();
while (wallet.getActualBalance() < p.destinations[0].amount + p.fee)
{
/* Break after a minute just in case something has gone wrong */
if ((std::chrono::system_clock::now() - startTime) >
std::chrono::minutes(5))
{
std::cout << WarningMsg("Fusion transactions have "
"completed, however available "
"balance is less than transfer "
"amount specified.") << std::endl
<< WarningMsg("Transfer aborted, please review "
"and start a new transfer.")
<< std::endl;
return false;
}
std::cout << WarningMsg("Optimization completed, but balance "
"is not fully unlocked yet!")
<< std::endl
<< SuccessMsg("Will try again in 5 seconds...")
<< std::endl;
std::this_thread::sleep_for(std::chrono::seconds(5));
}
return true;
}
void txSecretKey(CryptoNote::WalletGreen &wallet)
{
std::string hashStr;
Crypto::Hash txid;
while (true)
{
std::cout << InformationMsg("Enter transaction hash: ");
std::getline(std::cin, hashStr);
boost::algorithm::trim(hashStr);
if (!parse_hash256(hashStr, txid)) {
std::cout << WarningMsg("Failed to parse txid") << std::endl;
return;
}
else {
break;
}
if (std::cin.fail() || std::cin.eof()) {
std::cin.clear();
break;
}
}
Crypto::SecretKey txSecretKey = wallet.getTransactionSecretKey(txid);
if (txSecretKey == CryptoNote::NULL_SECRET_KEY) {
std::cout << WarningMsg("Transaction ")
<< WarningMsg(hashStr)
<< WarningMsg(" secret key is not available")
<< std::endl;
return;
}
std::cout << SuccessMsg("Transaction secret key: ")
<< std::endl
<< SuccessMsg(Common::podToHex(txSecretKey))
<< std::endl;
}
void splitTx(CryptoNote::WalletGreen &wallet,
CryptoNote::TransactionParameters p)
{
std::cout << "Wallet optimization failed, transactions are still too large "
<< "to send in one chunk, splitting into multiple chunks."
<< std::endl << "This may take a long time as portions of your "
<< "balance get locked whilst sending a transaction."
<< std::endl << "It may also slightly raise the fee you have "
<< "to pay, and hence reduce the total amount you can send if "
<< "your balance cannot cover it." << std::endl;
if (!confirm("Is this OK?"))
{
std::cout << WarningMsg("Cancelling transaction.") << std::endl;
return;
}
CryptoNote::TransactionParameters restoreInitialTx = p;
uint64_t maxSize = wallet.getMaxTxSize();
size_t txSize = wallet.getTxSize(p);
uint64_t minFee = CryptoNote::parameters::MINIMUM_FEE;
for (int numTxMultiplier = 2; ; numTxMultiplier++)
{
/* We modify p a bit in this function, so restore back to initial
state each time */
p = restoreInitialTx;
/* We can't just evenly divide a transaction up to be < 115k bytes by
decreasing the amount we're sending, because depending upon the
inputs we might need to split into more transactions, so a good
start is attempting to split them into chunks of 55k bytes or so.
We then check at the end that each transaction is small enough, and
if not, we up the numTxMultiplier and try again with more
transactions. */
int numTransactions
= int(numTxMultiplier *
(std::ceil(double(txSize) / double(maxSize))));
/* Split the requested fee over each transaction, i.e. if a fee of 200
TRTL was requested and we split it into 4 transactions each one will
have a fee of 5 TRTL. If the fee per transaction is less than the
min fee, use the min fee. */
uint64_t feePerTx = std::max (p.fee / numTransactions, minFee);
uint64_t totalFee = feePerTx * numTransactions;
uint64_t totalCost = p.destinations[0].amount + totalFee;
/* If we have to use the minimum fee instead of splitting the total fee,
then it is possible the user no longer has the balance to cover this
transaction. So, we slightly lower the amount they are sending. */
if (totalCost > wallet.getActualBalance())
{
p.destinations[0].amount = wallet.getActualBalance() - totalFee;
}
uint64_t amountPerTx = p.destinations[0].amount / numTransactions;
/* Left over amount from integral division */
uint64_t change = p.destinations[0].amount % numTransactions;
std::vector<CryptoNote::TransactionParameters> transfers;
for (int i = 0; i < numTransactions; i++)
{
CryptoNote::TransactionParameters tmp = p;
tmp.destinations[0].amount = amountPerTx;
tmp.fee = feePerTx;
transfers.push_back(tmp);
}
/* Add the extra change to the first transaction */
transfers[0].destinations[0].amount += change;
for (auto tx : transfers)
{
/* One of the transfers is too large. Retry, cutting the
transactions into smaller pieces */
if (wallet.txIsTooLarge(tx))
{
std::cout << "Split up transactions are still too large! "
<< "Splitting up into smaller chunks." << std::endl;
continue;
}
}
sendMultipleTransactions(wallet, transfers);
return;
}
}
std::shared_ptr<WalletInfo> openWallet(CryptoNote::WalletGreen &wallet,
Config &config)
{
const std::string walletFileName = getExistingWalletFileName(config);
bool initial = true;
while (true)
{
std::string walletPass;
/* Only use the command line pass once, otherwise we will infinite
loop if it is incorrect */
if (initial && config.passGiven)
{
walletPass = config.walletPass;
}
else
{
walletPass = getWalletPassword(false, "Enter password: "******"Your view only wallet ")
<< InformationMsg(walletAddress)
<< InformationMsg(" has been successfully opened!")
<< std::endl << std::endl;
viewWalletMsg();
viewWallet = true;
}
else
{
std::cout << std::endl
<< InformationMsg("Your wallet ")
<< InformationMsg(walletAddress)
<< InformationMsg(" has been successfully opened!")
<< std::endl << std::endl;
}
return std::make_shared<WalletInfo>(
walletFileName, walletPass, walletAddress, viewWallet, wallet
);
}
catch (const std::system_error& e)
{
bool handled = false;
switch (e.code().value())
{
case CryptoNote::error::WRONG_PASSWORD:
{
std::cout << std::endl
<< WarningMsg("Incorrect password! Try again.")
<< std::endl << std::endl;
handled = true;
break;
}
case CryptoNote::error::WRONG_VERSION:
{
std::stringstream msg;
msg << "Could not open wallet file! It doesn't appear "
<< "to be a valid wallet!" << std::endl
<< "Ensure you are opening a wallet file, and the "
<< "file has not gotten corrupted." << std::endl
<< "Try reimporting via keys, and always close "
<< WalletConfig::walletName << " with the exit "
<< "command to prevent corruption." << std::endl;
std::cout << WarningMsg(msg.str()) << std::endl;
return nullptr;
}
}
if (handled)
{
continue;
}
const std::string alreadyOpenMsg =
"MemoryMappedFile::open: The process cannot access the file "
"because it is being used by another process.";
const std::string errorMsg = e.what();
/* The message actually has a \r\n on the end but i'd prefer to
keep just the raw string in the source so check the it starts
with instead */
if (boost::starts_with(errorMsg, alreadyOpenMsg))
{
std::cout << WarningMsg("Could not open wallet! It is already "
"open in another process.")
<< std::endl
<< WarningMsg("Check with a task manager that you "
"don't have ")
<< WalletConfig::walletName
<< WarningMsg(" open twice.")
<< std::endl
<< WarningMsg("Also check you don't have another "
"wallet program open, such as a GUI "
"wallet or ")
<< WarningMsg(WalletConfig::walletdName)
<< WarningMsg(".")
<< std::endl << std::endl;
return nullptr;
}
else
{
std::cout << "Unexpected error: " << errorMsg << std::endl;
std::cout << "Please report this error message and what "
<< "you did to cause it." << std::endl << std::endl;
return nullptr;
}
}
}
}
bool optimize(CryptoNote::WalletGreen &wallet, uint64_t threshold)
{
std::vector<Crypto::Hash> fusionTransactionHashes;
while (true)
{
/* Create as many fusion transactions until we can't send anymore,
either because balance is locked too much or we can no longer
optimize anymore transactions */
const size_t tmpFusionTxID = makeFusionTransaction(wallet, threshold);
if (tmpFusionTxID == CryptoNote::WALLET_INVALID_TRANSACTION_ID)
{
break;
}
else
{
const CryptoNote::WalletTransaction w
= wallet.getTransaction(tmpFusionTxID);
fusionTransactionHashes.push_back(w.hash);
if (fusionTransactionHashes.size() == 1)
{
std::cout << SuccessMsg("Created 1 fusion transaction!")
<< std::endl;
}
else
{
std::cout << SuccessMsg("Created "
+ std::to_string(fusionTransactionHashes.size())
+ " fusion transactions!") << std::endl;
}
}
}
if (fusionTransactionHashes.empty())
{
return false;
}
/* Hurr durr grammar */
if (fusionTransactionHashes.size() == 1)
{
std::cout << SuccessMsg("1 fusion transaction has been sent, waiting "
"for balance to return and unlock")
<< std::endl << std::endl;
}
else
{
std::cout << SuccessMsg(std::to_string(fusionTransactionHashes.size()) +
" fusion transactions have been sent, waiting "
"for balance to return and unlock")
<< std::endl << std::endl;
}
wallet.updateInternalCache();
/* Short sleep to ensure it's in the transaction pool when we poll it */
std::this_thread::sleep_for(std::chrono::seconds(1));
while (true)
{
const std::vector<CryptoNote::WalletTransactionWithTransfers>
unconfirmedTransactions = wallet.getUnconfirmedTransactions();
std::vector<Crypto::Hash> unconfirmedTxHashes;
for (const auto &t : unconfirmedTransactions)
{
unconfirmedTxHashes.push_back(t.transaction.hash);
}
bool fusionCompleted = true;
/* Is our fusion transaction still unconfirmed? We can't gain the
benefits of fusioning if the balance hasn't unlocked, so we can
send this new optimized balance */
for (const auto &tx : fusionTransactionHashes)
{
/* If the fusion transaction hash is present in the unconfirmed
transactions pool, we need to wait for it to complete. */
if (std::find(unconfirmedTxHashes.begin(),
unconfirmedTxHashes.end(), tx)
!= unconfirmedTxHashes.end())
{
fusionCompleted = false;
}
else
{
/* We can't find this transaction in the unconfirmed
transaction pool anymore, so it has been confirmed. Remove
it so we both have to check less transactions each time,
and we can easily update the transactions left to confirm
output message */
fusionTransactionHashes.erase(std::remove
(fusionTransactionHashes.begin(),
fusionTransactionHashes.end(), tx),
fusionTransactionHashes.end());
}
}
if (!fusionCompleted)
{
std::cout << WarningMsg("Balance is still locked, "
+ std::to_string(fusionTransactionHashes.size()));
/* More grammar... */
if (fusionTransactionHashes.size() == 1)
{
std::cout << WarningMsg(" fusion transaction still to be "
"confirmed.");
}
else
{
std::cout << WarningMsg(" fusion transactions still to be "
"confirmed.");
}
std::cout << std::endl
<< SuccessMsg("Will try again in 1 minute...")
<< std::endl;
std::this_thread::sleep_for(std::chrono::minutes(1));
wallet.updateInternalCache();
}
else
{
std::cout << SuccessMsg("All fusion transactions confirmed!")
<< std::endl;
break;
}
}
return true;
}
void splitTx(CryptoNote::WalletGreen &wallet,
CryptoNote::TransactionParameters p)
{
std::cout << "Wallet optimization failed, transactions are still too large "
<< "to send in one chunk, splitting into multiple chunks."
<< std::endl << "This may take a long time as portions of your "
<< "balance get locked whilst sending a transaction."
<< std::endl << "It may also slightly raise the fee you have "
<< "to pay, and hence reduce the total amount you can send if "
<< "your balance cannot cover it." << std::endl;
if (!confirm("Is this OK?"))
{
std::cout << WarningMsg("Cancelling transaction.") << std::endl;
return;
}
CryptoNote::TransactionParameters restoreInitialTx = p;
uint64_t maxSize = wallet.getMaxTxSize();
size_t txSize = wallet.getTxSize(p);
uint64_t minFee = CryptoNote::parameters::MINIMUM_FEE;
for (int numTxMultiplier = 2; ; numTxMultiplier++)
{
p = restoreInitialTx;
int numTransactions
= int(numTxMultiplier *
(std::ceil(double(txSize) / double(maxSize))));
uint64_t feePerTx = std::max (p.fee / numTransactions, minFee);
uint64_t totalFee = feePerTx * numTransactions;
uint64_t totalCost = p.destinations[0].amount + totalFee;
if (totalCost > wallet.getActualBalance())
{
p.destinations[0].amount = wallet.getActualBalance() - totalFee;
}
uint64_t amountPerTx = p.destinations[0].amount / numTransactions;
uint64_t change = p.destinations[0].amount % numTransactions;
std::vector<CryptoNote::TransactionParameters> transfers;
for (int i = 0; i < numTransactions; i++)
{
CryptoNote::TransactionParameters tmp = p;
tmp.destinations[0].amount = amountPerTx;
tmp.fee = feePerTx;
transfers.push_back(tmp);
}
transfers[0].destinations[0].amount += change;
for (auto tx : transfers)
{
if (wallet.txIsTooLarge(tx))
{
std::cout << "Split up transactions are still too large! "
<< "Splitting up into smaller chunks." << std::endl;
continue;
}
}
sendMultipleTransactions(wallet, transfers);
return;
}
}
void txProof(CryptoNote::WalletGreen &wallet)
{
std::string txHashStr;
Crypto::Hash txid;
while (true)
{
std::cout << InformationMsg("Enter transaction hash: ");
std::getline(std::cin, txHashStr);
boost::algorithm::trim(txHashStr);
if (!parse_hash256(txHashStr, txid)) {
std::cout << WarningMsg("Failed to parse txid") << std::endl;
return;
}
else {
break;
}
if (std::cin.fail() || std::cin.eof()) {
std::cin.clear();
break;
}
}
Crypto::SecretKey txSecretKey = wallet.getTransactionSecretKey(txid);
if (txSecretKey == CryptoNote::NULL_SECRET_KEY) {
std::cout << InformationMsg("Transaction ")
<< InformationMsg(txHashStr)
<< InformationMsg(" secret key is not available.")
<< std::endl
<< InformationMsg("If you have it elsewhere, ")
<< InformationMsg("enter it here to continue: ")
<< std::endl;
Crypto::Hash tx_key_hash;
while (true)
{
std::string keyStr;
std::getline(std::cin, keyStr);
boost::algorithm::trim(keyStr);
size_t size;
if (!Common::fromHex(keyStr, &tx_key_hash, sizeof(tx_key_hash), size)
|| size != sizeof(tx_key_hash))
{
std::cout << WarningMsg("Failed to parse tx secret key ")
<< WarningMsg(keyStr) << std::endl;
return;
}
else {
txSecretKey = *(struct Crypto::SecretKey *) &tx_key_hash;
break;
}
if (std::cin.fail() || std::cin.eof()) {
std::cin.clear();
break;
}
}
}
CryptoNote::AccountPublicAddress destAddress;
while (true)
{
std::cout << InformationMsg("Enter destination address: ");
std::string addrStr;
uint64_t prefix;
std::getline(std::cin, addrStr);
boost::algorithm::trim(addrStr);
if (!CryptoNote::parseAccountAddressString(prefix, destAddress, addrStr))
{
std::cout << WarningMsg("Failed to parse address") << std::endl;
}
else
{
break;
}
if (std::cin.fail() || std::cin.eof()) {
std::cin.clear();
break;
}
}
try {
std::string sig;
if (wallet.getTransactionProof(txid, destAddress, txSecretKey, sig)) {
std::cout << SuccessMsg("Transaction proof: ")
<< std::endl
<< SuccessMsg(sig)
<< std::endl;
}
else {
std::cout << WarningMsg("Failed to get transaction proof") << std::endl;
}
}
catch (std::system_error& x) {
std::cout << WarningMsg("Error while getting transaction proof: ")
<< WarningMsg(x.what())
<< std::endl;
}
catch (std::exception& x) {
std::cout << WarningMsg("Error while getting transaction proof: ")
<< WarningMsg(x.what())
<< std::endl;
}
}
void save(CryptoNote::WalletGreen &wallet)
{
std::cout << InformationMsg("Saving.") << std::endl;
wallet.save();
std::cout << InformationMsg("Saved.") << std::endl;
}
void sendMultipleTransactions(CryptoNote::WalletGreen &wallet,
std::vector<CryptoNote::TransactionParameters>
transfers)
{
size_t numTxs = transfers.size();
size_t currentTx = 1;
std::cout << "Your transaction has been split up into " << numTxs
<< " separate transactions of "
<< formatAmount(transfers[0].destinations[0].amount)
<< ". It may take some time to send all the transactions, "
<< "please be patient." << std::endl << std::endl;
for (auto tx : transfers)
{
while (true)
{
std::cout << "Attempting to send transaction "
<< InformationMsg(std::to_string(currentTx))
<< " of " << InformationMsg(std::to_string(numTxs))
<< std::endl;
wallet.updateInternalCache();
uint64_t neededBalance = tx.destinations[0].amount + tx.fee;
if (neededBalance < wallet.getActualBalance())
{
size_t id = wallet.transfer(tx);
CryptoNote::WalletTransaction sentTx
= wallet.getTransaction(id);
std::cout << SuccessMsg("Transaction has been sent!")
<< std::endl
<< SuccessMsg("Hash: "
+ Common::podToHex(sentTx.hash))
<< std::endl << std::endl;
break;
}
std::cout << "Not enough balance available to send transaction, "
<< "this is because some of your balance is used when "
<< "sending another transaction to help hide the size "
<< "of your transaction, and is locked for a short "
<< "time. It will return shortly." << std::endl
<< "Needed balance: " << formatAmount(neededBalance)
<< std::endl << "Available balance: "
<< formatAmount(wallet.getActualBalance())
<< std::endl << "Locked balance: "
<< formatAmount(wallet.getPendingBalance())
<< std::endl << "Will try again in 5 seconds..."
<< std::endl << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(5));
}
currentTx++;
}
std::cout << SuccessMsg("All transactions sent!") << std::endl;
}
void blockchainHeight(CryptoNote::INode &node, CryptoNote::WalletGreen &wallet)
{
const uint32_t localHeight = node.getLastLocalBlockHeight();
const uint32_t remoteHeight = node.getLastKnownBlockHeight();
const uint32_t walletHeight = wallet.getBlockCount() - 1;
/* This is the height that the wallet has been scanned to. The blockchain
can be fully updated, but we have to walk the chain to find our
transactions, and this number indicates that progress. */
std::cout << "Wallet blockchain height: ";
/* Small buffer because wallet height doesn't update instantly like node
height does */
if (walletHeight + 1000 > remoteHeight)
{
std::cout << SuccessMsg(std::to_string(walletHeight));
}
else
{
std::cout << WarningMsg(std::to_string(walletHeight));
}
std::cout << std::endl << "Local blockchain height: ";
if (localHeight == remoteHeight)
{
std::cout << SuccessMsg(std::to_string(localHeight));
}
else
{
std::cout << WarningMsg(std::to_string(localHeight));
}
std::cout << std::endl << "Network blockchain height: "
<< SuccessMsg(std::to_string(remoteHeight)) << std::endl;
if (localHeight == 0 && remoteHeight == 0)
{
std::cout << WarningMsg("Uh oh, it looks like you don't have ")
<< WarningMsg(WalletConfig::daemonName)
<< WarningMsg(" open!")
<< std::endl;
}
else if (walletHeight + 1000 < remoteHeight && localHeight == remoteHeight)
{
std::cout << InformationMsg("You are synced with the network, but the "
"blockchain is still being scanned for "
"your transactions.")
<< std::endl
<< "Balances might be incorrect whilst this is ongoing."
<< std::endl;
}
else if (localHeight == remoteHeight)
{
std::cout << SuccessMsg("Yay! You are synced!") << std::endl;
}
else
{
std::cout << WarningMsg("Be patient, you are still syncing with the "
"network!") << std::endl;
}
}