external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

updated fift

Browse source 
updated fift
updated some smartcontracts
added partial support for hardforks
This commit is contained in:
ton 2019-10-01 14:07:35 +04:00
parent 2845f9a2cc
commit 841d5ebac2
16 changed files with 202 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

4
validator/fabric.h
View file

@ -27,6 +27,8 @@ namespace validator {
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
td::uint32 depth);
td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
std::string db_root);
td::Result<td::Ref<BlockData>> create_block(BlockIdExt block_id, td::BufferSlice data);
td::Result<td::Ref<BlockData>> create_block(ReceivedBlock data);
@ -71,7 +73,7 @@ void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& m
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<BlockCandidate> promise);
void run_liteserver_query(td::BufferSlice data, td::actor::ActorId<ValidatorManager> manager,
td::Promise<td::BufferSlice> promise);
td::actor::ActorId<LiteServerCache> cache, td::Promise<td::BufferSlice> promise);
void run_validate_shard_block_description(td::BufferSlice data, BlockHandle masterchain_block,
td::Ref<MasterchainState> masterchain_state,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,

7
validator/impl/fabric.cpp
View file

@ -43,6 +43,11 @@ td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> man
return td::actor::create_actor<RootDb>("db", manager, db_root_, depth);
}
td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
std::string db_root) {
return td::actor::create_actor<LiteServerCache>("cache");
}
td::Result<td::Ref<BlockData>> create_block(BlockIdExt block_id, td::BufferSlice data) {
auto res = BlockQ::create(block_id, std::move(data));
if (res.is_error()) {
@ -196,7 +201,7 @@ void run_collate_query(ShardIdFull shard, td::uint32 min_ts, const BlockIdExt& m
}
void run_liteserver_query(td::BufferSlice data, td::actor::ActorId<ValidatorManager> manager,
td::Promise<td::BufferSlice> promise) {
td::actor::ActorId<LiteServerCache> cache, td::Promise<td::BufferSlice> promise) {
LiteQuery::run_query(std::move(data), std::move(manager), std::move(promise));
}

16
validator/interfaces/liteserver.h Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "td/actor/actor.h"
namespace ton {
namespace validator {
class LiteServerCache : public td::actor::Actor {
public:
virtual ~LiteServerCache() = default;
};
} // namespace validator
} // namespace ton

3
validator/interfaces/validator-manager.h
View file

@ -26,6 +26,7 @@
#include "shard-block.h"
#include "message-queue.h"
#include "validator/validator.h"
#include "liteserver.h"
namespace ton {
@ -147,7 +148,7 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void allow_block_info_gc(BlockIdExt block_id, td::Promise<bool> promise) = 0;
virtual void check_is_hardfork(BlockIdExt block_id, td::Promise<bool> promise) = 0;
virtual void get_vertical_height(BlockSeqno seqno, td::Promise<td::uint32> promise) = 0;
virtual void get_vertical_seqno(BlockSeqno seqno, td::Promise<td::uint32> promise) = 0;
virtual void update_last_known_key_block(BlockHandle handle, bool send_request) = 0;
virtual void update_gc_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) = 0;

4
validator/manager-disk.hpp
View file

@ -279,8 +279,8 @@ class ValidatorManagerImpl : public ValidatorManager {
CHECK(block_id.is_masterchain());
promise.set_result(opts_->is_hardfork(block_id));
}
void get_vertical_height(BlockSeqno seqno, td::Promise<td::uint32> promise) override {
promise.set_result(opts_->get_vertical_height(seqno));
void get_vertical_seqno(BlockSeqno seqno, td::Promise<td::uint32> promise) override {
promise.set_result(opts_->get_vertical_seqno(seqno));
}
void run_ext_query(td::BufferSlice data, td::Promise<td::BufferSlice> promise) override {
UNREACHABLE();

63
validator/manager.cpp
View file

@ -73,7 +73,8 @@ void ValidatorManagerImpl::validate_block_is_next_proof(BlockIdExt prev_block_id
promise.set_value(td::Unit());
});
run_check_proof_query(next_block_id, pp.move_as_ok(), actor_id(this), td::Timestamp::in(2.0), std::move(P));
run_check_proof_query(next_block_id, pp.move_as_ok(), actor_id(this), td::Timestamp::in(2.0), std::move(P),
opts_->is_hardfork(next_block_id));
}
void ValidatorManagerImpl::validate_block_proof(BlockIdExt block_id, td::BufferSlice proof,
@ -91,7 +92,8 @@ void ValidatorManagerImpl::validate_block_proof(BlockIdExt block_id, td::BufferS
promise.set_value(td::Unit());
}
});
run_check_proof_query(block_id, pp.move_as_ok(), actor_id(this), td::Timestamp::in(2.0), std::move(P));
run_check_proof_query(block_id, pp.move_as_ok(), actor_id(this), td::Timestamp::in(2.0), std::move(P),
opts_->is_hardfork(block_id));
}
void ValidatorManagerImpl::validate_block_proof_link(BlockIdExt block_id, td::BufferSlice proof,
@ -129,28 +131,30 @@ void ValidatorManagerImpl::validate_block_proof_rel(BlockIdExt block_id, BlockId
});
if (rel_block_id.id.seqno == 0) {
auto P = td::PromiseCreator::lambda([block_id, SelfId = actor_id(this), proof = pp.move_as_ok(),
promise = std::move(Q)](td::Result<td::Ref<ShardState>> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
} else {
auto s = td::Ref<MasterchainState>{R.move_as_ok()};
auto P = td::PromiseCreator::lambda(
[block_id, SelfId = actor_id(this), proof = pp.move_as_ok(), promise = std::move(Q),
skip_sig = opts_->is_hardfork(block_id)](td::Result<td::Ref<ShardState>> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
} else {
auto s = td::Ref<MasterchainState>{R.move_as_ok()};
run_check_proof_query(block_id, std::move(proof), SelfId, td::Timestamp::in(2.0), std::move(promise),
std::move(s));
}
});
run_check_proof_query(block_id, std::move(proof), SelfId, td::Timestamp::in(2.0), std::move(promise),
std::move(s), skip_sig);
}
});
get_shard_state_from_db_short(rel_block_id, std::move(P));
} else {
auto P = td::PromiseCreator::lambda([block_id, SelfId = actor_id(this), proof = pp.move_as_ok(),
promise = std::move(Q)](td::Result<td::Ref<ProofLink>> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
} else {
run_check_proof_query(block_id, std::move(proof), SelfId, td::Timestamp::in(2.0), std::move(promise),
R.move_as_ok());
}
});
auto P =
td::PromiseCreator::lambda([block_id, SelfId = actor_id(this), proof = pp.move_as_ok(), promise = std::move(Q),
skip_sig = opts_->is_hardfork(block_id)](td::Result<td::Ref<ProofLink>> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
} else {
run_check_proof_query(block_id, std::move(proof), SelfId, td::Timestamp::in(2.0), std::move(promise),
R.move_as_ok(), skip_sig);
}
});
get_block_proof_link_from_db_short(rel_block_id, std::move(P));
}
}
@ -464,7 +468,7 @@ void ValidatorManagerImpl::run_ext_query(td::BufferSlice data, td::Promise<td::B
promise.set_value(std::move(data));
});
run_liteserver_query(std::move(data), actor_id(this), std::move(P));
run_liteserver_query(std::move(data), actor_id(this), lite_server_cache_.get(), std::move(P));
}
void ValidatorManagerImpl::wait_block_state(BlockHandle handle, td::uint32 priority, td::Timestamp timeout,
@ -1289,6 +1293,7 @@ void ValidatorManagerImpl::send_block_broadcast(BlockBroadcast broadcast) {
void ValidatorManagerImpl::start_up() {
db_ = create_db_actor(actor_id(this), db_root_, opts_->get_filedb_depth());
lite_server_cache_ = create_liteserver_cache_actor(actor_id(this), db_root_);
token_manager_ = td::actor::create_actor<TokenManager>("tokenmanager");
auto Q =
@ -1583,13 +1588,19 @@ ValidatorSessionId ValidatorManagerImpl::get_validator_set_id(ShardIdFull shard,
td::Bits256 opts_hash) {
std::vector<tl_object_ptr<ton_api::validator_groupMember>> vec;
auto v = val_set->export_vector();
auto vert_seqno = opts_->get_maximal_vertical_seqno();
for (auto &n : v) {
auto pub_key = PublicKey{pubkeys::Ed25519{n.key}};
vec.push_back(
create_tl_object<ton_api::validator_groupMember>(pub_key.compute_short_id().bits256_value(), n.addr, n.weight));
}
return create_hash_tl_object<ton_api::validator_group>(shard.workchain, shard.shard, val_set->get_catchain_seqno(),
opts_hash, std::move(vec));
if (vert_seqno == 0) {
return create_hash_tl_object<ton_api::validator_group>(shard.workchain, shard.shard, val_set->get_catchain_seqno(),
opts_hash, std::move(vec));
} else {
return create_hash_tl_object<ton_api::validator_groupEx>(shard.workchain, shard.shard, vert_seqno,
val_set->get_catchain_seqno(), opts_hash, std::move(vec));
}
}
td::actor::ActorOwn<ValidatorGroup> ValidatorManagerImpl::create_validator_group(
@ -1975,8 +1986,6 @@ void ValidatorManagerImpl::send_peek_key_block_request() {
void ValidatorManagerImpl::prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) {
auto merger = StatsMerger::create(std::move(promise));
td::actor::send_closure(db_, &Db::prepare_stats, merger.make_promise("db."));
std::vector<std::pair<std::string, std::string>> vec;
vec.emplace_back("unixtime", td::to_string(static_cast<UnixTime>(td::Clocks::system())));
if (last_masterchain_block_handle_) {
@ -2004,6 +2013,8 @@ void ValidatorManagerImpl::prepare_stats(td::Promise<std::vector<std::pair<std::
}
merger.make_promise("").set_value(std::move(vec));
td::actor::send_closure(db_, &Db::prepare_stats, merger.make_promise("db."));
}
td::actor::ActorOwn<ValidatorManagerInterface> ValidatorManagerFactory::create(

5
validator/manager.hpp
View file

@ -432,8 +432,8 @@ class ValidatorManagerImpl : public ValidatorManager {
CHECK(block_id.is_masterchain());
promise.set_result(opts_->is_hardfork(block_id));
}
void get_vertical_height(BlockSeqno seqno, td::Promise<td::uint32> promise) override {
promise.set_result(opts_->get_vertical_height(seqno));
void get_vertical_seqno(BlockSeqno seqno, td::Promise<td::uint32> promise) override {
promise.set_result(opts_->get_vertical_seqno(seqno));
}
void add_shard_block_description(td::Ref<ShardTopBlockDescription> desc);
@ -522,6 +522,7 @@ class ValidatorManagerImpl : public ValidatorManager {
private:
td::actor::ActorOwn<adnl::AdnlExtServer> lite_server_;
td::actor::ActorOwn<LiteServerCache> lite_server_cache_;
std::vector<td::uint16> pending_ext_ports_;
std::vector<adnl::AdnlNodeIdShort> pending_ext_ids_;

8
validator/validator-options.hpp
View file

@ -67,7 +67,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
}
return false;
}
td::uint32 get_vertical_height(BlockSeqno seqno) const override {
td::uint32 get_vertical_seqno(BlockSeqno seqno) const override {
size_t best = 0;
for (size_t i = 0; i < hardforks_.size(); i++) {
if (seqno >= hardforks_[i].seqno()) {
@ -76,6 +76,12 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
}
return static_cast<td::uint32>(best);
}
td::uint32 get_maximal_vertical_seqno() const override {
return td::narrow_cast<td::uint32>(hardforks_.size());
}
td::uint32 get_last_fork_masterchain_seqno() const override {
return hardforks_.size() ? hardforks_.rbegin()->seqno() : 0;
}
td::uint32 get_filedb_depth() const override {
return db_depth_;
}

4
validator/validator.h
View file

@ -57,7 +57,9 @@ struct ValidatorManagerOptions : public td::CntObject {
virtual td::ClocksBase::Duration key_proof_ttl() const = 0;
virtual bool initial_sync_disabled() const = 0;
virtual bool is_hardfork(BlockIdExt block_id) const = 0;
virtual td::uint32 get_vertical_height(BlockSeqno seqno) const = 0;
virtual td::uint32 get_vertical_seqno(BlockSeqno seqno) const = 0;
virtual td::uint32 get_maximal_vertical_seqno() const = 0;
virtual td::uint32 get_last_fork_masterchain_seqno() const = 0;
virtual td::uint32 get_filedb_depth() const = 0;
virtual td::uint32 key_block_utime_step() const {
return 86400;