miner: Chain and TxPool interfaces stubs

Author: Anatol Sevostyan

chain/chain.cpp

@@ -2,10 +2,18 @@
 
 namespace beam
 {
+    Chain::Chain()
+    {
+        m_blockChain.emplace_back(std::make_unique<Block>());
+    }
+
     const Block& Chain::getHeadBlock() const
     {
-        return m_blockChain.back();
+        return *m_blockChain.back();
     }
 
-    
+    void Chain::processBlock(BlockUniquePtr&& block)
+    {
+        m_blockChain.emplace_back(std::move(block));
+    }
 };

chain/chain.h

@@ -7,9 +7,11 @@ namespace beam
     class Chain
     {
     public:
+        Chain();
         const Block& getHeadBlock() const;
+        void processBlock(BlockUniquePtr&& block);
     private:
         // TODO: replace
-        std::vector<Block> m_blockChain;
+        std::vector<BlockUniquePtr> m_blockChain;
     };
 }

core/block.h

@@ -9,53 +9,81 @@ namespace beam
 class BlockHeader
 {
 public:
-	// Version of the block
-	uint16_t version;
+    // Version of the block
+    uint16_t version;
 
-	// Height of this block since the genesis block (height 0)
-	uint64_t height;
+    // Height of this block since the genesis block (height 0)
+    uint64_t height;
 
-	// Timestamp at which the block was built.
-	Timestamp timestamp;
+    // Timestamp at which the block was built.
+    Timestamp timestamp;
 
-	// Hash of the block previous to this in the chain.
-	Hash previous;
+    // Hash of the block previous to this in the chain.
+    Hash previous;
 
-	// Merklish root of all the commitments in the TxHashSet
-	// Hash output_root;
+    // Merklish root of all the commitments in the TxHashSet
+    // Hash output_root;
 
-	// Merklish root of all range proofs in the TxHashSet
-	// Hash range_proof_root;
+    // Merklish root of all range proofs in the TxHashSet
+    // Hash range_proof_root;
 
-	// Merklish root of all transaction kernels in the TxHashSet
-	// Hash kernel_root;
+    // Merklish root of all transaction kernels in the TxHashSet
+    // Hash kernel_root;
 
-	// Total accumulated difficulty since genesis block
-	Difficulty total_difficulty;
+    // Total accumulated difficulty since genesis block
+    Difficulty total_difficulty;
 
-	// Total accumulated sum of kernel offsets since genesis block.
-	// We can derive the kernel offset sum for *this* block from
-	// the total kernel offset of the previous block header.
-	// total_kernel_offset: BlindingFactor,
+    // Total accumulated sum of kernel offsets since genesis block.
+    // We can derive the kernel offset sum for *this* block from
+    // the total kernel offset of the previous block header.
+    // total_kernel_offset: BlindingFactor,
 
-	// Proof of work data.
-	Proof pow;
+    // Proof of work data.
+    Proof pow;
+
+    BlockHeader(){}
+
+    BlockHeader(const BlockHeader& other) = delete;
+    BlockHeader(BlockHeader&& other) = delete;
+    BlockHeader& operator=(const BlockHeader&) = delete;
+    BlockHeader& operator=(BlockHeader&&) = delete;
+
+    template<typename Buffer>
+    void serializeTo(Buffer& b)
+    {
+
+    }
 };
 
 class Block
 {
 public:
-	// The header with metadata and commitments to the rest of the data
+    // The header with metadata and commitments to the rest of the data
     BlockHeader header;
 
-	// List of transaction inputs
+    // List of transaction inputs
     Inputs inputs;
 
-	// List of transaction outputs
+    // List of transaction outputs
     Outputs outputs;
 
-	// List of kernels with associated proofs (note these are offset from tx_kernels)
+    // List of kernels with associated proofs (note these are offset from tx_kernels)
     Kernels kernels;
+
+    Block() {}
+
+    Block(const Block& other) = delete;
+    Block(Block&& other) = delete;
+    Block& operator=(const Block&) = delete;
+    Block& operator=(Block&&) = delete;
+
+    template<typename Buffer>
+    void serializeTo(Buffer& b)
+    {
+
+    }
 };
 
+using BlockUniquePtr = std::unique_ptr<Block>;
+
 }

core/common.h

@@ -2,11 +2,12 @@
 
 #include <vector>
 #include <array>
+#include <utility>
 #include <cstdint>
+#include <memory>
 
 namespace beam
 {
-
 // 256 bit hash
 using Hash = std::array<uint8_t, 256/8>;
 
@@ -18,6 +19,8 @@ using Difficulty = uint64_t;
 
 using Solution = std::vector<uint8_t>;
 
+using ByteBuffer = std::vector<uint8_t>;
+
 struct Proof
 {
     // Nonce increment used to mine this block.
@@ -26,7 +29,13 @@ struct Proof
     Solution solution;
 
     Proof() = default;
-    Proof(Proof &&other) : nonce(std::move(nonce)), solution(std::move(solution)) {}
+    Proof(Proof&& other) : nonce(std::move(nonce)), solution(std::move(solution)) {}
+    const Proof& operator=(Proof&& other) 
+    {
+        nonce = std::move(other.nonce);
+        solution = std::move(other.solution);
+        return *this;
+    }
 };
 
 }

miner/CMakeLists.txt

@@ -6,7 +6,7 @@ set(MINER_SRC
 )
 
 add_library(miner STATIC ${MINER_SRC})
-add_dependencies(miner pow)
-target_link_libraries(miner pow)
+add_dependencies(miner pow chain pool)
+target_link_libraries(miner pow chain pool)
 
 add_subdirectory(unittests)

miner/miner.cpp

@@ -1,11 +1,15 @@
 #include "miner.h"
 
 #include "pow/equihash.h"
+#include "chain/chain.h"
+#include "pool/txpool.h"
 
 namespace beam
 {
 
-Miner::Miner()
+Miner::Miner(Chain& blockChain, TxPool& txPool)
+    : m_blockChain(blockChain)
+    , m_txPool(txPool)
 {
 }
 
@@ -14,17 +18,26 @@ void Miner::start()
 
 }
 
-void Miner::mine()
+void Miner::mineBlock()
 {
-    equi::ByteBuffer input{1, 2, 3, 4, 56};
-    beam::uint256_t nonce{1, 2, 4};
+    const Block& headBlock = m_blockChain.getHeadBlock();
 
-    equi::is_valid_proof(input, equi::get_solution(input, nonce));
+    BlockUniquePtr newBlock = createBlock(headBlock.header);
+    
+    ByteBuffer input { 1, 2, 3, 4, 56 };
+    newBlock->header.serializeTo(input);
+    uint256_t nonce{1, 2, 4};
+
+    Proof solution = equi::getSolution(input, nonce);
+    if (equi::isValidProof(input, solution)) {
+        newBlock->header.pow = std::move(solution);
+        m_blockChain.processBlock(std::move(newBlock));
+    }
 }
 
-Block Miner::createBlock(const BlockHeader& prevHeader)
+BlockUniquePtr Miner::createBlock(const BlockHeader& prevHeader)
 {
-    Block block;
+    BlockUniquePtr block = std::make_unique<Block>();
     // TODO: get transactions
     // TODO: calc merkle root hash
 

miner/miner.h

@@ -6,16 +6,20 @@
 namespace beam
 {
 
+class Chain;
+class TxPool;
 class Miner
 {
 public:
-    Miner();
+    Miner(Chain& blockChain, TxPool& txPool);
 
     void start();
-    void mine();
-
-    Block createBlock(const BlockHeader& prevHeader);
-
+    void mineBlock();
+private:
+    BlockUniquePtr createBlock(const BlockHeader& prevHeader);
+private:
+    Chain& m_blockChain;
+    TxPool& m_txPool;
 };
 
 }

miner/pow/equihash.cpp

@@ -11,14 +11,14 @@ namespace equi
 const int N = 200;
 const int K = 9;
 
-beam::Proof get_solution(const ByteBuffer &input, const beam::uint256_t &initial_nonce, const Cancel cancel)
+beam::Proof getSolution(const beam::ByteBuffer &input, const beam::uint256_t &initial_nonce, const Cancel cancel)
 {
 
     beam::Proof proof;
     proof.nonce = initial_nonce;
 
-    std::function<bool(ByteBuffer)> valid_block =
-        [&proof](ByteBuffer soln) {
+    std::function<bool(beam::ByteBuffer)> valid_block =
+        [&proof](beam::ByteBuffer soln) {
             proof.solution = soln;
             return true;
         };
@@ -53,7 +53,7 @@ beam::Proof get_solution(const ByteBuffer &input, const beam::uint256_t &initial
     return proof;
 }
 
-bool is_valid_proof(const ByteBuffer &input, const beam::Proof &proof)
+bool isValidProof(const beam::ByteBuffer &input, const beam::Proof &proof)
 {
     blake2b_state state;
     EhInitialiseState(N, K, state);

miner/pow/equihash.h

@@ -9,10 +9,9 @@
 namespace equi
 {
 
-using ByteBuffer = std::vector<uint8_t>;
 using Cancel = std::function<bool()>;
 
-beam::Proof get_solution(const ByteBuffer &input, const beam::uint256_t &initial_nonce, const Cancel = []{ return false; });
-bool is_valid_proof(const ByteBuffer &input, const beam::Proof &proof);
+beam::Proof getSolution(const beam::ByteBuffer &input, const beam::uint256_t &initial_nonce, const Cancel = []{ return false; });
+bool isValidProof(const beam::ByteBuffer &input, const beam::Proof &proof);
 
 }

miner/unittests/equihash_test.cpp

@@ -3,13 +3,13 @@
 
 int main()
 {
-    equi::ByteBuffer input{1, 2, 3, 4, 56};
+    beam::ByteBuffer input{1, 2, 3, 4, 56};
 
     beam::uint256_t nonce{1, 2, 4};
-    auto proof = equi::get_solution(input, nonce);
+    auto proof = equi::getSolution(input, nonce);
     std::cout << proof.solution.size() << std::endl;
 
-    if (equi::is_valid_proof(input, proof))
+    if (equi::isValidProof(input, proof))
     {
         std::cout << "Solution is correct\n";
         return 0;

miner/unittests/miner_test.cpp

@@ -1,14 +1,16 @@
 #include "miner/miner.h"
+#include "chain/chain.h"
+#include "pool/txpool.h"
 #include <iostream>
 
 int main()
 {
-    beam::Miner miner;
-    beam::BlockHeader header;
+    using namespace beam;
+    Chain chain;
+    TxPool txPool;
+    Miner miner{ chain, txPool };
 
-
-    
-    beam::Block block = miner.createBlock(header);
+    miner.mineBlock();
 
     return 0;
 }