Extract testgen-hs handling into dedicated crates

Cargo.toml

@@ -12,6 +12,8 @@ members = [
   "crates/api_provider",
   "crates/node",
   "crates/data_node",
+  "crates/testgen",
+  "crates/error_decoder",
   "crates/gateway",
   "crates/sdk_bridge",
   "crates/integration_tests",
@@ -32,6 +34,7 @@ bf-build-utils = { path = "crates/build_utils", package = "blockfrost-platform-b
 bf-common = { path = "crates/common", package = "blockfrost-platform-common" }
 bf-data-node = { path = "crates/data_node", package = "blockfrost-platform-data-node" }
 bf-node = { path = "crates/node", package = "blockfrost-platform-node" }
+bf-testgen = { path = "crates/testgen", package = "blockfrost-platform-testgen" }
 bip39 = "2.2.2"
 blockfrost = { version = "1.2.3", default-features = false, features = [
   "native-tls",

crates/build_utils/src/lib.rs

@@ -1,2 +1,3 @@
 pub mod git;
+pub mod target;
 pub mod testgen_hs;

crates/build_utils/src/target.rs

@@ -0,0 +1,21 @@
+pub const fn os() -> &'static str {
+    if cfg!(target_os = "macos") {
+        "darwin"
+    } else if cfg!(target_os = "linux") {
+        "linux"
+    } else if cfg!(target_os = "windows") {
+        "windows"
+    } else {
+        panic!("Unsupported OS")
+    }
+}
+
+pub const fn arch() -> &'static str {
+    if cfg!(target_arch = "x86_64") {
+        "x86_64"
+    } else if cfg!(target_arch = "aarch64") {
+        "aarch64"
+    } else {
+        panic!("Unsupported architecture")
+    }
+}

crates/build_utils/src/testgen_hs.rs

@@ -16,25 +16,10 @@ pub fn ensure() {
         return;
     }
 
-    let testgen_lib_version = "10.6.3.0";
-
-    let target_os = if cfg!(target_os = "macos") {
-        "darwin"
-    } else if cfg!(target_os = "linux") {
-        "linux"
-    } else if cfg!(target_os = "windows") {
-        "windows"
-    } else {
-        panic!("Unsupported OS");
-    };
+    let testgen_lib_version = "10.6.3.1";
 
-    let arch = if cfg!(target_arch = "x86_64") {
-        "x86_64"
-    } else if cfg!(target_arch = "aarch64") {
-        "aarch64"
-    } else {
-        panic!("Unsupported architecture");
-    };
+    let target_os = super::target::os();
+    let arch = super::target::arch();
 
     let suffix = if target_os == "windows" {
         ".zip"
@@ -44,7 +29,7 @@ pub fn ensure() {
 
     let file_name = format!("testgen-hs-{testgen_lib_version}-{arch}-{target_os}");
     let download_url = format!(
-        "https://github.com/input-output-hk/testgen-hs/releases/download/{testgen_lib_version}/{file_name}{suffix}"
+        "https://github.com/blockfrost/testgen-hs/releases/download/{testgen_lib_version}/{file_name}{suffix}"
     );
 
     println!("Looking for {file_name}");

crates/error_decoder/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "blockfrost-platform-error-decoder"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+build = "build.rs"
+
+[dependencies]
+bf-common.workspace = true
+bf-testgen.workspace = true
+hex.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+
+[features]
+tarpaulin = []
+
+[build-dependencies]
+bf-build-utils.workspace = true
+
+[dev-dependencies]
+bf-testgen = { workspace = true, features = ["test-utils"] }
+sysinfo.workspace = true
+pallas-network.workspace = true
+pallas-hardano.workspace = true
+pallas-codec.workspace = true

crates/error_decoder/README.md

@@ -0,0 +1,5 @@
+# error decoder
+
+This package contains external error decoder for tx submit errors. Historically used to decode and generate error messages that are returned from our API.
+Now it's only used to test `pallas-hardano` based implementation and generate random test cases. `pallas-hardano` vs ledger error generating tests are also in this crate.
+Related `pallas-hardano` part initially implemented in this repository and later merged into pallas.

crates/error_decoder/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    bf_build_utils::testgen_hs::ensure();
+}

crates/error_decoder/src/external.rs

@@ -0,0 +1,113 @@
+use bf_common::errors::AppError;
+use bf_testgen::testgen::{Testgen, TestgenResponse, Variant};
+
+#[derive(Clone)]
+pub struct ExternalDecoder {
+    testgen: Testgen,
+}
+impl ExternalDecoder {
+    pub fn spawn() -> Result<Self, AppError> {
+        let testgen = Testgen::spawn(Variant::DeserializeStream)
+            .map_err(|err| AppError::Server(format!("Failed to spawn ExternalDecoder: {err}")))?;
+
+        Ok(Self { testgen })
+    }
+
+    pub async fn decode(&self, input: &[u8]) -> Result<serde_json::Value, String> {
+        match self.testgen.decode(input).await {
+            Ok(resp) => match resp {
+                TestgenResponse::Ok(value) => Ok(value),
+                TestgenResponse::Err(err) => Err(err.to_string()),
+            },
+            Err(err) => Err(err),
+        }
+    }
+
+    /// This function is called at startup, so that we make sure that the worker is reasonable.
+    pub async fn startup_sanity_test(&self) -> Result<(), String> {
+        let input = hex::decode("8182068182028200a0").map_err(|err| err.to_string())?;
+        let result = self.decode(&input).await;
+        let expected = serde_json::json!({
+          "contents": {
+            "contents": {
+              "contents": {
+                "era": "ShelleyBasedEraConway",
+                "error": [
+                  "ConwayCertsFailure (WithdrawalsNotInRewardsCERTS (Withdrawals {unWithdrawals = fromList []}))"
+                ],
+                "kind": "ShelleyTxValidationError"
+              },
+              "tag": "TxValidationErrorInCardanoMode"
+            },
+            "tag": "TxCmdTxSubmitValidationError"
+          },
+          "tag": "TxSubmitFail"
+        });
+
+        if result == Ok(expected) {
+            Ok(())
+        } else {
+            Err(format!(
+                "ExternalDecoder: startup_sanity_test failed: {result:?}"
+            ))
+        }
+    }
+
+    /// A single global [`ExternalDecoder`] that you can cheaply use in tests.
+    #[cfg(all(test, not(feature = "tarpaulin")))]
+    pub fn instance() -> Self {
+        GLOBAL_INSTANCE.clone()
+    }
+}
+
+#[cfg(all(test, not(feature = "tarpaulin")))]
+static GLOBAL_INSTANCE: std::sync::LazyLock<ExternalDecoder> =
+    std::sync::LazyLock::new(|| ExternalDecoder::spawn().expect("Failed to spawn ExternalDecoder"));
+
+#[cfg(test)]
+mod tests {
+    // The CBOR test cases are covered by `crates/error_decoder/src/tests/specific.rs`,
+    // which already cross-validates the Rust (pallas-hardano) implementation against the
+    // Haskell (testgen-hs) external decoder. This module only contains tests that are
+    // unique to the external decoder itself (e.g. crash-recovery behaviour).
+    #[cfg(not(feature = "tarpaulin"))]
+    use super::*;
+
+    #[tokio::test]
+    //#[tracing_test::traced_test]
+    #[cfg(not(feature = "tarpaulin"))]
+    async fn test_sanity() {
+        let decoder = ExternalDecoder::spawn().unwrap();
+
+        // Wait for it to come up:
+        decoder.startup_sanity_test().await.unwrap();
+
+        // Now, kill our child to test the restart logic:
+        sysinfo::System::new_all()
+            .process(sysinfo::Pid::from_u32(decoder.testgen.child_pid().unwrap()))
+            .unwrap()
+            .kill();
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        let input = hex::decode("8182068183051a000c275b1a000b35ec").unwrap();
+        let result = decoder.decode(&input).await;
+
+        assert_eq!(
+            result,
+            Ok(serde_json::json!({"contents":
+                 {"contents":
+                  {"contents":
+                   {"era": "ShelleyBasedEraConway", "error":
+                    ["ConwayTreasuryValueMismatch (Mismatch {mismatchSupplied = Coin 734700, mismatchExpected = Coin 796507})"],
+                    "kind": "ShelleyTxValidationError"
+                    },
+                    "tag": "TxValidationErrorInCardanoMode"
+                }, "tag": "TxCmdTxSubmitValidationError"
+            },
+                "tag": "TxSubmitFail"
+                }
+            ))
+        );
+    }
+}

crates/error_decoder/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod external;
+#[cfg(test)]
+mod tests;

crates/error_decoder/src/tests.rs

@@ -0,0 +1,4 @@
+#[cfg(test)]
+mod random;
+#[cfg(test)]
+pub(crate) mod specific;

crates/node/src/cbor/tests/random.rs → crates/error_decoder/src/tests/random.rs

@@ -1,4 +1,8 @@
-use super::*;
+#![cfg(not(feature = "tarpaulin"))]
+
+use bf_testgen::tests::{CaseType, check_generated_cases};
+use pallas_hardano::display::haskell_error::serialize_error;
+use pallas_network::miniprotocols::localtxsubmission::TxValidationError;
 
 #[test]
 #[allow(non_snake_case)]

crates/node/src/cbor/tests/specific.rs → crates/error_decoder/src/tests/specific.rs

@@ -18,7 +18,80 @@ done
 ```
 */
 
-use super::verify_one;
+#[cfg(test)]
+use pallas_network::miniprotocols::localtxsubmission::TxValidationError;
+
+/// This function takes a CBOR-encoded `ApplyTxErr`, and verifies our
+/// deserializer against the Haskell one. Use it for specific cases.
+///
+/// Under `tarpaulin`, the external Haskell decoder (`testgen-hs`) is not
+/// available, so we only exercise the Rust decode + serialize path (which is
+/// what we want coverage for anyway).
+#[cfg(test)]
+pub(crate) async fn verify_one(cbor: &str) {
+    use pallas_hardano::display::haskell_error::serialize_error;
+
+    let cbor = hex::decode(cbor).unwrap();
+
+    let our_decoding = decode_error(&cbor);
+    let our_json = serialize_error(our_decoding).expect("Failed to serialize error");
+
+    #[cfg(not(feature = "tarpaulin"))]
+    {
+        use crate::external::ExternalDecoder;
+
+        let reference_json = match ExternalDecoder::instance().decode(&cbor).await {
+            Ok(value) => value,
+            Err(shared_decoder_err) => {
+                // Recover from a poisoned shared decoder process by retrying with a fresh one.
+                let fresh_decoder = ExternalDecoder::spawn()
+                    .expect("Failed to spawn a fresh ExternalDecoder for retry");
+                fresh_decoder.decode(&cbor).await.unwrap_or_else(|fresh_decoder_err| {
+                    panic!(
+                        "Failed to decode reference JSON with both shared and fresh ExternalDecoder instances. shared_error={shared_decoder_err}, fresh_error={fresh_decoder_err}, cbor={}",
+                        hex::encode(&cbor)
+                    )
+                })
+            },
+        };
+
+        assert_json_eq!(reference_json, our_json);
+    }
+
+    // Under tarpaulin: just assert the Rust decoder didn't panic and produced valid JSON.
+    #[cfg(feature = "tarpaulin")]
+    {
+        let _ = our_json;
+    }
+}
+#[cfg(test)]
+fn decode_error(bytes: &[u8]) -> TxValidationError {
+    use pallas_codec::minicbor;
+
+    let mut decoder = minicbor::Decoder::new(bytes);
+    decoder.decode().unwrap()
+}
+
+#[cfg(all(test, not(feature = "tarpaulin")))]
+macro_rules! assert_json_eq {
+    ($left:expr, $right:expr) => {
+        if $left != $right {
+            let left_pretty = serde_json::to_string_pretty(&$left).unwrap();
+            let right_pretty = serde_json::to_string_pretty(&$right).unwrap();
+            panic!(
+                concat!(
+                    "assertion `left == right` failed\n",
+                    "  left:\n    {}\n  right:\n    {}",
+                ),
+                left_pretty.replace("\n", "\n    "),
+                right_pretty.replace("\n", "\n    "),
+            );
+        }
+    };
+}
+
+#[cfg(all(test, not(feature = "tarpaulin")))]
+pub(crate) use assert_json_eq; // export it
 
 #[tokio::test]
 #[allow(non_snake_case)]