Simplewallet console message sending

Author: xdn-project

src/Common/ConsoleHandler.cpp

@@ -192,9 +192,40 @@ bool ConsoleHandler::runCommand(const std::vector<std::string>& cmdAndArgs) {
 }
 
 void ConsoleHandler::handleCommand(const std::string& cmd) {
-  std::vector<std::string> args;
-  boost::split(args, cmd, boost::is_any_of(" "), boost::token_compress_on);
-  runCommand(args);
+  bool parseString = false;
+  std::string arg;
+  std::vector<std::string> argList;
+
+  for (auto ch : cmd) {
+    switch (ch) {
+    case ' ':
+      if (parseString) {
+        arg += ch;
+      } else if (!arg.empty()) {
+        argList.emplace_back(std::move(arg));
+        arg.clear();
+      }
+      break;
+
+    case '"':
+      if (!arg.empty()) {
+        argList.emplace_back(std::move(arg));
+        arg.clear();
+      }
+
+      parseString = !parseString;
+      break;
+
+    default:
+      arg += ch;
+    }
+  }
+
+  if (!arg.empty()) {
+    argList.emplace_back(std::move(arg));
+  }
+
+  runCommand(argList);
 }
 
 void ConsoleHandler::handlerThread() {

src/CryptoNoteCore/TransactionPool.cpp

@@ -123,19 +123,6 @@ namespace CryptoNote {
       ttl.ttl = 0;
     }
 
-    uint64_t now = static_cast<uint64_t>(time(nullptr));
-    if (ttl.ttl != 0) {
-      if (ttl.ttl <= now) {
-        logger(INFO, BRIGHT_WHITE) << "Transaction TTL has already expired: tx = " << id << ", ttl = " << ttl.ttl;
-        tvc.m_verifivation_failed = true;
-        return false;
-      } else if (ttl.ttl - now > m_currency.mempoolTxLiveTime() + m_currency.blockFutureTimeLimit()) {
-        logger(INFO, BRIGHT_WHITE) << "Transaction TTL is out of range: tx = " << id << ", ttl = " << ttl.ttl;
-        tvc.m_verifivation_failed = true;
-        return false;
-      }
-    }
-
     const uint64_t fee = inputs_amount - outputs_amount;
     bool isFusionTransaction = fee == 0 && m_currency.isFusionTransaction(tx, blobSize);
     if (!keptByBlock && !isFusionTransaction && ttl.ttl == 0 && fee < m_currency.minimumFee()) {
@@ -146,6 +133,25 @@ namespace CryptoNote {
       return false;
     }
 
+    if (ttl.ttl != 0 && !keptByBlock) {
+      uint64_t now = static_cast<uint64_t>(time(nullptr));
+      if (ttl.ttl <= now) {
+        logger(WARNING, BRIGHT_YELLOW) << "Transaction TTL has already expired: tx = " << id << ", ttl = " << ttl.ttl;
+        tvc.m_verifivation_failed = true;
+        return false;
+      } else if (ttl.ttl - now > m_currency.mempoolTxLiveTime() + m_currency.blockFutureTimeLimit()) {
+        logger(WARNING, BRIGHT_YELLOW) << "Transaction TTL is out of range: tx = " << id << ", ttl = " << ttl.ttl;
+        tvc.m_verifivation_failed = true;
+        return false;
+      }
+
+      if (fee != 0) {
+        logger(WARNING, BRIGHT_YELLOW) << "Transaction with TTL has non-zero fee: tx = " << id << ", fee = " << m_currency.formatAmount(fee);
+        tvc.m_verifivation_failed = true;
+        return false;
+      }
+    }
+
     //check key images for transaction if it is not kept by block
     if (!keptByBlock) {
       std::lock_guard<std::recursive_mutex> lock(m_transactions_lock);

src/SimpleWallet/SimpleWallet.cpp

@@ -137,9 +137,11 @@ struct TransferCommand {
   std::vector<uint8_t> extra;
   uint64_t fee;
   std::map<std::string, std::vector<WalletLegacyTransfer>> aliases;
+  std::vector<std::string> messages;
+  uint64_t ttl;
 
   TransferCommand(const CryptoNote::Currency& currency) :
-    m_currency(currency), fake_outs_count(0), fee(currency.minimumFee()) {
+    m_currency(currency), fake_outs_count(0), fee(currency.minimumFee()), ttl(0) {
   }
 
   bool parseArguments(LoggerRef& logger, const std::vector<std::string> &args) {
@@ -155,6 +157,8 @@ struct TransferCommand {
         return false;
       }
 
+      bool feeFound = false;
+      bool ttlFound = false;
       while (!ar.eof()) {
 
         auto arg = ar.next();
@@ -169,6 +173,13 @@ struct TransferCommand {
               return false;
             }
           } else if (arg == "-f") {
+            feeFound = true;
+
+            if (ttlFound) {
+              logger(ERROR, BRIGHT_RED) << "Transaction with TTL can not have fee";
+              return false;
+            }
+
             bool ok = m_currency.parseAmount(value, fee);
             if (!ok) {
               logger(ERROR, BRIGHT_RED) << "Fee value is invalid: " << value;
@@ -179,6 +190,23 @@ struct TransferCommand {
               logger(ERROR, BRIGHT_RED) << "Fee value is less than minimum: " << m_currency.minimumFee();
               return false;
             }
+          } else if (arg == "-m") {
+            messages.emplace_back(value);
+          } else if (arg == "-ttl") {
+            ttlFound = true;
+
+            if (feeFound) {
+              logger(ERROR, BRIGHT_RED) << "Transaction with fee can not have TTL";
+              return false;
+            } else {
+              fee = 0;
+            }
+
+            if (!Common::fromString(value, ttl) || ttl < 1 || ttl * 60 > m_currency.mempoolTxLiveTime()) {
+              logger(ERROR, BRIGHT_RED) << "TTL has invalid format: \"" << value << "\", " <<
+                "enter time from 1 to " << (m_currency.mempoolTxLiveTime() / 60) << " minutes";
+              return false;
+            }
           }
         } else {
           WalletLegacyTransfer destination;
@@ -1113,14 +1141,26 @@ bool simple_wallet::transfer(const std::vector<std::string> &args) {
       }
     }
 
+    std::vector<TransactionMessage> messages;
+    for (auto dst : cmd.dsts) {
+      for (auto msg : cmd.messages) {
+        messages.emplace_back(TransactionMessage{ msg, dst.address });
+      }
+    }
+
+    uint64_t ttl = 0;
+    if (cmd.ttl != 0) {
+      ttl = static_cast<uint64_t>(time(nullptr)) + cmd.ttl;
+    }
+
     CryptoNote::WalletHelper::SendCompleteResultObserver sent;
 
     std::string extraString;
     std::copy(cmd.extra.begin(), cmd.extra.end(), std::back_inserter(extraString));
 
     WalletHelper::IWalletRemoveObserverGuard removeGuard(*m_wallet, sent);
 
-    CryptoNote::TransactionId tx = m_wallet->sendTransaction(cmd.dsts, cmd.fee, extraString, cmd.fake_outs_count, 0);
+    CryptoNote::TransactionId tx = m_wallet->sendTransaction(cmd.dsts, cmd.fee, extraString, cmd.fake_outs_count, 0, messages, ttl);
     if (tx == WALLET_LEGACY_INVALID_TRANSACTION_ID) {
       fail_msg_writer() << "Can't send money";
       return true;

src/version.h.in

@@ -1,4 +1,4 @@
 #define BUILD_COMMIT_ID "@VERSION@"
-#define PROJECT_VERSION "3.1.0-beta"
-#define PROJECT_VERSION_BUILD_NO "1757"
+#define PROJECT_VERSION "3.1.1-beta"
+#define PROJECT_VERSION_BUILD_NO "1761"
 #define PROJECT_VERSION_LONG PROJECT_VERSION "." PROJECT_VERSION_BUILD_NO "(" BUILD_COMMIT_ID ")"