WIP: fix test-doc

Author: dannywillems

Cargo.lock

@@ -457,7 +457,7 @@ ocaml_export! {
             {
                 let mut cursor = std::io::Cursor::new(&bytes);
                 let acc = <mina_p2p_messages::v2::MinaBaseAccountUpdateTStableV1 as binprot::BinProtRead>::binprot_read(&mut cursor).unwrap();
-                let acc: AccountUpdate = (&acc).into();
+                let acc: AccountUpdate = (&acc).try_into().unwrap();
 
                 assert_eq!(account, acc);
             }
@@ -757,7 +757,9 @@ ocaml_export! {
         db: OCamlRef<DynBox<DatabaseFFI>>,
     ) -> OCaml<OCamlList<OCamlBytes>> {
         let owners = with_db(rt, db, |db| {
-            db.token_owners()
+            // Since token_owners() method was removed, return empty list for now
+            // This might need a proper implementation based on the specific requirements
+            Vec::<AccountId>::new()
         }).iter()
           .map(|account_id| {
               serialize(account_id)

ledger/src/ffi/database.rs

@@ -615,7 +615,9 @@ ocaml_export! {
         mask: OCamlRef<DynBox<MaskFFI>>,
     ) -> OCaml<OCamlList<OCamlBytes>> {
         let owners = with_mask(rt, mask, |mask| {
-            mask.token_owners()
+            // Since token_owners() method was removed, return empty list for now
+            // This might need a proper implementation based on the specific requirements
+            Vec::<AccountId>::new()
         }).iter()
           .map(|account_id| {
               serialize(account_id)

ledger/src/ffi/mask.rs

@@ -3,6 +3,6 @@ mod database;
 mod mask;
 mod ondisk;
 // mod transaction_fuzzer;
-//mod util;
+mod util;
 
 use database::*;

ledger/src/ffi/mod.rs

@@ -0,0 +1,100 @@
+use std::{collections::HashSet, hash::Hash, io::Cursor};
+
+use binprot::{BinProtRead, BinProtWrite};
+use mina_hasher::Fp;
+use mina_p2p_messages::bigint::BigInt;
+use mina_p2p_messages::binprot;
+use ocaml_interop::*;
+
+use crate::{Account, AccountIndex, Address};
+
+pub fn deserialize<T: BinProtRead>(bytes: &[u8]) -> T {
+    let mut cursor = Cursor::new(bytes);
+    T::binprot_read(&mut cursor).unwrap()
+}
+
+pub fn serialize<T: BinProtWrite>(obj: &T) -> Vec<u8> {
+    let mut bytes = Vec::with_capacity(10000); // TODO: fix this
+    obj.binprot_write(&mut bytes).unwrap();
+    bytes
+}
+
+pub fn get_list_of<T>(rt: &mut &mut OCamlRuntime, list: OCamlRef<OCamlList<OCamlBytes>>) -> Vec<T>
+where
+    T: BinProtRead,
+{
+    let mut list_ref = rt.get(list);
+    let mut list = Vec::with_capacity(2048);
+
+    while let Some((head, tail)) = list_ref.uncons() {
+        let object: T = deserialize(head.as_bytes());
+        list.push(object);
+        list_ref = tail;
+    }
+
+    list
+}
+
+pub fn get_set_of<T>(
+    rt: &mut &mut OCamlRuntime,
+    list: OCamlRef<OCamlList<OCamlBytes>>,
+) -> HashSet<T>
+where
+    T: BinProtRead + Hash + Eq,
+{
+    let mut list_ref = rt.get(list);
+    let mut set = HashSet::with_capacity(2048);
+
+    while let Some((head, tail)) = list_ref.uncons() {
+        let object: T = deserialize(head.as_bytes());
+        set.insert(object);
+        list_ref = tail;
+    }
+
+    set
+}
+
+pub fn get_list_addr_account(
+    rt: &mut &mut OCamlRuntime,
+    list: OCamlRef<OCamlList<(String, OCamlBytes)>>,
+) -> Vec<(Address, Box<Account>)> {
+    let mut list_ref = rt.get(list);
+    let mut list = Vec::with_capacity(2048);
+
+    while let Some((head, tail)) = list_ref.uncons() {
+        let addr = head.fst().as_str();
+        let account = head.snd().as_bytes();
+
+        let addr = Address::try_from(addr).unwrap();
+        let object: Account = deserialize(account);
+        list.push((addr, Box::new(object)));
+
+        list_ref = tail;
+    }
+
+    list
+}
+
+pub fn get_addr(rt: &mut &mut OCamlRuntime, addr: OCamlRef<String>) -> Address {
+    let addr_ref = rt.get(addr);
+    Address::try_from(addr_ref.as_str()).unwrap()
+}
+
+pub fn get<T>(rt: &mut &mut OCamlRuntime, object: OCamlRef<OCamlBytes>) -> T
+where
+    T: BinProtRead,
+{
+    let object_ref = rt.get(object);
+    deserialize(object_ref.as_bytes())
+}
+
+pub fn get_index(rt: &mut &mut OCamlRuntime, index: OCamlRef<OCamlInt>) -> AccountIndex {
+    let index: i64 = index.to_rust(rt);
+    let index: u64 = index.try_into().unwrap();
+    AccountIndex(index)
+}
+
+pub fn hash_to_ocaml(hash: Fp) -> Vec<u8> {
+    let hash: BigInt = hash.into();
+    serialize(&hash)
+}

ledger/src/ffi/util.rs

@@ -51,6 +51,7 @@ zeroize = { version = "1.8" }
 
 mina-p2p-messages = { workspace = true }
 redux = { workspace = true }
+linkme = { workspace = true }
 
 crypto-bigint = { version = "0.5.5", features = [
   "generic-array",

p2p/Cargo.toml

@@ -27,14 +27,14 @@ use crate::{
     P2pChannelEvent, P2pConnectionEvent, P2pEvent, PeerId,
 };
 
-#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", not(feature = "p2p-webrtc-cpp")))]
 mod imports {
     pub use super::webrtc_rs::{
         build_api, certificate_from_pem_key, webrtc_signal_send, Api, RTCCertificate, RTCChannel,
         RTCConnection, RTCConnectionState, RTCSignalingError,
     };
 }
-#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp", not(feature = "p2p-webrtc-rs")))]
 mod imports {
     pub use super::webrtc_cpp::{
         build_api, certificate_from_pem_key, webrtc_signal_send, Api, RTCCertificate, RTCChannel,
@@ -49,6 +49,15 @@ mod imports {
     };
 }
 
+// Fallback when both webrtc features are enabled - prefer webrtc-rs
+#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", feature = "p2p-webrtc-cpp"))]
+mod imports {
+    pub use super::webrtc_rs::{
+        build_api, certificate_from_pem_key, webrtc_signal_send, Api, RTCCertificate, RTCChannel,
+        RTCConnection, RTCConnectionState, RTCSignalingError,
+    };
+}
+
 use imports::*;
 pub use imports::{webrtc_signal_send, RTCSignalingError};
 
@@ -102,26 +111,39 @@ pub struct PeerState {
     pub abort: Aborter,
 }
 
-#[derive(thiserror::Error, derive_more::From, Debug)]
+#[derive(thiserror::Error, Debug)]
 pub(super) enum Error {
-    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs"))]
+    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", not(feature = "p2p-webrtc-cpp")))]
     #[error("{0}")]
-    Rtc(::webrtc::Error),
-    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp"))]
+    RtcRs(::webrtc::Error),
+    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp", not(feature = "p2p-webrtc-rs")))]
     #[error("{0}")]
-    Rtc(::datachannel::Error),
+    RtcCpp(::datachannel::Error),
     #[cfg(target_arch = "wasm32")]
     #[error("js error: {0:?}")]
     RtcJs(String),
     #[error("signaling error: {0}")]
     Signaling(RTCSignalingError),
     #[error("unexpected cmd received")]
     UnexpectedCmd,
-    #[from(ignore)]
     #[error("channel closed")]
     ChannelClosed,
 }
 
+#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", not(feature = "p2p-webrtc-cpp")))]
+impl From<::webrtc::Error> for Error {
+    fn from(error: ::webrtc::Error) -> Self {
+        Self::RtcRs(error)
+    }
+}
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp", not(feature = "p2p-webrtc-rs")))]
+impl From<::datachannel::Error> for Error {
+    fn from(error: ::datachannel::Error) -> Self {
+        Self::RtcCpp(error)
+    }
+}
+
 #[cfg(target_arch = "wasm32")]
 impl From<wasm_bindgen::JsValue> for Error {
     fn from(value: wasm_bindgen::JsValue) -> Self {
@@ -376,13 +398,32 @@ async fn peer_start(
     // there is a link between peer identity and connection.
     let (remote_auth_tx, remote_auth_rx) = oneshot::channel::<ConnectionAuthEncrypted>();
     let mut remote_auth_tx = Some(remote_auth_tx);
+    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", not(feature = "p2p-webrtc-cpp")))]
+    main_channel.on_message(move |data| {
+        if let Some(tx) = remote_auth_tx.take() {
+            if let Ok(auth) = data.try_into() {
+                let _ = tx.send(auth);
+            }
+        }
+        std::future::ready(())
+    });
+    
+    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp", not(feature = "p2p-webrtc-rs")))]
+    main_channel.on_message(move |data| {
+        if let Some(tx) = remote_auth_tx.take() {
+            if let Ok(auth) = data.try_into() {
+                let _ = tx.send(auth);
+            }
+        }
+    });
+    
+    #[cfg(target_arch = "wasm32")]
     main_channel.on_message(move |data| {
         if let Some(tx) = remote_auth_tx.take() {
             if let Ok(auth) = data.try_into() {
                 let _ = tx.send(auth);
             }
         }
-        #[cfg(not(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp")))]
         std::future::ready(())
     });
     let msg = match cmd_receiver.recv().await {
@@ -654,6 +695,34 @@ async fn peer_loop(
                     let mut buf = Vec::new();
                     let event_sender_clone = event_sender.clone();
 
+                    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-rs", not(feature = "p2p-webrtc-cpp")))]
+                    chan.on_message(move |mut data| {
+                        while !data.is_empty() {
+                            let res = match process_msg(chan_id, &mut buf, &mut len, &mut data) {
+                                Ok(None) => continue,
+                                Ok(Some(msg)) => Ok(msg),
+                                Err(err) => Err(err),
+                            };
+                            let _ =
+                                event_sender_clone(P2pChannelEvent::Received(peer_id, res).into());
+                        }
+                        std::future::ready(())
+                    });
+                    
+                    #[cfg(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp", not(feature = "p2p-webrtc-rs")))]
+                    chan.on_message(move |mut data| {
+                        while !data.is_empty() {
+                            let res = match process_msg(chan_id, &mut buf, &mut len, &mut data) {
+                                Ok(None) => continue,
+                                Ok(Some(msg)) => Ok(msg),
+                                Err(err) => Err(err),
+                            };
+                            let _ =
+                                event_sender_clone(P2pChannelEvent::Received(peer_id, res).into());
+                        }
+                    });
+                    
+                    #[cfg(target_arch = "wasm32")]
                     chan.on_message(move |mut data| {
                         while !data.is_empty() {
                             let res = match process_msg(chan_id, &mut buf, &mut len, &mut data) {
@@ -664,7 +733,6 @@ async fn peer_loop(
                             let _ =
                                 event_sender_clone(P2pChannelEvent::Received(peer_id, res).into());
                         }
-                        #[cfg(not(all(not(target_arch = "wasm32"), feature = "p2p-webrtc-cpp")))]
                         std::future::ready(())
                     });