refactor(bbapi,wsdb): replace remaining msgpack_roundtrip with field-by-field converters

Eliminate the two remaining handler-boundary msgpack_roundtrip sites:

bbapi: add fq2_{to,from}_wire (just c0/c1 bridged via
field_{to,from}_wire<bb::fq>) and use it for bn254_g2_point_{to,from}_wire.
The `detail::msgpack_roundtrip` template is gone.

wsdb: add field-by-field converters for the nested status aggregates:
- db_stats_{to,from}_wire (lmdblib::DBStats)
- tree_db_stats_{to,from}_wire (crypto::merkle_tree::TreeDBStats)
- tree_meta_{to,from}_wire (crypto::merkle_tree::TreeMeta, uses
  fr_{to,from}_wire for `root` / `initialRoot`)
- world_state_db_stats_{to,from}_wire
- world_state_meta_{to,from}_wire
- world_state_status_summary_{to,from}_wire
- world_state_status_full_{to,from}_wire

The 6 wsdb_handlers.cpp call sites swap to the named helpers. The
`msgpack_roundtrip_{to,from}_wire` templates are gone.

Net effect: zero handler-boundary pack-then-unpack. Every wire ↔ domain
crossing in bbapi and wsdb is now an explicit field-by-field walk; field
renames and type drift surface at compile time.

(The unrelated `msgpack_roundtrip` test helper in
serialize/test_helper.hpp stays — it's a serde-equality assertion, not a
type-bridge.)

Author: charlielye

barretenberg/cpp/src/barretenberg/bbapi/bbapi_wire_convert.hpp

@@ -11,15 +11,11 @@
  * aliases) and domain field types (`bb::fr`, `bb::fq`, `uint256_t`, …)
  * share a 32-byte msgpack `bin32` encoding, so the byte-level conversion
  * is a `serialize_to_buffer` / `serialize_from_buffer` call.
- *
- * The one residual `msgpack_roundtrip` usage is inside
- * `bn254_g2_point_{to,from}_wire`: the Fq2 nesting on g2 affine_element
- * makes the manual form genuinely uglier, and the call site is exactly
- * one (`Bn254G2Mul`).
  */
 #include "barretenberg/bbapi/generated/bb_types.hpp"
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/ecc/curves/bn254/fq.hpp"
+#include "barretenberg/ecc/curves/bn254/fq2.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/ecc/curves/secp256k1/secp256k1.hpp"
@@ -33,25 +29,6 @@
 
 namespace bb::bbapi {
 
-// ---------------------------------------------------------------------------
-// Local msgpack roundtrip — only used by bn254_g2_point conversions below,
-// where Fq2 nesting on g2 affine_element makes the manual form intricate
-// enough that a generic pack+unpack pair is the cleanest available bridge.
-// Restricted to a single call site (`Bn254G2Mul`); not exposed for general use.
-// ---------------------------------------------------------------------------
-
-namespace detail {
-template <typename Target, typename Source> inline Target msgpack_roundtrip(const Source& src)
-{
-    msgpack::sbuffer buf;
-    msgpack::pack(buf, src);
-    auto unpacked = msgpack::unpack(buf.data(), buf.size());
-    Target target;
-    unpacked.get().convert(target);
-    return target;
-}
-} // namespace detail
-
 // ---------------------------------------------------------------------------
 // Field element conversions. All field types (bb::fr, bb::fq, grumpkin::fr,
 // grumpkin::fq, secp256k1::*, secp256r1::*) pack as msgpack bin32. Wire `Fr`
@@ -198,14 +175,25 @@ inline bb::g1::affine_element bn254_g1_point_from_wire(const wire::Bn254G1Point&
     return { field_from_wire<bb::fq>(w.x), field_from_wire<bb::fq>(w.y) };
 }
 
+// Fq2 = { c0: bb::fq, c1: bb::fq }; wire field2 = std::array<std::array<uint8_t,32>, 2>.
+inline std::array<std::array<uint8_t, 32>, 2> fq2_to_wire(const bb::fq2& d)
+{
+    return { field_to_wire<bb::fq>(d.c0), field_to_wire<bb::fq>(d.c1) };
+}
+
+inline bb::fq2 fq2_from_wire(const std::array<std::array<uint8_t, 32>, 2>& w)
+{
+    return { field_from_wire<bb::fq>(w[0]), field_from_wire<bb::fq>(w[1]) };
+}
+
 inline wire::Bn254G2Point bn254_g2_point_to_wire(const bb::g2::affine_element& d)
 {
-    return detail::msgpack_roundtrip<wire::Bn254G2Point>(d);
+    return { .x = fq2_to_wire(d.x), .y = fq2_to_wire(d.y) };
 }
 
 inline bb::g2::affine_element bn254_g2_point_from_wire(const wire::Bn254G2Point& w)
 {
-    return detail::msgpack_roundtrip<bb::g2::affine_element>(w);
+    return { fq2_from_wire(w.x), fq2_from_wire(w.y) };
 }
 
 inline wire::Secp256k1Point secp256k1_point_to_wire(const secp256k1::g1::affine_element& d)

barretenberg/cpp/src/barretenberg/wsdb/wsdb_handlers.cpp

@@ -354,7 +354,7 @@ wire::WsdbCommitResponse handle_commit(WsdbRequest& ctx, wire::WsdbCommit&&)
     WorldStateStatusFull status;
     ctx.world_state.commit(status);
     return wire::WsdbCommitResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusFull>(status),
+        .status = world_state_status_full_to_wire(status),
     };
 }
 
