extra;
- if (!block::unpack_CurrencyCollection(info.value, value, extra)) {
+ block::CurrencyCollection currency_collection;
+ if (!currency_collection.unpack(info.value)) {
abort("cannot unpack message value");
return *this;
}
@@ -133,7 +132,7 @@ HttpAnswer& HttpAnswer::operator<<(MessageCell msg) {
<< "| destination | " << AddressCell{info.dest} << " |
|---|
\n"
<< "| lt | " << info.created_lt << " |
|---|
\n"
<< "| time | " << info.created_at << " (" << time_to_human(info.created_at) << ") |
|---|
\n"
- << "| value | " << value << " |
|---|
\n";
+ << "| value | " << currency_collection.to_str()<< " |
|---|
\n";
break;
}
default:
@@ -365,6 +364,7 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
ton::LogicalTime last_trans_lt = 0;
ton::Bits256 last_trans_hash;
last_trans_hash.set_zero();
+ block::CurrencyCollection balance = block::CurrencyCollection::zero();
try {
auto state_root = vm::MerkleProof::virtualize(acc_c.q_roots[1], 1);
if (state_root.is_null()) {
@@ -397,6 +397,20 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
}
last_trans_hash = acc_info.last_trans_hash;
last_trans_lt = acc_info.last_trans_lt;
+ block::gen::Account::Record_account acc;
+ block::gen::AccountStorage::Record storage_rec;
+ if (!tlb::unpack_cell(acc_c.root, acc)) {
+ abort("cannot unpack Account");
+ return *this;
+ }
+ if (!tlb::csr_unpack(acc.storage, storage_rec)) {
+ abort("cannot unpack AccountStorage");
+ return *this;
+ }
+ if (!balance.unpack(storage_rec.balance)) {
+ abort("cannot unpack account balance");
+ return *this;
+ }
} else if (acc_c.root.not_null()) {
abort(PSTRING() << "account state proof shows that account state for " << acc_c.addr.workchain << ":"
<< acc_c.addr.addr.to_hex() << " must be empty, but it is not");
@@ -434,6 +448,7 @@ HttpAnswer& HttpAnswer::operator<<(AccountCell acc_c) {
*this << "| workchain | " << acc_c.addr.workchain << " |
|---|
";
*this << "| account hex | " << acc_c.addr.addr.to_hex() << " |
|---|
";
*this << "| account | " << acc_c.addr.rserialize(true) << " |
|---|
";
+ *this << "| balance | " << balance.to_str() << " |
|---|
";
if (last_trans_lt > 0) {
*this << "| last transaction | "
<< "lt=" << last_trans_lt
diff --git a/blockchain-explorer/blockchain-explorer-query.cpp b/blockchain-explorer/blockchain-explorer-query.cpp
index b53e7969..26a6787e 100644
--- a/blockchain-explorer/blockchain-explorer-query.cpp
+++ b/blockchain-explorer/blockchain-explorer-query.cpp
@@ -50,32 +50,6 @@
#include "vm/vm.h"
#include "vm/cp0.h"
-namespace {
-
-td::Ref prepare_vm_c7(ton::UnixTime now, ton::LogicalTime lt, td::Ref my_addr,
- const block::CurrencyCollection &balance) {
- td::BitArray<256> rand_seed;
- td::RefInt256 rand_seed_int{true};
- td::Random::secure_bytes(rand_seed.as_slice());
- if (!rand_seed_int.unique_write().import_bits(rand_seed.cbits(), 256, false)) {
- return {};
- }
- auto tuple = vm::make_tuple_ref(td::make_refint(0x076ef1ea), // [ magic:0x076ef1ea
- td::make_refint(0), // actions:Integer
- td::make_refint(0), // msgs_sent:Integer
- td::make_refint(now), // unixtime:Integer
- td::make_refint(lt), // block_lt:Integer
- td::make_refint(lt), // trans_lt:Integer
- std::move(rand_seed_int), // rand_seed:Integer
- balance.as_vm_tuple(), // balance_remaining:[Integer (Maybe Cell)]
- my_addr, // myself:MsgAddressInt
- vm::StackEntry()); // global_config:(Maybe Cell) ] = SmartContractInfo;
- LOG(DEBUG) << "SmartContractInfo initialized with " << vm::StackEntry(tuple).to_string();
- return vm::make_tuple_ref(std::move(tuple));
-}
-
-} // namespace
-
td::Result parse_block_id(std::map &opts, bool allow_empty) {
if (allow_empty) {
if (opts.count("workchain") == 0 && opts.count("shard") == 0 && opts.count("seqno") == 0) {
@@ -1343,111 +1317,71 @@ void HttpQueryRunMethod::start_up_query() {
if (R.is_error()) {
td::actor::send_closure(SelfId, &HttpQueryRunMethod::abort_query, R.move_as_error_prefix("litequery failed: "));
} else {
- td::actor::send_closure(SelfId, &HttpQueryRunMethod::got_account, R.move_as_ok());
+ td::actor::send_closure(SelfId, &HttpQueryRunMethod::got_result, R.move_as_ok());
}
});
+
auto a = ton::create_tl_object(addr_.workchain, addr_.addr);
- auto query = ton::serialize_tl_object(ton::create_tl_object(
- ton::create_tl_lite_block_id(block_id_), std::move(a)),
- true);
+ td::int64 method_id = (td::crc16(td::Slice{method_name_}) & 0xffff) | 0x10000;
+
+ // serialize params
+ vm::CellBuilder cb;
+ td::Ref cell;
+ if (!(vm::Stack{params_}.serialize(cb) && cb.finalize_to(cell))) {
+ return abort_query(td::Status::Error("cannot serialize stack with get-method parameters"));
+ }
+ auto params_serialized = vm::std_boc_serialize(std::move(cell));
+ if (params_serialized.is_error()) {
+ return abort_query(params_serialized.move_as_error_prefix("cannot serialize stack with get-method parameters : "));
+ }
+
+ auto query = ton::serialize_tl_object(
+ ton::create_tl_object(
+ 0x17, ton::create_tl_lite_block_id(block_id_), std::move(a), method_id, params_serialized.move_as_ok()),
+ true);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
}
-void HttpQueryRunMethod::got_account(td::BufferSlice data) {
- auto F = ton::fetch_tl_object(std::move(data), true);
+void HttpQueryRunMethod::got_result(td::BufferSlice data) {
+ auto F = ton::fetch_tl_object(std::move(data), true);
if (F.is_error()) {
- abort_query(F.move_as_error());
- return;
+ return abort_query(F.move_as_error());
}
-
auto f = F.move_as_ok();
- data_ = std::move(f->state_);
- proof_ = std::move(f->proof_);
- shard_proof_ = std::move(f->shard_proof_);
- block_id_ = ton::create_block_id(f->id_);
- res_block_id_ = ton::create_block_id(f->shardblk_);
-
- finish_query();
-}
-
-void HttpQueryRunMethod::finish_query() {
- if (promise_) {
- auto page = [&]() -> std::string {
- HttpAnswer A{"account", prefix_};
- A.set_account_id(addr_);
- A.set_block_id(res_block_id_);
-
- block::AccountState account_state;
- account_state.blk = block_id_;
- account_state.shard_blk = res_block_id_;
- account_state.shard_proof = std::move(shard_proof_);
- account_state.proof = std::move(proof_);
- account_state.state = std::move(data_);
- auto r_info = account_state.validate(block_id_, addr_);
- if (r_info.is_error()) {
- A.abort(r_info.move_as_error());
- return A.finish();
- }
- auto info = r_info.move_as_ok();
- if (info.root.is_null()) {
- A.abort(PSTRING() << "account state of " << addr_ << " is empty (cannot run method `" << method_name_ << "`)");
- return A.finish();
- }
- block::gen::Account::Record_account acc;
- block::gen::AccountStorage::Record store;
- block::CurrencyCollection balance;
- if (!(tlb::unpack_cell(info.root, acc) && tlb::csr_unpack(acc.storage, store) &&
- balance.validate_unpack(store.balance))) {
- A.abort("error unpacking account state");
- return A.finish();
- }
- int tag = block::gen::t_AccountState.get_tag(*store.state);
- switch (tag) {
- case block::gen::AccountState::account_uninit:
- A.abort(PSTRING() << "account " << addr_ << " not initialized yet (cannot run any methods)");
- return A.finish();
- case block::gen::AccountState::account_frozen:
- A.abort(PSTRING() << "account " << addr_ << " frozen (cannot run any methods)");
- return A.finish();
- }
-
- CHECK(store.state.write().fetch_ulong(1) == 1); // account_init$1 _:StateInit = AccountState;
- block::gen::StateInit::Record state_init;
- CHECK(tlb::csr_unpack(store.state, state_init));
- auto code = state_init.code->prefetch_ref();
- auto data = state_init.data->prefetch_ref();
- auto stack = td::make_ref(std::move(params_));
- td::int64 method_id = (td::crc16(td::Slice{method_name_}) & 0xffff) | 0x10000;
- stack.write().push_smallint(method_id);
- long long gas_limit = vm::GasLimits::infty;
- // OstreamLogger ostream_logger(ctx.error_stream);
- // auto log = create_vm_log(ctx.error_stream ? &ostream_logger : nullptr);
- vm::GasLimits gas{gas_limit};
- LOG(DEBUG) << "creating VM";
- vm::VmState vm{code, std::move(stack), gas, 1, data, vm::VmLog()};
- vm.set_c7(prepare_vm_c7(info.gen_utime, info.gen_lt, acc.addr, balance)); // tuple with SmartContractInfo
- // vm.incr_stack_trace(1); // enable stack dump after each step
- int exit_code = ~vm.run();
- if (exit_code != 0) {
- A.abort(PSTRING() << "VM terminated with error code " << exit_code);
- return A.finish();
- }
- stack = vm.get_stack_ref();
- {
- std::ostringstream os;
- os << "result: ";
- stack->dump(os, 3);
-
- A << HttpAnswer::CodeBlock{os.str()};
- }
-
+ auto page = [&]() -> std::string {
+ HttpAnswer A{"account", prefix_};
+ A.set_account_id(addr_);
+ A.set_block_id(ton::create_block_id(f->id_));
+ if (f->exit_code_ != 0) {
+ A.abort(PSTRING() << "VM terminated with error code " << f->exit_code_);
return A.finish();
- }();
- auto R = MHD_create_response_from_buffer(page.length(), const_cast(page.c_str()), MHD_RESPMEM_MUST_COPY);
- MHD_add_response_header(R, "Content-Type", "text/html");
- promise_.set_value(std::move(R));
- }
+ }
+
+ std::ostringstream os;
+ os << "result: ";
+ if (f->result_.empty()) {
+ os << "";
+ } else {
+ auto r_cell = vm::std_boc_deserialize(f->result_);
+ if (r_cell.is_error()) {
+ A.abort(PSTRING() << "cannot deserialize VM result boc: " << r_cell.move_as_error());
+ return A.finish();
+ }
+ auto cs = vm::load_cell_slice(r_cell.move_as_ok());
+ td::Ref stack;
+ if (!(vm::Stack::deserialize_to(cs, stack, 0) && cs.empty_ext())) {
+ A.abort("VM result boc cannot be deserialized");
+ return A.finish();
+ }
+ stack->dump(os, 3);
+ }
+ A << HttpAnswer::CodeBlock{os.str()};
+ return A.finish();
+ }();
+ auto R = MHD_create_response_from_buffer(page.length(), const_cast(page.c_str()), MHD_RESPMEM_MUST_COPY);
+ MHD_add_response_header(R, "Content-Type", "text/html");
+ promise_.set_value(std::move(R));
stop();
}
HttpQueryStatus::HttpQueryStatus(std::string prefix, td::Promise promise)
@@ -1498,7 +1432,7 @@ void HttpQueryStatus::finish_query() {
for (td::uint32 i = 0; i < results_.ips.size(); i++) {
A << "";
if (results_.ips[i].is_valid()) {
- A << "| " << results_.ips[i] << " | ";
+ A << "" << results_.ips[i].get_ip_str() << ":" << results_.ips[i].get_port() << " | ";
} else {
A << "hidden | ";
}
diff --git a/blockchain-explorer/blockchain-explorer-query.hpp b/blockchain-explorer/blockchain-explorer-query.hpp
index 0ce52af6..29501265 100644
--- a/blockchain-explorer/blockchain-explorer-query.hpp
+++ b/blockchain-explorer/blockchain-explorer-query.hpp
@@ -311,22 +311,14 @@ class HttpQueryRunMethod : public HttpQueryCommon {
std::vector params, std::string prefix, td::Promise promise);
HttpQueryRunMethod(std::map opts, std::string prefix, td::Promise promise);
- void finish_query();
-
void start_up_query() override;
- void got_account(td::BufferSlice result);
+ void got_result(td::BufferSlice result);
private:
ton::BlockIdExt block_id_;
block::StdAddress addr_;
-
std::string method_name_;
std::vector params_;
-
- td::BufferSlice data_;
- td::BufferSlice proof_;
- td::BufferSlice shard_proof_;
- ton::BlockIdExt res_block_id_;
};
class HttpQueryStatus : public HttpQueryCommon {
diff --git a/blockchain-explorer/blockchain-explorer.cpp b/blockchain-explorer/blockchain-explorer.cpp
index 3b5346b7..ca50d526 100644
--- a/blockchain-explorer/blockchain-explorer.cpp
+++ b/blockchain-explorer/blockchain-explorer.cpp
@@ -57,6 +57,7 @@
#include "auto/tl/lite_api.h"
#include "ton/lite-tl.hpp"
#include "tl-utils/lite-utils.hpp"
+#include "lite-client/ext-client.h"
#include
@@ -127,7 +128,7 @@ class CoreActor : public CoreActorInterface {
private:
std::string global_config_ = "ton-global.config";
- std::vector> clients_;
+ td::actor::ActorOwn client_;
td::uint32 http_port_ = 80;
MHD_Daemon* daemon_ = nullptr;
@@ -137,35 +138,29 @@ class CoreActor : public CoreActorInterface {
bool hide_ips_ = false;
- std::unique_ptr make_callback(td::uint32 idx) {
- class Callback : public ton::adnl::AdnlExtClient::Callback {
+ td::unique_ptr make_callback() {
+ class Callback : public liteclient::ExtClient::Callback {
public:
- void on_ready() override {
- td::actor::send_closure(id_, &CoreActor::conn_ready, idx_);
- }
- void on_stop_ready() override {
- td::actor::send_closure(id_, &CoreActor::conn_closed, idx_);
- }
- Callback(td::actor::ActorId id, td::uint32 idx) : id_(std::move(id)), idx_(idx) {
+ Callback(td::actor::ActorId id) : id_(std::move(id)) {
}
private:
td::actor::ActorId id_;
- td::uint32 idx_;
};
- return std::make_unique(actor_id(this), idx);
+ return td::make_unique(actor_id(this));
}
std::shared_ptr new_result_;
td::int32 attempt_ = 0;
td::int32 waiting_ = 0;
- std::vector ready_;
+ size_t n_servers_ = 0;
void run_queries();
- void got_result(td::uint32 idx, td::int32 attempt, td::Result data);
- void send_query(td::uint32 idx);
+ void got_servers_ready(td::int32 attempt, std::vector ready);
+ void send_ping(td::uint32 idx);
+ void got_ping_result(td::uint32 idx, td::int32 attempt, td::Result data);
void add_result() {
if (new_result_) {
@@ -196,12 +191,6 @@ class CoreActor : public CoreActorInterface {
static CoreActor* instance_;
td::actor::ActorId self_id_;
- void conn_ready(td::uint32 idx) {
- ready_.at(idx) = true;
- }
- void conn_closed(td::uint32 idx) {
- ready_.at(idx) = false;
- }
void set_global_config(std::string str) {
global_config_ = str;
}
@@ -226,10 +215,7 @@ class CoreActor : public CoreActorInterface {
hide_ips_ = value;
}
- void send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise promise);
- void send_lite_query(td::BufferSlice data, td::Promise promise) override {
- return send_lite_query(0, std::move(data), std::move(promise));
- }
+ void send_lite_query(td::BufferSlice query, td::Promise promise) override;
void get_last_result(td::Promise> promise) override {
}
void get_results(td::uint32 max, td::Promise promise) override {
@@ -449,33 +435,27 @@ class CoreActor : public CoreActorInterface {
}
void run() {
+ std::vector servers;
if (remote_public_key_.empty()) {
auto G = td::read_file(global_config_).move_as_ok();
auto gc_j = td::json_decode(G.as_slice()).move_as_ok();
ton::ton_api::liteclient_config_global gc;
ton::ton_api::from_json(gc, gc_j.get_object()).ensure();
-
- CHECK(gc.liteservers_.size() > 0);
- td::uint32 size = static_cast(gc.liteservers_.size());
- ready_.resize(size, false);
-
- for (td::uint32 i = 0; i < size; i++) {
- auto& cli = gc.liteservers_[i];
- td::IPAddress addr;
- addr.init_host_port(td::IPAddress::ipv4_to_str(cli->ip_), cli->port_).ensure();
- addrs_.push_back(addr);
- clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull::create(cli->id_).move_as_ok(),
- addr, make_callback(i)));
+ auto r_servers = liteclient::LiteServerConfig::parse_global_config(gc);
+ r_servers.ensure();
+ servers = r_servers.move_as_ok();
+ for (const auto& serv : servers) {
+ addrs_.push_back(serv.addr);
}
} else {
if (!remote_addr_.is_valid()) {
LOG(FATAL) << "remote addr not set";
}
- ready_.resize(1, false);
addrs_.push_back(remote_addr_);
- clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull{remote_public_key_},
- remote_addr_, make_callback(0)));
+ servers.push_back(liteclient::LiteServerConfig{ton::adnl::AdnlNodeIdFull{remote_public_key_}, remote_addr_});
}
+ n_servers_ = servers.size();
+ client_ = liteclient::ExtClient::create(std::move(servers), make_callback(), true);
daemon_ = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, static_cast(http_port_), nullptr, nullptr,
&process_http_request, nullptr, MHD_OPTION_NOTIFY_COMPLETED, request_completed, nullptr,
MHD_OPTION_THREAD_POOL_SIZE, 16, MHD_OPTION_END);
@@ -483,7 +463,46 @@ class CoreActor : public CoreActorInterface {
}
};
-void CoreActor::got_result(td::uint32 idx, td::int32 attempt, td::Result R) {
+void CoreActor::run_queries() {
+ waiting_ = 0;
+ new_result_ = std::make_shared(n_servers_, td::Timestamp::at_unix(attempt_ * 60));
+ td::actor::send_closure(client_, &liteclient::ExtClient::get_servers_status,
+ [SelfId = actor_id(this), attempt = attempt_](td::Result> R) {
+ R.ensure();
+ td::actor::send_closure(SelfId, &CoreActor::got_servers_ready, attempt, R.move_as_ok());
+ });
+}
+
+void CoreActor::got_servers_ready(td::int32 attempt, std::vector ready) {
+ if (attempt != attempt_) {
+ return;
+ }
+ CHECK(ready.size() == n_servers_);
+ for (td::uint32 i = 0; i < n_servers_; i++) {
+ if (ready[i]) {
+ send_ping(i);
+ }
+ }
+ CHECK(waiting_ >= 0);
+ if (waiting_ == 0) {
+ add_result();
+ }
+}
+
+void CoreActor::send_ping(td::uint32 idx) {
+ waiting_++;
+ auto query = ton::create_tl_object();
+ auto q = ton::create_tl_object(serialize_tl_object(query, true));
+
+ auto P =
+ td::PromiseCreator::lambda([SelfId = actor_id(this), idx, attempt = attempt_](td::Result R) {
+ td::actor::send_closure(SelfId, &CoreActor::got_ping_result, idx, attempt, std::move(R));
+ });
+ td::actor::send_closure(client_, &liteclient::ExtClient::send_query_to_server, "query", serialize_tl_object(q, true),
+ idx, td::Timestamp::in(10.0), std::move(P));
+}
+
+void CoreActor::got_ping_result(td::uint32 idx, td::int32 attempt, td::Result R) {
if (attempt != attempt_) {
return;
}
@@ -524,39 +543,7 @@ void CoreActor::got_result(td::uint32 idx, td::int32 attempt, td::Result();
- auto q = ton::create_tl_object(serialize_tl_object(query, true));
-
- auto P =
- td::PromiseCreator::lambda([SelfId = actor_id(this), idx, attempt = attempt_](td::Result R) {
- td::actor::send_closure(SelfId, &CoreActor::got_result, idx, attempt, std::move(R));
- });
- td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
- td::Timestamp::in(10.0), std::move(P));
-}
-
-void CoreActor::run_queries() {
- waiting_ = 0;
- new_result_ = std::make_shared(ready_.size(), td::Timestamp::at_unix(attempt_ * 60));
- for (td::uint32 i = 0; i < ready_.size(); i++) {
- send_query(i);
- }
- CHECK(waiting_ >= 0);
- if (waiting_ == 0) {
- add_result();
- }
-}
-
-void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise promise) {
- if (!ready_[idx]) {
- promise.set_error(td::Status::Error(ton::ErrorCode::notready, "ext conn not ready"));
- return;
- }
+void CoreActor::send_lite_query(td::BufferSlice query, td::Promise promise) {
auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
@@ -574,7 +561,7 @@ void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promi
promise.set_value(std::move(B));
});
auto q = ton::create_tl_object(std::move(query));
- td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
+ td::actor::send_closure(client_, &liteclient::ExtClient::send_query, "query", serialize_tl_object(q, true),
td::Timestamp::in(10.0), std::move(P));
}
diff --git a/catchain/CMakeLists.txt b/catchain/CMakeLists.txt
index 8ab9525d..3f766688 100644
--- a/catchain/CMakeLists.txt
+++ b/catchain/CMakeLists.txt
@@ -34,6 +34,5 @@ target_include_directories(overlay PUBLIC
$/..
${OPENSSL_INCLUDE_DIR}
)
-target_link_libraries(catchain PRIVATE tdutils tdactor adnl tl_api dht tdfec
- overlay)
+target_link_libraries(catchain PRIVATE tdutils tdactor adnl tl_api dht tdfec overlay)
diff --git a/catchain/catchain-receiver-source.h b/catchain/catchain-receiver-source.h
index 55035e77..136906a0 100644
--- a/catchain/catchain-receiver-source.h
+++ b/catchain/catchain-receiver-source.h
@@ -61,7 +61,7 @@ class CatChainReceiverSource {
virtual td::BufferSlice fork_proof() const = 0;
virtual bool fork_is_found() const = 0;
- // One block can be sent to one node only a limited number of times to prevent DoS
+ // One block can be sent to one node in catchain.getDifference only a limited number of times to prevent DoS
virtual bool allow_send_block(CatChainBlockHash hash) = 0;
static td::Result> create(CatChainReceiver *chain, PublicKey pub_key,
diff --git a/catchain/catchain-receiver.cpp b/catchain/catchain-receiver.cpp
index 482cfb43..a6160383 100644
--- a/catchain/catchain-receiver.cpp
+++ b/catchain/catchain-receiver.cpp
@@ -27,6 +27,8 @@
#include "catchain-receiver.hpp"
+#include "td/utils/ThreadSafeCounter.h"
+
namespace ton {
namespace catchain {
@@ -287,7 +289,9 @@ void CatChainReceiverImpl::add_block_cont_3(tl_object_ptrdelivered());
+ LOG_CHECK(last_sent_block_->delivered())
+ << "source=" << last_sent_block_->get_source_id() << " ill=" << last_sent_block_->is_ill()
+ << " height=" << last_sent_block_->get_height();
}
active_send_ = false;
@@ -366,6 +370,12 @@ void CatChainReceiverImpl::add_block(td::BufferSlice payload, std::vectorheight_ + 1;
+ auto max_block_height = get_max_block_height(opts_, sources_.size());
+ if (td::narrow_cast(height) > max_block_height) {
+ VLOG(CATCHAIN_WARNING) << this << ": cannot create block: max height exceeded (" << max_block_height << ")";
+ active_send_ = false;
+ return;
+ }
auto block_data = create_tl_object(std::move(prev), std::move(deps_arr));
auto block = create_tl_object(incarnation_, local_idx_, height, std::move(block_data),
td::BufferSlice());
@@ -516,9 +526,12 @@ void CatChainReceiverImpl::start_up() {
for (td::uint32 i = 0; i < get_sources_cnt(); i++) {
root_keys.emplace(get_source(i)->get_hash(), OVERLAY_MAX_ALLOWED_PACKET_SIZE);
}
- td::actor::send_closure(overlay_manager_, &overlay::Overlays::create_private_overlay,
+ overlay::OverlayOptions overlay_options;
+ overlay_options.broadcast_speed_multiplier_ = opts_.broadcast_speed_multiplier;
+ td::actor::send_closure(overlay_manager_, &overlay::Overlays::create_private_overlay_ex,
get_source(local_idx_)->get_adnl_id(), overlay_full_id_.clone(), std::move(ids),
- make_callback(), overlay::OverlayPrivacyRules{0, 0, std::move(root_keys)});
+ make_callback(), overlay::OverlayPrivacyRules{0, 0, std::move(root_keys)},
+ R"({ "type": "catchain" })", std::move(overlay_options));
CHECK(root_block_);
@@ -676,6 +689,7 @@ void CatChainReceiverImpl::receive_query_from_overlay(adnl::AdnlNodeIdShort src,
promise.set_error(td::Status::Error(ErrorCode::notready, "db not read"));
return;
}
+ TD_PERF_COUNTER(catchain_query_process);
td::PerfWarningTimer t{"catchain query process", 0.05};
auto F = fetch_tl_object(data.clone(), true);
if (F.is_error()) {
@@ -694,12 +708,8 @@ void CatChainReceiverImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::cat
} else {
CatChainReceiverSource *S = get_source_by_adnl_id(src);
CHECK(S != nullptr);
- if (S->allow_send_block(it->second->get_hash())) {
- promise.set_value(serialize_tl_object(create_tl_object(it->second->export_tl()),
- true, it->second->get_payload().as_slice()));
- } else {
- promise.set_error(td::Status::Error("block was requested too many times"));
- }
+ promise.set_value(serialize_tl_object(create_tl_object(it->second->export_tl()),
+ true, it->second->get_payload().as_slice()));
}
}
diff --git a/catchain/catchain.h b/catchain/catchain.h
index 912957e5..c5c8af28 100644
--- a/catchain/catchain.h
+++ b/catchain/catchain.h
@@ -96,6 +96,7 @@ class CatChain : public td::actor::Actor {
virtual void send_query_via(const PublicKeyHash &dst, std::string name, td::Promise promise,
td::Timestamp timeout, td::BufferSlice query, td::uint64 max_answer_size,
td::actor::ActorId via) = 0;
+ virtual void get_source_heights(td::Promise> promise) = 0;
virtual void destroy() = 0;
static td::actor::ActorOwn create(std::unique_ptr callback, const CatChainOptions &opts,
diff --git a/catchain/catchain.hpp b/catchain/catchain.hpp
index 8c8bb99a..586cf474 100644
--- a/catchain/catchain.hpp
+++ b/catchain/catchain.hpp
@@ -115,6 +115,15 @@ class CatChainImpl : public CatChain {
td::actor::send_closure(receiver_, &CatChainReceiverInterface::send_custom_query_data_via, dst, name,
std::move(promise), timeout, std::move(query), max_answer_size, via);
}
+ void get_source_heights(td::Promise> promise) override {
+ std::vector heights(top_source_blocks_.size(), 0);
+ for (size_t i = 0; i < top_source_blocks_.size(); ++i) {
+ if (top_source_blocks_[i]) {
+ heights[i] = top_source_blocks_[i]->height();
+ }
+ }
+ promise.set_result(std::move(heights));
+ }
void destroy() override;
CatChainImpl(std::unique_ptr callback, const CatChainOptions &opts,
td::actor::ActorId keyring, td::actor::ActorId adnl,
diff --git a/common/delay.h b/common/delay.h
index 9b98c58e..3df8e7d8 100644
--- a/common/delay.h
+++ b/common/delay.h
@@ -49,4 +49,29 @@ template
void delay_action(T promise, td::Timestamp timeout) {
DelayedAction::create(std::move(promise), timeout);
}
+
+template
+class AsyncApply : public td::actor::Actor {
+ public:
+ AsyncApply(PromiseT promise, ValueT value) : promise_(std::move(promise)), value_(std::move(value)){
+ }
+
+ void start_up() override {
+ promise_(std::move(value_));
+ stop();
+ }
+
+ static void create(td::Slice name, PromiseT promise, ValueT value ) {
+ td::actor::create_actor(PSLICE() << "async:" << name, std::move(promise), std::move(value)).release();
+ }
+
+ private:
+ PromiseT promise_;
+ ValueT value_;
+};
+
+template
+void async_apply(td::Slice name, PromiseT &&promise, ValueT &&value) {
+ AsyncApply::create(name, std::forward(promise), std::forward(value));
+}
} // namespace ton
diff --git a/common/global-version.h b/common/global-version.h
index 01c1795d..2308ce3e 100644
--- a/common/global-version.h
+++ b/common/global-version.h
@@ -19,6 +19,6 @@
namespace ton {
// See doc/GlobalVersions.md
-const int SUPPORTED_VERSION = 4;
+constexpr int SUPPORTED_VERSION = 10;
}
diff --git a/create-hardfork/CMakeLists.txt b/create-hardfork/CMakeLists.txt
index 41b94b52..3024603c 100644
--- a/create-hardfork/CMakeLists.txt
+++ b/create-hardfork/CMakeLists.txt
@@ -10,8 +10,7 @@ set(CREATE_HARDFORK_SOURCE
)
add_executable(create-hardfork ${CREATE_HARDFORK_SOURCE})
-target_link_libraries(create-hardfork overlay tdutils tdactor adnl tl_api dht
- rldp catchain validatorsession full-node validator-hardfork ton_validator
+target_link_libraries(create-hardfork overlay tdutils tdactor adnl tl_api dht rldp catchain validatorsession full-node validator-hardfork ton_validator
validator-hardfork fift-lib memprof git ${JEMALLOC_LIBRARIES})
install(TARGETS create-hardfork RUNTIME DESTINATION bin)
diff --git a/create-hardfork/create-hardfork.cpp b/create-hardfork/create-hardfork.cpp
index 5f0b93be..72bffae5 100644
--- a/create-hardfork/create-hardfork.cpp
+++ b/create-hardfork/create-hardfork.cpp
@@ -213,7 +213,7 @@ class HardforkCreator : public td::actor::Actor {
ton::validator::ValidatorManagerHardforkFactory::create(opts, shard_, shard_top_block_id_, db_root_);
for (auto &msg : ext_msgs_) {
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManager::new_external_message,
- std::move(msg));
+ std::move(msg), 0);
}
for (auto &topmsg : top_shard_descrs_) {
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManager::new_shard_block, ton::BlockIdExt{},
@@ -236,9 +236,8 @@ class HardforkCreator : public td::actor::Actor {
td::actor::send_closure(id_, &ton::validator::ValidatorManager::sync_complete,
td::PromiseCreator::lambda([](td::Unit) {}));
}
- void add_shard(ton::ShardIdFull) override {
- }
- void del_shard(ton::ShardIdFull) override {
+ void on_new_masterchain_block(td::Ref state,
+ std::set shards_to_monitor) override {
}
void send_ihr_message(ton::AccountIdPrefixFull dst, td::BufferSlice data) override {
}
@@ -246,7 +245,10 @@ class HardforkCreator : public td::actor::Actor {
}
void send_shard_block_info(ton::BlockIdExt block_id, ton::CatchainSeqno cc_seqno, td::BufferSlice data) override {
}
- void send_broadcast(ton::BlockBroadcast broadcast) override {
+ void send_block_candidate(ton::BlockIdExt block_id, ton::CatchainSeqno cc_seqno, td::uint32 validator_set_hash,
+ td::BufferSlice data) override {
+ }
+ void send_broadcast(ton::BlockBroadcast broadcast, int mode) override {
}
void download_block(ton::BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
td::Promise promise) override {
@@ -267,13 +269,19 @@ class HardforkCreator : public td::actor::Actor {
void get_next_key_blocks(ton::BlockIdExt block_id, td::Timestamp timeout,
td::Promise> promise) override {
}
- void download_archive(ton::BlockSeqno masterchain_seqno, std::string tmp_dir, td::Timestamp timeout,
-
- td::Promise promise) override {
+ void download_archive(ton::BlockSeqno masterchain_seqno, ton::ShardIdFull shard_prefix, std::string tmp_dir,
+ td::Timestamp timeout, td::Promise promise) override {
+ }
+ void download_out_msg_queue_proof(
+ ton::ShardIdFull dst_shard, std::vector blocks, block::ImportedMsgQueueLimits limits,
+ td::Timestamp timeout, td::Promise>> promise) override {
}
void new_key_block(ton::validator::BlockHandle handle) override {
}
+ void send_validator_telemetry(ton::PublicKeyHash key,
+ ton::tl_object_ptr telemetry) override {
+ }
};
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::install_callback,
diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt
index 62b0d216..06908338 100644
--- a/crypto/CMakeLists.txt
+++ b/crypto/CMakeLists.txt
@@ -151,6 +151,7 @@ set(TON_DB_SOURCE
vm/db/CellHashTable.h
vm/db/CellStorage.h
vm/db/TonDb.h
+ vm/db/InMemoryBagOfCellsDb.cpp
)
set(FIFT_SOURCE
@@ -213,6 +214,7 @@ set(BLOCK_SOURCE
block/mc-config.cpp
block/output-queue-merger.cpp
block/transaction.cpp
+ block/precompiled-smc/PrecompiledSmartContract.cpp
${TLB_BLOCK_AUTO}
block/block-binlog.h
@@ -223,6 +225,8 @@ set(BLOCK_SOURCE
block/check-proof.h
block/output-queue-merger.h
block/transaction.h
+ block/precompiled-smc/PrecompiledSmartContract.h
+ block/precompiled-smc/common.h
)
set(SMC_ENVELOPE_SOURCE
@@ -297,9 +301,8 @@ endif()
target_include_directories(ton_crypto_core SYSTEM PUBLIC $)
add_library(ton_crypto STATIC ${TON_CRYPTO_SOURCE})
-target_include_directories(ton_crypto PUBLIC $
- $)
-target_link_libraries(ton_crypto PUBLIC ${OPENSSL_CRYPTO_LIBRARY} tdutils tddb_utils ton_crypto_core ton_block)
+target_include_directories(ton_crypto PUBLIC $ $)
+target_link_libraries(ton_crypto PUBLIC ${OPENSSL_CRYPTO_LIBRARY} ton_crypto_core ton_block)
if (USE_EMSCRIPTEN)
target_link_options(ton_crypto PRIVATE -fexceptions)
target_compile_options(ton_crypto PRIVATE -fexceptions)
@@ -315,33 +318,30 @@ endif()
target_include_directories(ton_crypto SYSTEM PUBLIC $)
add_dependencies(ton_crypto blst)
+add_dependencies(ton_crypto_core secp256k1)
+
target_include_directories(ton_crypto PRIVATE ${BLST_INCLUDE_DIR})
target_link_libraries(ton_crypto PRIVATE ${BLST_LIB})
-if (NOT USE_EMSCRIPTEN)
- find_package(Secp256k1 REQUIRED)
-endif()
+target_include_directories(ton_crypto_core PUBLIC $)
if (MSVC)
find_package(Sodium REQUIRED)
target_compile_definitions(ton_crypto PUBLIC SODIUM_STATIC)
- target_include_directories(ton_crypto_core PUBLIC $)
- target_link_libraries(ton_crypto PUBLIC ${SECP256K1_LIBRARIES})
-elseif (ANDROID)
- target_include_directories(ton_crypto_core PUBLIC $)
+ target_link_libraries(ton_crypto_core PUBLIC ${SECP256K1_LIBRARY})
+ target_link_libraries(ton_crypto PUBLIC ${SECP256K1_LIBRARY})
+elseif (EMSCRIPTEN)
+ target_link_libraries(ton_crypto_core PUBLIC $)
target_link_libraries(ton_crypto PUBLIC $)
else()
- if (NOT USE_EMSCRIPTEN)
+ if (NOT SODIUM_FOUND)
find_package(Sodium REQUIRED)
- target_include_directories(ton_crypto_core PUBLIC $)
- target_link_libraries(ton_crypto PUBLIC ${SECP256K1_LIBRARIES})
else()
- target_include_directories(ton_crypto_core PUBLIC $)
- target_link_libraries(ton_crypto PUBLIC ${SECP256K1_LIBRARY})
- endif()
- if (NOT APPLE AND NOT USE_EMSCRIPTEN)
- target_link_libraries(ton_crypto_core PUBLIC secp256k1)
+ message(STATUS "Using Sodium ${SODIUM_LIBRARY_RELEASE}")
endif()
+ target_compile_definitions(ton_crypto PUBLIC SODIUM_STATIC)
+ target_link_libraries(ton_crypto_core PUBLIC ${SECP256K1_LIBRARY})
+ target_link_libraries(ton_crypto PUBLIC ${SECP256K1_LIBRARY})
endif()
target_include_directories(ton_crypto_core PUBLIC $)
@@ -356,9 +356,10 @@ add_executable(test-ed25519-crypto test/test-ed25519-crypto.cpp)
target_include_directories(test-ed25519-crypto PUBLIC $)
target_link_libraries(test-ed25519-crypto PUBLIC ton_crypto)
-add_library(fift-lib ${FIFT_SOURCE})
+add_library(fift-lib STATIC ${FIFT_SOURCE})
target_include_directories(fift-lib PUBLIC $ |
|---|
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+ 
+