Bc explorer703

src/CryptoNoteCore/CryptoNoteFormatUtils.cpp

@@ -224,6 +224,23 @@ bool constructTransaction(
   return true;
 }
 
+bool get_inputs_money_amount(const Transaction& tx, uint64_t& money) {
+  money = 0;
+
+  for (const auto& in : tx.inputs) {
+    uint64_t amount = 0;
+
+    if (in.type() == typeid(KeyInput)) {
+      amount = boost::get<KeyInput>(in).amount;
+    } else if (in.type() == typeid(MultisignatureInput)) {
+      amount = boost::get<MultisignatureInput>(in).amount;
+    }
+
+    money += amount;
+  }
+  return true;
+}
+
 uint32_t get_block_height(const Block& b) {
   if (b.baseTransaction.inputs.size() != 1) {
     return 0;

src/CryptoNoteCore/CryptoNoteFormatUtils.h

@@ -75,6 +75,7 @@ bool get_aux_block_header_hash(const Block& b, Crypto::Hash& res);
 bool get_block_hash(const Block& b, Crypto::Hash& res);
 Crypto::Hash get_block_hash(const Block& b);
 bool get_block_longhash(Crypto::cn_context &context, const Block& b, Crypto::Hash& res);
+bool get_inputs_money_amount(const Transaction& tx, uint64_t& money);
 uint64_t get_outs_money_amount(const Transaction& tx);
 bool check_inputs_types_supported(const TransactionPrefix& tx);
 bool check_outs_valid(const TransactionPrefix& tx, std::string* error = 0);

src/CryptoNoteCore/CryptoNoteTools.cpp

@@ -31,6 +31,19 @@ Crypto::Hash getBinaryArrayHash(const BinaryArray& binaryArray) {
   return hash;
 }
 
+uint64_t getInputAmount(const Transaction& transaction) {
+  uint64_t amount = 0;
+  for (auto& input : transaction.inputs) {
+    if (input.type() == typeid(KeyInput)) {
+      amount += boost::get<KeyInput>(input).amount;
+    } else if (input.type() == typeid(MultisignatureInput)) {
+      amount += boost::get<MultisignatureInput>(input).amount;
+    }
+  }
+
+  return amount;
+}
+
 std::vector<uint64_t> getInputsAmounts(const Transaction& transaction) {
   std::vector<uint64_t> inputsAmounts;
   inputsAmounts.reserve(transaction.inputs.size());

src/CryptoNoteCore/CryptoNoteTools.h

@@ -32,7 +32,7 @@ bool toBinaryArray(const T& object, BinaryArray& binaryArray) {
 }
 
 template<>
-bool toBinaryArray(const BinaryArray& object, BinaryArray& binaryArray); 
+bool toBinaryArray(const BinaryArray& object, BinaryArray& binaryArray);
 
 template<class T>
 BinaryArray toBinaryArray(const T& object) {
@@ -107,6 +107,7 @@ Crypto::Hash getObjectHash(const T& object) {
   return hash;
 }
 
+uint64_t getInputAmount(const Transaction& transaction);
 std::vector<uint64_t> getInputsAmounts(const Transaction& transaction);
 uint64_t getOutputAmount(const Transaction& transaction);
 void decomposeAmount(uint64_t amount, uint64_t dustThreshold, std::vector<uint64_t>& decomposedAmounts);

src/Rpc/CoreRpcServerCommandsDefinitions.h

@@ -47,7 +47,7 @@ struct COMMAND_RPC_GET_BLOCKS_FAST {
 
   struct request {
     std::vector<Crypto::Hash> block_ids; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */
-    
+
     void serialize(ISerializer &s) {
       serializeAsBinary(block_ids, "block_ids", s);
     }
@@ -85,7 +85,7 @@ struct COMMAND_RPC_GET_TRANSACTIONS {
     void serialize(ISerializer &s) {
       KV_MEMBER(txs_as_hex)
       KV_MEMBER(missed_tx)
-      KV_MEMBER(status)    
+      KV_MEMBER(status)
     }
   };
 };
@@ -144,7 +144,7 @@ struct COMMAND_RPC_GET_POOL_CHANGES_LITE {
 
 //-----------------------------------------------
 struct COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES {
-  
+
   struct request {
     Crypto::Hash txid;
 
@@ -403,6 +403,169 @@ struct BLOCK_HEADER_RESPONSE {
 };
 
 
+struct f_transaction_short_response {
+  std::string hash;
+  uint64_t fee;
+  uint64_t amount_out;
+  uint64_t size;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(hash)
+    KV_MEMBER(fee)
+    KV_MEMBER(amount_out)
+    KV_MEMBER(size)
+  }
+};
+
+struct f_transaction_details_response {
+  std::string hash;
+  size_t size;
+  std::string paymentId;
+  uint64_t mixin;
+  uint64_t fee;
+  uint64_t amount_out;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(hash)
+    KV_MEMBER(size)
+    KV_MEMBER(paymentId)
+    KV_MEMBER(mixin)
+    KV_MEMBER(fee)
+    KV_MEMBER(amount_out)
+  }
+};
+
+struct f_block_short_response {
+  uint64_t timestamp;
+  uint32_t height;
+  difficulty_type difficulty;
+  std::string hash;
+  uint64_t tx_count;
+  uint64_t cumul_size;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(timestamp)
+    KV_MEMBER(height)
+    KV_MEMBER(difficulty)
+    KV_MEMBER(hash)
+    KV_MEMBER(cumul_size)
+    KV_MEMBER(tx_count)
+  }
+};
+
+struct f_block_details_response {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint64_t timestamp;
+  std::string prev_hash;
+  uint32_t nonce;
+  bool orphan_status;
+  uint64_t height;
+  uint64_t depth;
+  std::string hash;
+  difficulty_type difficulty;
+  uint64_t reward;
+  uint64_t blockSize;
+  size_t sizeMedian;
+  uint64_t effectiveSizeMedian;
+  uint64_t transactionsCumulativeSize;
+  std::string alreadyGeneratedCoins;
+  uint64_t alreadyGeneratedTransactions;
+  uint64_t baseReward;
+  double penalty;
+  uint64_t totalFeeAmount;
+  std::vector<f_transaction_short_response> transactions;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(major_version)
+    KV_MEMBER(minor_version)
+    KV_MEMBER(timestamp)
+    KV_MEMBER(prev_hash)
+    KV_MEMBER(nonce)
+    KV_MEMBER(orphan_status)
+    KV_MEMBER(height)
+    KV_MEMBER(depth)
+    KV_MEMBER(hash)
+    KV_MEMBER(difficulty)
+    KV_MEMBER(reward)
+    KV_MEMBER(blockSize)
+    KV_MEMBER(sizeMedian)
+    KV_MEMBER(effectiveSizeMedian)
+    KV_MEMBER(transactionsCumulativeSize)
+    KV_MEMBER(alreadyGeneratedCoins)
+    KV_MEMBER(alreadyGeneratedTransactions)
+    KV_MEMBER(baseReward)
+    KV_MEMBER(penalty)
+    KV_MEMBER(transactions)
+    KV_MEMBER(totalFeeAmount)
+  }
+};
+struct currency_base_coin {
+  std::string name;
+  std::string git;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(name)
+    KV_MEMBER(git)
+  }
+};
+
+struct currency_core {
+  std::vector<std::string> SEED_NODES;
+  uint64_t EMISSION_SPEED_FACTOR;
+  uint64_t DIFFICULTY_TARGET;
+  uint64_t CRYPTONOTE_DISPLAY_DECIMAL_POINT;
+  std::string MONEY_SUPPLY;
+//uint64_t GENESIS_BLOCK_REWARD;
+  uint64_t DEFAULT_DUST_THRESHOLD;
+  uint64_t MINIMUM_FEE;
+  uint64_t CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW;
+  uint64_t CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE;
+//  uint64_t CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
+  uint64_t CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX;
+  uint64_t P2P_DEFAULT_PORT;
+  uint64_t RPC_DEFAULT_PORT;
+  uint64_t MAX_BLOCK_SIZE_INITIAL;
+  uint64_t EXPECTED_NUMBER_OF_BLOCKS_PER_DAY;
+  uint64_t UPGRADE_HEIGHT;
+  uint64_t DIFFICULTY_CUT;
+  uint64_t DIFFICULTY_LAG;
+  //std::string BYTECOIN_NETWORK;
+  std::string CRYPTONOTE_NAME;
+  std::string GENESIS_COINBASE_TX_HEX;
+  std::vector<std::string> CHECKPOINTS;
+
+  void serialize(ISerializer &s) {
+    KV_MEMBER(SEED_NODES)
+    KV_MEMBER(EMISSION_SPEED_FACTOR)
+    KV_MEMBER(DIFFICULTY_TARGET)
+    KV_MEMBER(CRYPTONOTE_DISPLAY_DECIMAL_POINT)
+    KV_MEMBER(MONEY_SUPPLY)
+//    KV_MEMBER(GENESIS_BLOCK_REWARD)
+    KV_MEMBER(DEFAULT_DUST_THRESHOLD)
+    KV_MEMBER(MINIMUM_FEE)
+    KV_MEMBER(CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW)
+    KV_MEMBER(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE)
+//    KV_MEMBER(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1)
+    KV_MEMBER(CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX)
+    KV_MEMBER(P2P_DEFAULT_PORT)
+    KV_MEMBER(RPC_DEFAULT_PORT)
+    KV_MEMBER(MAX_BLOCK_SIZE_INITIAL)
+    KV_MEMBER(EXPECTED_NUMBER_OF_BLOCKS_PER_DAY)
+    KV_MEMBER(UPGRADE_HEIGHT)
+    KV_MEMBER(DIFFICULTY_CUT)
+    KV_MEMBER(DIFFICULTY_LAG)
+//    KV_MEMBER(BYTECOIN_NETWORK)
+    KV_MEMBER(CRYPTONOTE_NAME)
+    KV_MEMBER(GENESIS_COINBASE_TX_HEX)
+    KV_MEMBER(CHECKPOINTS)
+  }
+};
+
+
+
+
+
 struct COMMAND_RPC_GET_LAST_BLOCK_HEADER {
   typedef EMPTY_STRUCT request;
   typedef BLOCK_HEADER_RESPONSE response;
@@ -432,6 +595,105 @@ struct COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT {
   typedef BLOCK_HEADER_RESPONSE response;
 };
 
+
+
+struct F_COMMAND_RPC_GET_BLOCKS_LIST {
+  struct request {
+    uint64_t height;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(height)
+    }
+  };
+
+  struct response {
+    std::vector<f_block_short_response> blocks; //transactions blobs as hex
+    std::string status;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(blocks)
+      KV_MEMBER(status)
+    }
+  };
+};
+
+struct F_COMMAND_RPC_GET_BLOCK_DETAILS {
+  struct request {
+    std::string hash;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(hash)
+    }
+  };
+
+  struct response {
+    f_block_details_response block;
+    std::string status;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(block)
+      KV_MEMBER(status)
+    }
+  };
+};
+
+struct F_COMMAND_RPC_GET_TRANSACTION_DETAILS {
+  struct request {
+    std::string hash;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(hash)
+    }
+  };
+
+  struct response {
+    Transaction tx;
+    f_transaction_details_response txDetails;
+    f_block_short_response block;
+    std::string status;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(tx)
+      KV_MEMBER(txDetails)
+      KV_MEMBER(block)
+      KV_MEMBER(status)
+    }
+  };
+};
+
+struct F_COMMAND_RPC_GET_POOL {
+    typedef EMPTY_STRUCT request;
+
+    struct response {
+        std::vector<f_transaction_short_response> transactions; //transactions blobs as hex
+        std::string status;
+
+        void serialize(ISerializer &s) {
+            KV_MEMBER(transactions)
+            KV_MEMBER(status)
+        }
+    };
+};
+
+struct F_COMMAND_RPC_GET_BLOCKCHAIN_SETTINGS {
+  typedef EMPTY_STRUCT request;
+  struct response {
+    currency_base_coin base_coin;
+    currency_core core;
+    std::vector<std::string> extensions;
+    std::string status;
+
+    void serialize(ISerializer &s) {
+      KV_MEMBER(base_coin)
+      KV_MEMBER(core)
+      KV_MEMBER(extensions)
+      KV_MEMBER(status)
+    }
+  };
+};
+
+
+
 struct COMMAND_RPC_QUERY_BLOCKS {
   struct request {
     std::vector<Crypto::Hash> block_ids; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */