initial commit

validator/validator-options.hpp

@@ -0,0 +1,134 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#pragma once
+
+#include "validator/validator.h"
+
+namespace ton {
+
+namespace validator {
+
+struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
+ public:
+  BlockIdExt zero_block_id() const override {
+    return zero_block_id_;
+  }
+  BlockIdExt init_block_id() const override {
+    return init_block_id_;
+  }
+  bool need_monitor(ShardIdFull shard) const override {
+    return check_shard_(shard);
+  }
+  bool allow_blockchain_init() const override {
+    return allow_blockchain_init_;
+  }
+  td::ClocksBase::Duration sync_blocks_before() const override {
+    return sync_blocks_before_;
+  }
+  td::ClocksBase::Duration block_ttl() const override {
+    return block_ttl_;
+  }
+  td::ClocksBase::Duration state_ttl() const override {
+    return state_ttl_;
+  }
+  bool initial_sync_disabled() const override {
+    return initial_sync_disabled_;
+  }
+  bool is_hardfork(BlockIdExt block_id) const override {
+    if (!block_id.is_valid()) {
+      return false;
+    }
+    for (size_t i = 0; i < hardforks_.size(); i++) {
+      if (block_id == hardforks_[i]) {
+        return (i == hardforks_.size() - 1) || block_id.seqno() < hardforks_[i + 1].seqno();
+      }
+    }
+    return false;
+  }
+  td::uint32 get_vertical_height(BlockSeqno seqno) const override {
+    size_t best = 0;
+    for (size_t i = 0; i < hardforks_.size(); i++) {
+      if (seqno >= hardforks_[i].seqno()) {
+        best = i + 1;
+      }
+    }
+    return static_cast<td::uint32>(best);
+  }
+
+  void set_zero_block_id(BlockIdExt block_id) override {
+    zero_block_id_ = block_id;
+  }
+  void set_init_block_id(BlockIdExt block_id) override {
+    init_block_id_ = block_id;
+  }
+  void set_shard_check_function(std::function<bool(ShardIdFull)> check_shard) override {
+    check_shard_ = std::move(check_shard);
+  }
+  void set_allow_blockchain_init(bool value) override {
+    allow_blockchain_init_ = value;
+  }
+  void set_sync_blocks_before(td::ClocksBase::Duration value) override {
+    sync_blocks_before_ = value;
+  }
+  void set_block_ttl(td::ClocksBase::Duration value) override {
+    block_ttl_ = value;
+  }
+  void set_state_ttl(td::ClocksBase::Duration value) override {
+    state_ttl_ = value;
+  }
+  void set_initial_sync_disabled(bool value) override {
+    initial_sync_disabled_ = value;
+  }
+  void set_hardforks(std::vector<BlockIdExt> vec) override {
+    hardforks_ = std::move(vec);
+  }
+
+  ValidatorManagerOptionsImpl *make_copy() const override {
+    return new ValidatorManagerOptionsImpl(*this);
+  }
+
+  ValidatorManagerOptionsImpl(BlockIdExt zero_block_id, BlockIdExt init_block_id,
+                              std::function<bool(ShardIdFull)> check_shard, bool allow_blockchain_init,
+                              td::ClocksBase::Duration sync_blocks_before, td::ClocksBase::Duration block_ttl,
+                              td::ClocksBase::Duration state_ttl, bool initial_sync_disabled)
+      : zero_block_id_(zero_block_id)
+      , init_block_id_(init_block_id)
+      , check_shard_(std::move(check_shard))
+      , allow_blockchain_init_(allow_blockchain_init)
+      , sync_blocks_before_(sync_blocks_before)
+      , block_ttl_(block_ttl)
+      , state_ttl_(state_ttl)
+      , initial_sync_disabled_(initial_sync_disabled) {
+  }
+
+ private:
+  BlockIdExt zero_block_id_;
+  BlockIdExt init_block_id_;
+  std::function<bool(ShardIdFull)> check_shard_;
+  bool allow_blockchain_init_;
+  td::ClocksBase::Duration sync_blocks_before_;
+  td::ClocksBase::Duration block_ttl_;
+  td::ClocksBase::Duration state_ttl_;
+  bool initial_sync_disabled_;
+  std::vector<BlockIdExt> hardforks_;
+};
+
+}  // namespace validator
+
+}  // namespace ton