@@ -394,7 +394,7 @@ wire::WsdbSyncBlockResponse handle_sync_block(WsdbRequest& ctx, wire::WsdbSyncBl
                                                              padded_nullifiers,
                                                              public_data_writes);
     return wire::WsdbSyncBlockResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusFull>(status),
+        .status = world_state_status_full_to_wire(status),
     };
 }
 
@@ -423,15 +423,15 @@ wire::WsdbFinalizeBlocksResponse handle_finalize_blocks(WsdbRequest& ctx, wire::
 {
     WorldStateStatusSummary status = ctx.world_state.set_finalized_blocks(cmd.toBlockNumber);
     return wire::WsdbFinalizeBlocksResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusSummary>(status),
+        .status = world_state_status_summary_to_wire(status),
     };
 }
 
 wire::WsdbUnwindBlocksResponse handle_unwind_blocks(WsdbRequest& ctx, wire::WsdbUnwindBlocks&& cmd)
 {
     WorldStateStatusFull status = ctx.world_state.unwind_blocks(cmd.toBlockNumber);
     return wire::WsdbUnwindBlocksResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusFull>(status),
+        .status = world_state_status_full_to_wire(status),
     };
 }
 
@@ -440,7 +440,7 @@ wire::WsdbRemoveHistoricalBlocksResponse handle_remove_historical_blocks(WsdbReq
 {
     WorldStateStatusFull status = ctx.world_state.remove_historical_blocks(cmd.toBlockNumber);
     return wire::WsdbRemoveHistoricalBlocksResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusFull>(status),
+        .status = world_state_status_full_to_wire(status),
     };
 }
 
@@ -453,7 +453,7 @@ wire::WsdbGetStatusResponse handle_get_status(WsdbRequest& ctx, wire::WsdbGetSta
     WorldStateStatusSummary status;
     ctx.world_state.get_status_summary(status);
     return wire::WsdbGetStatusResponse{
-        .status = msgpack_roundtrip_to_wire<wire::WorldStateStatusSummary>(status),
+        .status = world_state_status_summary_to_wire(status),
     };
 }
 

barretenberg/cpp/src/barretenberg/wsdb/wsdb_wire_convert.hpp

@@ -3,15 +3,18 @@
  * @file wsdb_wire_convert.hpp
  * @brief Wire <-> domain conversion helpers for the aztec-wsdb service.
  *
