Fix errors that will surface due to header reordering in the next commit

Author: DanShaders

crypto/block/block-binlog.h

@@ -17,11 +17,12 @@
     Copyright 2017-2020 Telegram Systems LLP
 */
 #pragma once
-#include "td/utils/int_types.h"
-#include "ton/ton-types.h"
 
 #include <ctime>
 
+#include "td/utils/as.h"
+#include "ton/ton-types.h"
+
 namespace block {
 
 namespace log {
@@ -35,9 +36,9 @@ struct Start {
   unsigned type_field;
   unsigned created_at;
   unsigned char zerostate_root_hash[32];
-  Start(const RootHash& hash, unsigned _now = 0)
+  Start(const ton::RootHash& hash, unsigned _now = 0)
       : tag_field(tag), type_field(log_type), created_at(_now ? _now : (unsigned)std::time(nullptr)) {
-    td::as<RootHash>(zerostate_root_hash) = hash;
+    td::as<ton::RootHash>(zerostate_root_hash) = hash;
   }
 };
 
@@ -48,10 +49,10 @@ struct SetZeroState {
   long long file_size;
   unsigned char file_hash[32];
   unsigned char root_hash[32];
-  SetZeroState(const RootHash& rhash, const FileHash& fhash, unsigned long long _fsize, unsigned _flags = 0)
+  SetZeroState(const ton::RootHash& rhash, const ton::FileHash& fhash, unsigned long long _fsize, unsigned _flags = 0)
       : tag_field(tag), flags(_flags), file_size(_fsize) {
-    td::as<FileHash>(file_hash) = fhash;
-    td::as<RootHash>(root_hash) = rhash;
+    td::as<ton::FileHash>(file_hash) = fhash;
+    td::as<ton::RootHash>(root_hash) = rhash;
   }
 };
 
@@ -66,16 +67,16 @@ struct NewBlock {
   unsigned char file_hash[32];
   unsigned char root_hash[32];
   unsigned char last_bytes[8];
-  NewBlock(const ton::BlockId& block, const RootHash& rhash, const FileHash& fhash, unsigned long long _fsize,
+  NewBlock(const ton::BlockId& block, const ton::RootHash& rhash, const ton::FileHash& fhash, unsigned long long _fsize,
            unsigned _flags)
       : tag_field(tag)
       , flags(_flags)
       , workchain(block.workchain)
       , seqno(block.seqno)
       , shard(block.shard)
       , file_size(_fsize) {
-    td::as<FileHash>(file_hash) = fhash;
-    td::as<RootHash>(root_hash) = rhash;
+    td::as<ton::FileHash>(file_hash) = fhash;
+    td::as<ton::RootHash>(root_hash) = rhash;
     td::as<unsigned long long>(last_bytes) = 0;
   }
 };
@@ -91,16 +92,16 @@ struct NewState {
   unsigned char file_hash[32];
   unsigned char root_hash[32];
   unsigned char last_bytes[8];
-  NewState(const ton::BlockId& state, const RootHash& rhash, const FileHash& fhash, unsigned long long _fsize,
+  NewState(const ton::BlockId& state, const ton::RootHash& rhash, const ton::FileHash& fhash, unsigned long long _fsize,
            unsigned _flags)
       : tag_field(tag)
       , flags(_flags)
       , workchain(state.workchain)
       , seqno(state.seqno)
       , shard(state.shard)
       , file_size(_fsize) {
-    td::as<FileHash>(file_hash) = fhash;
-    td::as<RootHash>(root_hash) = rhash;
+    td::as<ton::FileHash>(file_hash) = fhash;
+    td::as<ton::RootHash>(root_hash) = rhash;
     td::as<unsigned long long>(last_bytes) = 0;
   }
 };

crypto/common/AtomicRef.h

@@ -18,11 +18,12 @@
 */
 #pragma once
 
-#include "td/utils/SpinLock.h"
-#include "common/refcnt.hpp"
-
+#include <limits>
 #include <type_traits>
 
+#include "common/refcnt.hpp"
+#include "td/utils/SpinLock.h"
+
 namespace td {
 template <class T>
 class AtomicRefSpinlock {

crypto/common/util.cpp

@@ -163,7 +163,7 @@ std::size_t buff_base64_decode(td::MutableSlice buffer, td::Slice encoded, bool
   return wptr - (unsigned char *)buffer.data();
 }
 
-td::BufferSlice base64_decode(td::Slice encoded, bool allow_base64_url) {
+td::BufferSlice base64_decode_to_buffer_slice(td::Slice encoded, bool allow_base64_url) {
   auto s = decoded_base64_size(encoded, allow_base64_url);
   if (s <= 0) {
     return td::BufferSlice{};

crypto/common/util.h

@@ -34,7 +34,7 @@ bool is_valid_base64(td::Slice encoded, bool allow_base64_url = true);
 td::int32 decoded_base64_size(td::Slice encoded, bool allow_base64_url = true);
 
 std::size_t buff_base64_decode(td::MutableSlice buffer, td::Slice data, bool allow_base64_url = true);
-td::BufferSlice base64_decode(td::Slice encoded, bool allow_base64_url = true);
+td::BufferSlice base64_decode_to_buffer_slice(td::Slice encoded, bool allow_base64_url = true);
 std::string str_base64_decode(td::Slice encoded, bool allow_base64_url = true);
 
 //TODO: move it somewhere else

dht/utils/dht-resolve.cpp

@@ -149,7 +149,7 @@ class Resolver : public td::actor::Actor {
 };
 
 td::Result<td::Bits256> parse_bits256(td::Slice s) {
-  td::BufferSlice str = td::base64_decode(s, true);
+  td::BufferSlice str = td::base64_decode_to_buffer_slice(s, true);
   if (str.size() != 32) {
     return td::Status::Error("Invalid bits256");
   }