refactor: extract FFI memory adapters into separate cbmpc/ffi module

CMakeLists.txt

@@ -90,10 +90,12 @@ add_subdirectory(src/cbmpc/core)
 add_subdirectory(src/cbmpc/crypto)
 add_subdirectory(src/cbmpc/zk)
 add_subdirectory(src/cbmpc/protocol)
+add_subdirectory(src/cbmpc/ffi)
 
 add_library(
   cbmpc STATIC $<TARGET_OBJECTS:cbmpc_core> $<TARGET_OBJECTS:cbmpc_crypto>
-               $<TARGET_OBJECTS:cbmpc_zk> $<TARGET_OBJECTS:cbmpc_protocol>)
+               $<TARGET_OBJECTS:cbmpc_zk> $<TARGET_OBJECTS:cbmpc_protocol>
+               $<TARGET_OBJECTS:cbmpc_ffi>)
 
 link_openssl(cbmpc)
 

demos-go/cb-mpc-go/internal/cgobinding/ac.cpp

@@ -1,6 +1,7 @@
 #include "ac.h"
 
 #include <cbmpc/core/buf.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 #include <cbmpc/crypto/secret_sharing.h>
 
 using namespace coinbase;
@@ -14,7 +15,7 @@ extern "C" {
 
 // ============ PVE (Access Structure) utilities ================
 crypto_ss_node_ref new_node(int node_type, cmem_t node_name, int threshold) {
-  std::string name = mem_t(node_name).to_string();
+  std::string name = coinbase::ffi::view(node_name).to_string();
   node_t* node = new node_t(node_e(node_type), name, threshold);
   return crypto_ss_node_ref{node};
 }

demos-go/cb-mpc-go/internal/cgobinding/agree_random.cpp

@@ -5,6 +5,7 @@
 #include <cbmpc/crypto/base.h>
 #include <cbmpc/protocol/agree_random.h>
 #include <cbmpc/protocol/mpc_job_session.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 using namespace coinbase;
 using namespace coinbase::mpc;
@@ -35,7 +36,7 @@ int mpc_agree_random(job_2p_ref* job, int bit_len, cmem_t* out) {
 
     if (err) return static_cast<int>(err);
 
-    *out = out_buf.to_cmem();
+    *out = coinbase::ffi::copy_to_cmem(out_buf);
     return SUCCESS_CODE;
 
   } catch (const std::exception& e) {

demos-go/cb-mpc-go/internal/cgobinding/curve.cpp

@@ -4,6 +4,7 @@
 
 #include <cbmpc/core/buf.h>
 #include <cbmpc/crypto/base.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 using namespace coinbase;
 using namespace coinbase::crypto;
@@ -40,7 +41,7 @@ cmem_t ecurve_order(ecurve_ref* curve) {
   ecurve_t* curve_obj = static_cast<ecurve_t*>(curve->opaque);
   bn_t order = curve_obj->order();
   buf_t order_buf = order.to_bin();
-  return order_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(order_buf);
 }
 
 int ecurve_get_curve_code(ecurve_ref* curve) {
@@ -50,7 +51,7 @@ int ecurve_get_curve_code(ecurve_ref* curve) {
 
 ecc_point_ref ecc_point_from_bytes(cmem_t point_bytes) {
   ecc_point_t* point = new ecc_point_t();
-  error_t err = coinbase::deser(mem_t(point_bytes), *point);
+  error_t err = coinbase::deser(coinbase::ffi::view(point_bytes), *point);
   if (err) {
     delete point;
     return ecc_point_ref{nullptr};
@@ -61,13 +62,13 @@ ecc_point_ref ecc_point_from_bytes(cmem_t point_bytes) {
 cmem_t ecc_point_to_bytes(ecc_point_ref* point) {
   ecc_point_t* point_obj = static_cast<ecc_point_t*>(point->opaque);
   buf_t point_buf = coinbase::ser(*point_obj);
-  return point_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(point_buf);
 }
 
 ecc_point_ref ecc_point_multiply(ecc_point_ref* point, cmem_t scalar) {
   ecc_point_t* point_obj = static_cast<ecc_point_t*>(point->opaque);
   // Use from_bin to convert raw bytes to bn_t
-  bn_t scalar_bn = bn_t::from_bin(mem_t(scalar));
+  bn_t scalar_bn = bn_t::from_bin(coinbase::ffi::view(scalar));
 
   ecc_point_t* result = new ecc_point_t(scalar_bn * (*point_obj));
   return ecc_point_ref{result};
@@ -90,13 +91,13 @@ ecc_point_ref ecc_point_subtract(ecc_point_ref* point1, ecc_point_ref* point2) {
 cmem_t ecc_point_get_x(ecc_point_ref* point) {
   ecc_point_t* point_obj = static_cast<ecc_point_t*>(point->opaque);
   buf_t x_buf = point_obj->get_x().to_bin();
-  return x_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(x_buf);
 }
 
 cmem_t ecc_point_get_y(ecc_point_ref* point) {
   ecc_point_t* point_obj = static_cast<ecc_point_t*>(point->opaque);
   buf_t y_buf = point_obj->get_y().to_bin();
-  return y_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(y_buf);
 }
 
 int ecc_point_is_zero(ecc_point_ref* point) {
@@ -117,16 +118,16 @@ cmem_t ecurve_random_scalar(ecurve_ref* curve) {
   ecurve_t* curve_obj = static_cast<ecurve_t*>(curve->opaque);
   bn_t k = curve_obj->get_random_value();
   buf_t k_buf = k.to_bin(curve_obj->order().get_bin_size());
-  return k_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(k_buf);
 }
 
 int ecc_verify_der(int curve_code, cmem_t pub_oct, cmem_t hash, cmem_t der_sig) {
   ecurve_t curve = ecurve_t::find(curve_code);
   if (!curve) return -1;
   ecc_point_t Q;
-  if (Q.from_oct(curve, mem_t(pub_oct))) return -2;
+  if (Q.from_oct(curve, coinbase::ffi::view(pub_oct))) return -2;
   ecc_pub_key_t pub(Q);
-  error_t rv = pub.verify(mem_t(hash), mem_t(der_sig));
+  error_t rv = pub.verify(coinbase::ffi::view(hash), coinbase::ffi::view(der_sig));
   return rv ? -3 : 0;
 }
 
@@ -137,40 +138,40 @@ int ecc_verify_der(int curve_code, cmem_t pub_oct, cmem_t hash, cmem_t der_sig)
 // implementation from the core library to ensure constant-time behaviour.
 
 cmem_t bn_add(cmem_t a, cmem_t b) {
-  bn_t a_bn = bn_t::from_bin(mem_t(a));
-  bn_t b_bn = bn_t::from_bin(mem_t(b));
+  bn_t a_bn = bn_t::from_bin(coinbase::ffi::view(a));
+  bn_t b_bn = bn_t::from_bin(coinbase::ffi::view(b));
   bn_t c_bn = a_bn + b_bn;
   buf_t c_buf = c_bn.to_bin();
-  return c_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(c_buf);
 }
 
 // Adds two scalars modulo the curve order and returns the result as bytes.
 cmem_t ec_mod_add(ecurve_ref* curve, cmem_t a, cmem_t b) {
   ecurve_t* curve_obj = static_cast<ecurve_t*>(curve->opaque);
   mod_t q = curve_obj->order();
 
-  bn_t a_bn = bn_t::from_bin(mem_t(a));
-  bn_t b_bn = bn_t::from_bin(mem_t(b));
+  bn_t a_bn = bn_t::from_bin(coinbase::ffi::view(a));
+  bn_t b_bn = bn_t::from_bin(coinbase::ffi::view(b));
 
   bn_t c_bn = (a_bn + b_bn) % q;
 
   buf_t c_buf = c_bn.to_bin(q.get_bin_size());
-  return c_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(c_buf);
 }
 
 // Creates a bn_t from an int64 value and returns its byte representation.
 cmem_t bn_from_int64(int64_t value) {
   bn_t bn;
   bn.set_int64(value);
   buf_t bn_buf = bn.to_bin();
-  return bn_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(bn_buf);
 }
 
 // ============ Generator Multiply ================
 
 ecc_point_ref ecurve_mul_generator(ecurve_ref* curve, cmem_t scalar) {
   ecurve_t* curve_obj = static_cast<ecurve_t*>(curve->opaque);
-  bn_t k = bn_t::from_bin(mem_t(scalar));
+  bn_t k = bn_t::from_bin(coinbase::ffi::view(scalar));
   ecc_point_t* result = new ecc_point_t(curve_obj->mul_to_generator(k));
   return ecc_point_ref{result};
 }

demos-go/cb-mpc-go/internal/cgobinding/ecdsa2p.cpp

@@ -6,6 +6,7 @@
 #include <cbmpc/crypto/base.h>
 #include <cbmpc/protocol/ecdsa_2p.h>
 #include <cbmpc/protocol/mpc_job_session.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 #include "curve.h"
 #include "network.h"
@@ -42,7 +43,7 @@ int mpc_ecdsa2p_refresh(job_2p_ref* j, mpc_ecdsa2pc_key_ref* k, mpc_ecdsa2pc_key
 int mpc_ecdsa2p_sign(job_2p_ref* j, cmem_t sid_mem, mpc_ecdsa2pc_key_ref* k, cmems_t msgs, cmems_t* sigs) {
   job_2p_t* job = static_cast<job_2p_t*>(j->opaque);
   ecdsa2pc::key_t* key = static_cast<ecdsa2pc::key_t*>(k->opaque);
-  buf_t sid = mem_t(sid_mem);
+  buf_t sid = coinbase::ffi::view(sid_mem);
   // Reconstruct messages from cmems_t explicitly and copy into owned buffers
   int count = msgs.count;
   std::vector<buf_t> owned_msgs;
@@ -61,7 +62,7 @@ int mpc_ecdsa2p_sign(job_2p_ref* j, cmem_t sid_mem, mpc_ecdsa2pc_key_ref* k, cme
   std::vector<buf_t> signatures;
   error_t err = ecdsa2pc::sign_batch(*job, sid, *key, messages, signatures);
   if (err) return err;
-  *sigs = coinbase::mems_t(signatures).to_cmems();
+  *sigs = coinbase::ffi::copy_to_cmems(buf_t::to_mems(signatures));
 
   return 0;
 }
@@ -100,7 +101,7 @@ cmem_t mpc_ecdsa2p_key_get_x_share(mpc_ecdsa2pc_key_ref* key) {
   // Serialize bn_t to bytes (minimal length) preserving order size
   int bin_size = std::max(k->x_share.get_bin_size(), k->curve.order().get_bin_size());
   buf_t x_buf = k->x_share.to_bin(bin_size);
-  return x_buf.to_cmem();
+  return coinbase::ffi::copy_to_cmem(x_buf);
 }
 
 int mpc_ecdsa2p_key_get_curve_code(mpc_ecdsa2pc_key_ref* key) {

demos-go/cb-mpc-go/internal/cgobinding/ecdsamp.cpp

@@ -7,6 +7,7 @@
 #include <cbmpc/core/buf.h>
 #include <cbmpc/protocol/ecdsa_mp.h>
 #include <cbmpc/protocol/mpc_job_session.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 #include "curve.h"
 #include "network.h"
@@ -22,11 +23,11 @@ int mpc_ecdsampc_sign(job_mp_ref* j, mpc_eckey_mp_ref* k, cmem_t msg_mem, int si
   job_mp_t* job = static_cast<job_mp_t*>(j->opaque);
   ecdsampc::key_t* key = static_cast<ecdsampc::key_t*>(k->opaque);
 
-  buf_t msg = coinbase::mem_t(msg_mem);
+  buf_t msg = coinbase::ffi::view(msg_mem);
   buf_t sig;
   error_t err = ecdsampc::sign(*job, *key, msg, party_idx_t(sig_receiver), sig);
   if (err) return err;
-  *sig_mem = sig.to_cmem();
+  *sig_mem = coinbase::ffi::copy_to_cmem(sig);
   return 0;
 }
 
@@ -35,8 +36,8 @@ int mpc_ecdsampc_sign_with_ot_roles(job_mp_ref* j, mpc_eckey_mp_ref* k, cmem_t m
   job_mp_t* job = static_cast<job_mp_t*>(j->opaque);
   ecdsampc::key_t* key = static_cast<ecdsampc::key_t*>(k->opaque);
 
-  buf_t msg = coinbase::mem_t(msg_mem);
-  std::vector<buf_t> role_bufs = coinbase::mems_t(ot_role_map).bufs();
+  buf_t msg = coinbase::ffi::view(msg_mem);
+  std::vector<buf_t> role_bufs = coinbase::ffi::bufs_from_cmems(ot_role_map);
   std::vector<std::vector<int>> ot_roles(n_parties, std::vector<int>(n_parties));
 
   for (int i = 0; i < n_parties; i++) {
@@ -52,6 +53,6 @@ int mpc_ecdsampc_sign_with_ot_roles(job_mp_ref* j, mpc_eckey_mp_ref* k, cmem_t m
   error_t err = ecdsampc::sign(*job, *key, msg, party_idx_t(sig_receiver), ot_roles, sig);
   if (err) return err;
 
-  *sig_mem = sig.to_cmem();
+  *sig_mem = coinbase::ffi::copy_to_cmem(sig);
   return 0;
 } 

demos-go/cb-mpc-go/internal/cgobinding/eckeymp.cpp

@@ -6,6 +6,7 @@
 #include <cbmpc/crypto/base.h>
 #include <cbmpc/protocol/ec_dkg.h>
 #include <cbmpc/protocol/mpc_job_session.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 #include "curve.h"
 #include "network.h"
@@ -28,7 +29,7 @@ int mpc_eckey_mp_get_party_name(mpc_eckey_mp_ref* k, cmem_t* party_name_mem) {
   }
 
   eckey::key_share_mp_t* key = static_cast<eckey::key_share_mp_t*>(k->opaque);
-  *party_name_mem = coinbase::mem_t(key->party_name).to_cmem();
+  *party_name_mem = coinbase::ffi::copy_to_cmem(coinbase::mem_t(key->party_name));
   return 0;
 }
 
@@ -38,7 +39,7 @@ int mpc_eckey_mp_get_x_share(mpc_eckey_mp_ref* k, cmem_t* x_share_mem) {
   }
   eckey::key_share_mp_t* key = static_cast<eckey::key_share_mp_t*>(k->opaque);
   buf_t x_buf = key->x_share.to_bin(key->curve.order().get_bin_size());
-  *x_share_mem = x_buf.to_cmem();
+  *x_share_mem = coinbase::ffi::copy_to_cmem(x_buf);
   return 0;
 }
 
@@ -77,8 +78,8 @@ int mpc_eckey_mp_get_Qis(mpc_eckey_mp_ref* k, cmems_t* party_names_mem, cmems_t*
     point_bufs.push_back(coinbase::ser(kv.second));
   }
 
-  *party_names_mem = coinbase::mems_t(name_bufs).to_cmems();
-  *points_mem = coinbase::mems_t(point_bufs).to_cmems();
+  *party_names_mem = coinbase::ffi::copy_to_cmems(buf_t::to_mems(name_bufs));
+  *points_mem = coinbase::ffi::copy_to_cmems(buf_t::to_mems(point_bufs));
   return 0;
 }
 
@@ -111,7 +112,7 @@ int mpc_eckey_mp_refresh(job_mp_ref* j, cmem_t sid_mem, mpc_eckey_mp_ref* k, mpc
   // Allocate new key with automatic cleanup on error.
   std::unique_ptr<eckey::key_share_mp_t> new_key(new eckey::key_share_mp_t());
 
-  buf_t sid = coinbase::mem_t(sid_mem);
+  buf_t sid = coinbase::ffi::view(sid_mem);
   error_t err = eckey::key_share_mp_t::refresh(*job, sid, *key, *new_key);
   if (err) {
     return err;  // unique_ptr frees memory
@@ -130,7 +131,7 @@ int eckey_dkg_mp_threshold_dkg(job_mp_ref* job_ptr, ecurve_ref* curve_ref, cmem_
     return 1;  // Invalid curve reference
   }
 
-  buf_t sid_buf = mem_t(sid);
+  buf_t sid_buf = coinbase::ffi::view(sid);
   crypto::ss::ac_t* ac_obj = static_cast<crypto::ss::ac_t*>(ac->opaque);
   party_set_t* quorum_set = static_cast<party_set_t*>(quorum->opaque);
 
@@ -150,7 +151,7 @@ int eckey_key_share_mp_to_additive_share(mpc_eckey_mp_ref* key, crypto_ss_ac_ref
   eckey::key_share_mp_t* key_share = static_cast<eckey::key_share_mp_t*>(key->opaque);
   crypto::ss::ac_t* ac_obj = static_cast<crypto::ss::ac_t*>(ac->opaque);
 
-  std::vector<buf_t> name_bufs = coinbase::mems_t(quorum_party_names).bufs();
+  std::vector<buf_t> name_bufs = coinbase::ffi::bufs_from_cmems(quorum_party_names);
   std::set<crypto::pname_t> quorum_names;
   for (const auto& name_buf : name_bufs) {
     quorum_names.insert(name_buf.to_string());
@@ -178,13 +179,13 @@ int serialize_mpc_eckey_mp(mpc_eckey_mp_ref* k, cmems_t* ser) {
   auto party_name = coinbase::ser(key->party_name);
 
   auto out = std::vector<mem_t>{x, Q, Qis, curve, party_name};
-  *ser = coinbase::mems_t(out).to_cmems();
+  *ser = coinbase::ffi::copy_to_cmems(out);
   return 0;
 }
 
 int deserialize_mpc_eckey_mp(cmems_t sers, mpc_eckey_mp_ref* k) {
   std::unique_ptr<eckey::key_share_mp_t> key(new eckey::key_share_mp_t());
-  std::vector<buf_t> sers_vec = coinbase::mems_t(sers).bufs();
+  std::vector<buf_t> sers_vec = coinbase::ffi::bufs_from_cmems(sers);
 
   if (coinbase::deser(sers_vec[0], key->x_share)) return 1;
   if (coinbase::deser(sers_vec[1], key->Q)) return 1;

demos-go/cb-mpc-go/internal/cgobinding/eddsamp.cpp

@@ -7,6 +7,7 @@
 #include <cbmpc/core/buf.h>
 #include <cbmpc/protocol/eddsa.h>
 #include <cbmpc/protocol/mpc_job_session.h>
+#include <cbmpc/ffi/cmem_adapter.h>
 
 #include "curve.h"
 #include "network.h"
@@ -22,10 +23,10 @@ int mpc_eddsampc_sign(job_mp_ref* j, mpc_eckey_mp_ref* k, cmem_t msg_mem, int si
   job_mp_t* job = static_cast<job_mp_t*>(j->opaque);
   eddsampc::key_t* key = static_cast<eddsampc::key_t*>(k->opaque);
 
-  buf_t msg = coinbase::mem_t(msg_mem);
+  buf_t msg = coinbase::ffi::view(msg_mem);
   buf_t sig;
   error_t err = eddsampc::sign(*job, *key, msg, party_idx_t(sig_receiver), sig);
   if (err) return err;
-  *sig_mem = sig.to_cmem();
+  *sig_mem = coinbase::ffi::copy_to_cmem(sig);
   return 0;
 }