updated vm (breaking compatibility)

- updated vm
- new actor scheduler
- updated tonlib
- updated DNS smartcontract

crypto/smc-envelope/ManualDns.cpp

@@ -146,6 +146,23 @@ td::Result<DnsInterface::EntryData> DnsInterface::EntryData::from_cellslice(vm::
   return td::Status::Error("Unknown entry data");
 }
 
+SmartContract::Args DnsInterface::resolve_args_raw(td::Slice encoded_name, td::int16 category) {
+  SmartContract::Args res;
+  res.set_method_id("dnsresolve");
+  res.set_stack(
+      {vm::load_cell_slice_ref(vm::CellBuilder().store_bytes(encoded_name).finalize()), td::make_refint(category)});
+  return res;
+}
+
+td::Result<SmartContract::Args> DnsInterface::resolve_args(td::Slice name, td::int32 category_big) {
+  TRY_RESULT(category, td::narrow_cast_safe<td::int16>(category_big));
+  if (name.size() > get_default_max_name_size()) {
+    return td::Status::Error("Name is too long");
+  }
+  auto encoded_name = encode_name(name);
+  return resolve_args_raw(encoded_name, category);
+}
+
 td::Result<std::vector<DnsInterface::Entry>> DnsInterface::resolve(td::Slice name, td::int32 category) const {
   TRY_RESULT(raw_entries, resolve_raw(name, category));
   std::vector<Entry> entries;
@@ -375,7 +392,7 @@ td::Ref<vm::Cell> ManualDns::create_init_data_fast(const td::Ed25519::PublicKey&
 }
 
 size_t ManualDns::get_max_name_size() const {
-  return 128;
+  return get_default_max_name_size();
 }
 
 td::Result<std::vector<ManualDns::RawEntry>> ManualDns::resolve_raw(td::Slice name, td::int32 category_big) const {
@@ -388,9 +405,7 @@ td::Result<std::vector<ManualDns::RawEntry>> ManualDns::resolve_raw_or_throw(td:
     return td::Status::Error("Name is too long");
   }
   auto encoded_name = encode_name(name);
-  auto res = run_get_method(
-      "dnsresolve",
-      {vm::load_cell_slice_ref(vm::CellBuilder().store_bytes(encoded_name).finalize()), td::make_refint(category)});
+  auto res = run_get_method(resolve_args_raw(encoded_name, category));
   if (!res.success) {
     return td::Status::Error("get method failed");
   }
@@ -471,7 +486,7 @@ td::Result<td::Ref<vm::Cell>> ManualDns::create_update_query(td::Ed25519::Privat
   return sign(pk, std::move(prepared));
 }
 
-std::string ManualDns::encode_name(td::Slice name) {
+std::string DnsInterface::encode_name(td::Slice name) {
   std::string res;
   while (!name.empty()) {
     auto pos = name.rfind('.');
@@ -487,7 +502,7 @@ std::string ManualDns::encode_name(td::Slice name) {
   return res;
 }
 
-std::string ManualDns::decode_name(td::Slice name) {
+std::string DnsInterface::decode_name(td::Slice name) {
   std::string res;
   if (!name.empty() && name.back() == 0) {
     name.remove_suffix(1);

crypto/smc-envelope/ManualDns.h

@@ -165,6 +165,15 @@ class DnsInterface {
       td::uint32 valid_until = std::numeric_limits<td::uint32>::max()) const = 0;
 
   td::Result<std::vector<Entry>> resolve(td::Slice name, td::int32 category) const;
+
+  static std::string encode_name(td::Slice name);
+  static std::string decode_name(td::Slice name);
+
+  static size_t get_default_max_name_size() {
+    return 128;
+  }
+  static SmartContract::Args resolve_args_raw(td::Slice encoded_name, td::int16 category);
+  static td::Result<SmartContract::Args> resolve_args(td::Slice name, td::int32 category);
 };
 
 class ManualDns : public ton::SmartContract, public DnsInterface {
@@ -223,9 +232,6 @@ class ManualDns : public ton::SmartContract, public DnsInterface {
       td::Ed25519::PrivateKey& pk, td::Span<Action> actions,
       td::uint32 valid_until = std::numeric_limits<td::uint32>::max()) const override;
 
-  static std::string encode_name(td::Slice name);
-  static std::string decode_name(td::Slice name);
-
   template <class ActionT>
   struct CombinedActions {
     std::string name;

crypto/smc-envelope/MultisigWallet.cpp

@@ -1,3 +1,21 @@
+/*
+    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 2019-2020 Telegram Systems LLP
+*/
 #include "MultisigWallet.h"
 
 #include "SmartContractCode.h"

crypto/smc-envelope/MultisigWallet.h

@@ -1,3 +1,21 @@
+/*
+    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 2019-2020 Telegram Systems LLP
+*/
 #pragma once
 #include "vm/cells.h"
 

crypto/smc-envelope/SmartContract.cpp

@@ -24,19 +24,21 @@
 #include "block/block-auto.h"
 #include "vm/cellslice.h"
 #include "vm/cp0.h"
+#include "vm/memo.h"
 #include "vm/vm.h"
 
 #include "td/utils/crypto.h"
 
 namespace ton {
 namespace {
+
 td::Ref<vm::Stack> prepare_vm_stack(td::Ref<vm::CellSlice> body) {
   td::Ref<vm::Stack> stack_ref{true};
   td::RefInt256 acc_addr{true};
   //CHECK(acc_addr.write().import_bits(account.addr.cbits(), 256));
   vm::Stack& stack = stack_ref.write();
-  stack.push_int(td::RefInt256{true, 10000000000});
-  stack.push_int(td::RefInt256{true, 10000000000});
+  stack.push_int(td::make_refint(10000000000));
+  stack.push_int(td::make_refint(10000000000));
   stack.push_cell(vm::CellBuilder().finalize());
   stack.push_cellslice(std::move(body));
   return stack_ref;
@@ -90,6 +92,11 @@ SmartContract::Answer run_smartcont(SmartContract::State state, td::Ref<vm::Stac
   }
 
   SmartContract::Answer res;
+  if (GET_VERBOSITY_LEVEL() >= VERBOSITY_NAME(DEBUG)) {
+    std::ostringstream os;
+    stack->dump(os, 2);
+    LOG(DEBUG) << "VM stack:\n" << os.str();
+  }
   vm::VmState vm{state.code, std::move(stack), gas, 1, state.data, log};
   vm.set_c7(std::move(c7));
   vm.set_chksig_always_succeed(ignore_chksig);
@@ -124,6 +131,21 @@ SmartContract::Answer run_smartcont(SmartContract::State state, td::Ref<vm::Stac
 }
 }  // namespace
 
+td::Result<td::BufferSlice> SmartContract::Args::get_serialized_stack() {
+  if (!stack) {
+    return td::Status::Error("Args has no stack");
+  }
+  vm::FakeVmStateLimits fstate(1000);  // limit recursive (de)serialization calls
+  vm::VmStateInterface::Guard guard(&fstate);
+  // serialize parameters
+  vm::CellBuilder cb;
+  td::Ref<vm::Cell> cell;
+  if (!(stack.value()->serialize(cb) && cb.finalize_to(cell))) {
+    return td::Status::Error("Cannot serialize stack in args");
+  }
+  return vm::std_boc_serialize(std::move(cell));
+}
+
 td::Ref<vm::CellSlice> SmartContract::empty_slice() {
   return vm::load_cell_slice_ref(vm::CellBuilder().finalize());
 }

crypto/smc-envelope/SmartContract.h

@@ -90,6 +90,14 @@ class SmartContract : public td::CntObject {
       this->ignore_chksig = ignore_chksig;
       return std::move(*this);
     }
+
+    td::Result<td::int32> get_method_id() const {
+      if (!method_id) {
+        return td::Status::Error("Args has no method id");
+      }
+      return method_id.value();
+    }
+    td::Result<td::BufferSlice> get_serialized_stack();
   };
 
   Answer run_method(Args args = {});

crypto/smc-envelope/SmartContractCode.cpp

@@ -25,12 +25,12 @@
 
 namespace ton {
 namespace {
-constexpr static int WALLET_REVISION = 2;
-constexpr static int WALLET2_REVISION = 2;
-constexpr static int WALLET3_REVISION = 2;
-constexpr static int HIGHLOAD_WALLET_REVISION = 2;
-constexpr static int HIGHLOAD_WALLET2_REVISION = 2;
-constexpr static int DNS_REVISION = 1;
+// WALLET_REVISION = 2;
+// WALLET2_REVISION = 2;
+// WALLET3_REVISION = 2;
+// HIGHLOAD_WALLET_REVISION = 2;
+// HIGHLOAD_WALLET2_REVISION = 2;
+// DNS_REVISION = 1;
 const auto& get_map() {
   static auto map = [] {
     std::map<std::string, td::Ref<vm::Cell>, std::less<>> map;

crypto/smc-envelope/WalletInterface.h

@@ -31,8 +31,11 @@ class WalletInterface {
   struct Gift {
     block::StdAddress destination;
     td::int64 gramms;
+
     bool is_encrypted{false};
     std::string message;
+
+    td::Ref<vm::Cell> body;
   };
 
   virtual ~WalletInterface() {
@@ -50,6 +53,13 @@ class WalletInterface {
     return make_a_gift_message(private_key, valid_until, {});
   }
   static void store_gift_message(vm::CellBuilder &cb, const Gift &gift) {
+    if (gift.body.not_null()) {
+      auto body = vm::load_cell_slice(gift.body);
+      //TODO: handle error
+      cb.append_cellslice_bool(body);
+      return;
+    }
+
     if (gift.is_encrypted) {
       cb.store_long(1, 32);
     } else {