fix after rebase

src/lmdb/msgpack_table.h

@@ -37,7 +37,10 @@ namespace lmdb
     {
       epee::byte_stream initial;
       initial.write({reinterpret_cast<const char*>(std::addressof(val1)), sizeof(val1)});
-      return wire_write::to_bytes(wire::msgpack_slice_writer{std::move(initial), true}, val2);
+
+      wire::msgpack_slice_writer dest{std::move(initial), true};
+      wire_write::bytes(dest, val2);
+      return epee::byte_slice{dest.take_sink()};
     }
 
     /*!
@@ -76,10 +79,12 @@ namespace lmdb
 
       auto msgpack_bytes = lmdb::to_byte_span(value);
       msgpack_bytes.remove_prefix(sizeof(out.first));
-      auto msgpack = wire::msgpack::from_bytes<msgpack_value_type>(epee::byte_slice{{msgpack_bytes}});
-      if (!msgpack)
-        return msgpack.error();
-      out.second = std::move(*msgpack);
+
+      msgpack_value_type second{};
+      const std::error_code error = wire::msgpack::from_bytes(epee::byte_slice{{msgpack_bytes}}, second);
+      if (error)
+        return error;
+      out.second = std::move(second);
 
       return out;
     }

src/rest_server.cpp

@@ -708,11 +708,11 @@ namespace lws
 
       if (!disable_auth)
       {
-        if (!req->auth)
+        if (!req.auth)
           return {error::account_not_found};
 
         db::account_address address{};
-        if (!crypto::secret_key_to_public_key(req.auth, address.view_public))
+        if (!crypto::secret_key_to_public_key(*(req.auth), address.view_public))
           return {error::crypto_failure};
 
         auto reader = disk.start_read();
@@ -728,7 +728,7 @@ namespace lws
       }
 
       wire::json_slice_writer dest{};
-      MONERO_CHECK(E{}(dest, std::move(disk), req.params));
+      MONERO_CHECK(E{}(dest, std::move(disk), std::move(req.params)));
       return epee::byte_slice{dest.take_sink()};
     }
 

src/scanner.cpp

@@ -158,9 +158,15 @@ namespace lws
       if (uri.empty())
         uri = "/";
 
+      epee::byte_slice bytes{};
       const std::string& url = event.value.second.url;
-      const epee::byte_slice bytes = wire::json::to_bytes(event);
+      const std::error_code json_error = wire::json::to_bytes(bytes, event);
       const net::http::http_response_info* info = nullptr;
+      if (json_error)
+      {
+        MERROR("Failed to generate webhook JSON: " << json_error.message());
+        return;
+      }
 
       MINFO("Sending webhook to " << url);
       if (!client.invoke(uri, "POST", std::string{bytes.begin(), bytes.end()}, timeout, std::addressof(info), params))

src/wire/crypto.h

@@ -47,6 +47,7 @@ namespace wire
 {
   WIRE_DECLARE_BLOB(crypto::ec_scalar);
   WIRE_DECLARE_BLOB(crypto::hash);
+  WIRE_DECLARE_BLOB(crypto::hash8);
   WIRE_DECLARE_BLOB(crypto::key_derivation);
   WIRE_DECLARE_BLOB(crypto::key_image);
   WIRE_DECLARE_BLOB(crypto::public_key);

src/wire/field.h

@@ -114,10 +114,6 @@ namespace wire
     static constexpr std::size_t count() noexcept { return 1; }
     static constexpr unsigned id() noexcept { return I; }
 
-    //! \return True if field is forced optional when `get_value().empty()`.
-    static constexpr bool optional_on_empty() noexcept
-    { return is_optional_on_empty<value_type>::value; }
-
     const char* name;
     T value;
 

src/wire/read.h

@@ -288,24 +288,6 @@ namespace wire_read
     dest.get_value().reset();
   }
 
-  template<typename T, bool Required, typename... U>
-  inline void reset_field(wire::variant_field_<T, Required, U...>& dest)
-  {}
-
-  template<typename T, unsigned I>
-  inline void reset_field(wire::field_<T, true, I>& dest)
-  {
-    // array fields are always optional, see `wire/field.h`
-    if (dest.optional_on_empty())
-      wire::clear(dest.get_value());
-  }
-
-  template<typename T, unsigned I>
-  inline void reset_field(wire::field_<T, false, I>& dest)
-  {
-    dest.get_value().reset();
-  }
-
   template<typename R, typename T, unsigned I>
   inline void unpack_field(std::size_t, R& source, wire::field_<T, true, I>& dest)
   {

tests/unit/rpc/admin.test.cpp

@@ -46,12 +46,13 @@ namespace
   expect<epee::byte_slice> call_endpoint(lws::db::storage disk, std::string json)
   {
     using request_type = typename T::request;
-    expect<request_type> req = wire::json::from_bytes<request_type>(std::move(json));
-    if (!req)
-      return req.error();
+    request_type req{};
+    const std::error_code error = wire::json::from_bytes(std::move(json), req);
+    if (error)
+      return error;
     wire::json_slice_writer out{};
-    MONERO_CHECK(T{}(out, std::move(disk), std::move(*req)));
-    return out.take_bytes();
+    MONERO_CHECK(T{}(out, std::move(disk), std::move(req)));
+    return epee::byte_slice{out.take_sink()};
   }
 }
 
@@ -138,7 +139,7 @@ LWS_CASE("rpc::admin")
     {
       wire::json_slice_writer out{};
       EXPECT(lws::rpc::webhook_list(out, db.clone()));
-      expect<epee::byte_slice> bytes = out.take_bytes();
+      expect<epee::byte_slice> bytes = epee::byte_slice{out.take_sink()};
       EXPECT(!bytes.has_error());
 
       {