- * The codegen-emitted wire types in generated/wsdb_types.hpp are POD-shaped
- * (uint32_t for tree IDs, std::array<uint8_t, 32> for field elements, etc).
- * Domain types come from world_state/, crypto/merkle_tree/, ecc/. This file
- * is the single place that translates between them — used by handlers (server
+ * All conversions are field-by-field. The codegen-emitted wire types in
+ * generated/wsdb_types.hpp are POD-shaped (uint32_t for tree IDs,
+ * std::array<uint8_t, 32> for field elements, etc); domain types come from
+ * world_state/, crypto/merkle_tree/, ecc/, lmdblib/. This file is the
+ * single place that translates between them — used by handlers (server
  * side) and by wsdb_ipc_merkle_db.cpp (AVM client side).
  */
+#include "barretenberg/crypto/merkle_tree/node_store/tree_meta.hpp"
 #include "barretenberg/crypto/merkle_tree/response.hpp"
 #include "barretenberg/crypto/merkle_tree/types.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/lmdblib/types.hpp"
 #include "barretenberg/world_state/types.hpp"
 #include "barretenberg/wsdb/generated/wsdb_types.hpp"
 
@@ -113,33 +116,136 @@ inline world_state::StateReference state_reference_from_wire(
     return r;
 }
 
-// Generic msgpack roundtrip — used only for `WorldStateStatusFull` and
-// `WorldStateStatusSummary`. Both are 4-level nested aggregates (Full →
-// DBStats → TreeDBStats → DBStats, and parallel Meta → TreeMeta with
-// `bb::fr root` fields, fanning out across all 5 trees). Hand-writing
-// field-by-field convertors is ~150 LOC of mechanical boilerplate that
-// would have to track future field additions on the world_state side.
-// The 6 call sites (commit / sync / finalize / unwind / remove_historical
-// / get_status) are all dominated by the merkle-tree work they bracket,
-// so the per-call pack+unpack overhead is not in the critical path.
-template <typename Wire, typename Domain> inline Wire msgpack_roundtrip_to_wire(const Domain& d)
-{
-    msgpack::sbuffer buf;
-    msgpack::pack(buf, d);
-    auto unpacked = msgpack::unpack(buf.data(), buf.size());
-    Wire w;
-    unpacked.get().convert(w);
-    return w;
-}
-
-template <typename Domain, typename Wire> inline Domain msgpack_roundtrip_from_wire(const Wire& w)
-{
-    msgpack::sbuffer buf;
-    msgpack::pack(buf, w);
-    auto unpacked = msgpack::unpack(buf.data(), buf.size());
-    Domain d;
-    unpacked.get().convert(d);
-    return d;
+// World-state status conversions. Field-by-field walk of the
+// WorldStateStatusFull / WorldStateStatusSummary aggregates and their
+// nested DBStats / TreeDBStats / TreeMeta / WorldStateDBStats /
+// WorldStateMeta components. The wire types live in `bb::wsdb::wire`,
+// the domain types in `bb::lmdblib`, `bb::crypto::merkle_tree`,
+// `bb::world_state`.
+
+inline wire::DBStats db_stats_to_wire(const bb::lmdblib::DBStats& d)
+{
+    return { .name = d.name, .numDataItems = d.numDataItems, .totalUsedSize = d.totalUsedSize };
+}
+
+inline bb::lmdblib::DBStats db_stats_from_wire(const wire::DBStats& w)
+{
+    return bb::lmdblib::DBStats(w.name, w.numDataItems, w.totalUsedSize);
+}
+
+inline wire::TreeDBStats tree_db_stats_to_wire(const bb::crypto::merkle_tree::TreeDBStats& d)
+{
+    return { .mapSize = d.mapSize,
+             .physicalFileSize = d.physicalFileSize,
+             .blocksDBStats = db_stats_to_wire(d.blocksDBStats),
+             .nodesDBStats = db_stats_to_wire(d.nodesDBStats),
+             .leafPreimagesDBStats = db_stats_to_wire(d.leafPreimagesDBStats),
+             .leafIndicesDBStats = db_stats_to_wire(d.leafIndicesDBStats),
+             .blockIndicesDBStats = db_stats_to_wire(d.blockIndicesDBStats) };
+}
+
+inline bb::crypto::merkle_tree::TreeDBStats tree_db_stats_from_wire(const wire::TreeDBStats& w)
+{
+    return { w.mapSize,
+             w.physicalFileSize,
+             db_stats_from_wire(w.blocksDBStats),
+             db_stats_from_wire(w.nodesDBStats),
+             db_stats_from_wire(w.leafPreimagesDBStats),
+             db_stats_from_wire(w.leafIndicesDBStats),
+             db_stats_from_wire(w.blockIndicesDBStats) };
+}
+
+inline wire::TreeMeta tree_meta_to_wire(const bb::crypto::merkle_tree::TreeMeta& d)
+{
+    return { .name = d.name,
+             .depth = d.depth,
+             .size = d.size,
+             .committedSize = d.committedSize,
+             .root = fr_to_wire(d.root),
+             .initialSize = d.initialSize,
+             .initialRoot = fr_to_wire(d.initialRoot),
+             .oldestHistoricBlock = d.oldestHistoricBlock,
+             .unfinalizedBlockHeight = d.unfinalizedBlockHeight,
+             .finalizedBlockHeight = d.finalizedBlockHeight };
+}
+
+inline bb::crypto::merkle_tree::TreeMeta tree_meta_from_wire(const wire::TreeMeta& w)
+{
+    return { w.name,
+             w.depth,
+             w.size,
+             w.committedSize,
+             fr_from_wire(w.root),
+             w.initialSize,
+             fr_from_wire(w.initialRoot),
+             w.oldestHistoricBlock,
+             w.unfinalizedBlockHeight,
+             w.finalizedBlockHeight };
+}
+
+inline wire::WorldStateDBStats world_state_db_stats_to_wire(const bb::world_state::WorldStateDBStats& d)
+{
+    return { .noteHashTreeStats = tree_db_stats_to_wire(d.noteHashTreeStats),
+             .messageTreeStats = tree_db_stats_to_wire(d.messageTreeStats),
+             .archiveTreeStats = tree_db_stats_to_wire(d.archiveTreeStats),
+             .publicDataTreeStats = tree_db_stats_to_wire(d.publicDataTreeStats),
+             .nullifierTreeStats = tree_db_stats_to_wire(d.nullifierTreeStats) };
+}
+
+inline bb::world_state::WorldStateDBStats world_state_db_stats_from_wire(const wire::WorldStateDBStats& w)
+{
+    return { tree_db_stats_from_wire(w.noteHashTreeStats),
+             tree_db_stats_from_wire(w.messageTreeStats),
+             tree_db_stats_from_wire(w.archiveTreeStats),
+             tree_db_stats_from_wire(w.publicDataTreeStats),
+             tree_db_stats_from_wire(w.nullifierTreeStats) };
+}
+
+inline wire::WorldStateMeta world_state_meta_to_wire(const bb::world_state::WorldStateMeta& d)
+{
+    return { .noteHashTreeMeta = tree_meta_to_wire(d.noteHashTreeMeta),
+             .messageTreeMeta = tree_meta_to_wire(d.messageTreeMeta),
+             .archiveTreeMeta = tree_meta_to_wire(d.archiveTreeMeta),
+             .publicDataTreeMeta = tree_meta_to_wire(d.publicDataTreeMeta),
+             .nullifierTreeMeta = tree_meta_to_wire(d.nullifierTreeMeta) };
+}
+
+inline bb::world_state::WorldStateMeta world_state_meta_from_wire(const wire::WorldStateMeta& w)
+{
+    return { tree_meta_from_wire(w.noteHashTreeMeta),
+             tree_meta_from_wire(w.messageTreeMeta),
+             tree_meta_from_wire(w.archiveTreeMeta),
+             tree_meta_from_wire(w.publicDataTreeMeta),
+             tree_meta_from_wire(w.nullifierTreeMeta) };
+}
+
+inline wire::WorldStateStatusSummary world_state_status_summary_to_wire(
+    const bb::world_state::WorldStateStatusSummary& d)
+{
+    return { .unfinalizedBlockNumber = d.unfinalizedBlockNumber,
+             .finalizedBlockNumber = d.finalizedBlockNumber,
+             .oldestHistoricalBlock = d.oldestHistoricalBlock,
+             .treesAreSynched = d.treesAreSynched };
+}
+
+inline bb::world_state::WorldStateStatusSummary world_state_status_summary_from_wire(
+    const wire::WorldStateStatusSummary& w)
+{
+    return { w.unfinalizedBlockNumber, w.finalizedBlockNumber, w.oldestHistoricalBlock, w.treesAreSynched };
+}
+
+inline wire::WorldStateStatusFull world_state_status_full_to_wire(const bb::world_state::WorldStateStatusFull& d)
+{
+    return { .summary = world_state_status_summary_to_wire(d.summary),
+             .dbStats = world_state_db_stats_to_wire(d.dbStats),
+             .meta = world_state_meta_to_wire(d.meta) };
+}
+
+inline bb::world_state::WorldStateStatusFull world_state_status_full_from_wire(const wire::WorldStateStatusFull& w)
+{
+    return { world_state_status_summary_from_wire(w.summary),
+             world_state_db_stats_from_wire(w.dbStats),
+             world_state_meta_from_wire(w.meta) };
 }
 
 } // namespace bb::wsdb