From 465006f4a69ac781614cbc3eee07bf0a85da7c84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C4=B1z=C4=B1r=20Sefa=20=C4=B0rken?= <sefairken@gmail.com>
Date: Mon, 5 May 2025 20:05:44 +0300
Subject: [PATCH 01/22] Implement tx submit evaluation via pallas

---
 Cargo.lock                            | 287 +++++++++---
 Cargo.toml                            |   4 +-
 src/api/tx/submit.rs                  |  46 +-
 src/api/utils/txs/evaluate.rs         |   1 +
 src/api/utils/txs/evaluate/model.rs   | 306 ++++++++++++
 src/api/utils/txs/evaluate/root.rs    |  28 +-
 src/api/utils/txs/evaluate/utxos.rs   |  22 +-
 src/cbor.rs                           |   1 +
 src/cbor/evaluate.rs                  | 652 ++++++++++++++++++++++++++
 src/common.rs                         |  37 ++
 src/node.rs                           |   1 +
 src/node/ledger.rs                    |  53 +++
 tests/api/utils.rs                    |   6 +
 tests/api/utils/txs/evaluate/root.rs  |  35 ++
 tests/api/utils/txs/evaluate/utxos.rs |  66 +++
 tests/common.rs                       |   6 +
 tests/endpoints.rs                    |   7 +
 tests/endpoints_test.rs               |   1 +
 18 files changed, 1446 insertions(+), 113 deletions(-)
 create mode 100644 src/api/utils/txs/evaluate/model.rs
 create mode 100644 src/cbor/evaluate.rs
 create mode 100644 src/node/ledger.rs
 create mode 100644 tests/api/utils.rs
 create mode 100644 tests/api/utils/txs/evaluate/root.rs
 create mode 100644 tests/api/utils/txs/evaluate/utxos.rs
 create mode 100644 tests/endpoints.rs

diff --git a/Cargo.lock b/Cargo.lock
index 28330a82..3c691eab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -49,6 +49,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -120,6 +126,12 @@ version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "async-trait"
 version = "0.1.88"
@@ -200,6 +212,12 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "az"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
+
 [[package]]
 name = "backtrace"
 version = "0.3.74"
@@ -285,7 +303,7 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33415e24172c1b7d6066f6d999545375ab8e1d95421d6784bdfff9496f292387"
 dependencies = [
- "bitcoin_hashes",
+ "bitcoin_hashes 0.13.0",
  "rand_core 0.6.4",
  "serde",
  "unicode-normalization",
@@ -312,6 +330,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9425c3bf7089c983facbae04de54513cce73b41c7f9ff8c845b54e7bc64ebbfb"
 
+[[package]]
+name = "bitcoin-io"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+
 [[package]]
 name = "bitcoin_hashes"
 version = "0.13.0"
@@ -319,7 +343,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1930a4dabfebb8d7d9992db18ebe3ae2876f0a305fab206fd168df931ede293b"
 dependencies = [
  "bitcoin-internals",
- "hex-conservative",
+ "hex-conservative 0.1.2",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative 0.2.1",
 ]
 
 [[package]]
@@ -456,6 +490,18 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "blst"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47c79a94619fade3c0b887670333513a67ac28a6a7e653eb260bf0d4103db38d"
+dependencies = [
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.17.0"
@@ -575,6 +621,19 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "chumsky"
+version = "1.0.0-alpha.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7b80276986f86789dc56ca6542d53bba9cda3c66091ebbe7bd96fc1bdf20f1f"
+dependencies = [
+ "hashbrown 0.14.5",
+ "regex-automata 0.3.9",
+ "serde",
+ "stacker",
+ "unicode-ident",
+]
+
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -1302,6 +1361,16 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
+[[package]]
+name = "gmp-mpfr-sys"
+version = "1.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66d61197a68f6323b9afa616cf83d55d69191e1bf364d4eb7d35ae18defe776"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.9"
@@ -1344,6 +1413,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash",
+ "allocator-api2",
 ]
 
 [[package]]
@@ -1394,6 +1464,15 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "212ab92002354b4819390025006c897e8140934349e8635c9b077f47b4dcbd20"
 
+[[package]]
+name = "hex-conservative"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd"
+dependencies = [
+ "arrayvec",
+]
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -1546,7 +1625,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.0",
+ "windows-core 0.58.0",
 ]
 
 [[package]]
@@ -1843,9 +1922,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
 [[package]]
 name = "libproc"
 version = "0.14.10"
@@ -2013,6 +2098,15 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "minicbor"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0452a60c1863c1f50b5f77cd295e8d2786849f35883f0b9e18e7e6e1b5691b0"
+dependencies = [
+ "minicbor-derive 0.15.3",
+]
+
 [[package]]
 name = "minicbor"
 version = "0.26.4"
@@ -2020,7 +2114,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acb9d59e79ad66121ab441a0d1950890906a41e01ae14145ecf8401aa8894f50"
 dependencies = [
  "half",
- "minicbor-derive",
+ "minicbor-derive 0.16.2",
+]
+
+[[package]]
+name = "minicbor-derive"
+version = "0.15.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd2209fff77f705b00c737016a48e73733d7fbccb8b007194db148f03561fb70"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
 ]
 
 [[package]]
@@ -2365,7 +2470,7 @@ version = "1.0.0-alpha.1"
 source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
 dependencies = [
  "hex",
- "minicbor",
+ "minicbor 0.26.4",
  "serde",
  "thiserror 1.0.69",
 ]
@@ -2507,9 +2612,11 @@ dependencies = [
  "pallas-crypto",
  "pallas-primitives",
  "pallas-traverse",
+ "rug",
  "serde",
  "thiserror 1.0.69",
  "tracing",
+ "uplc-turbo",
 ]
 
 [[package]]
@@ -2822,6 +2929,15 @@ dependencies = [
  "prost",
 ]
 
+[[package]]
+name = "psm"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e944464ec8536cd1beb0bbfd96987eb5e3b72f2ecdafdc5c769a37f1fa2ae1f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "ptr"
 version = "0.2.3"
@@ -3062,6 +3178,17 @@ dependencies = [
  "regex-syntax 0.6.29",
 ]
 
+[[package]]
+name = "regex-automata"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.7.5",
+]
+
 [[package]]
 name = "regex-automata"
 version = "0.4.9"
@@ -3079,6 +3206,12 @@ version = "0.6.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
+[[package]]
+name = "regex-syntax"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -3190,6 +3323,18 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "rug"
+version = "1.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4207e8d668e5b8eb574bda8322088ccd0d7782d3d03c7e8d562e82ed82bdcbc3"
+dependencies = [
+ "az",
+ "gmp-mpfr-sys",
+ "libc",
+ "libm",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -3339,6 +3484,26 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "secp256k1"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+dependencies = [
+ "bitcoin_hashes 0.14.0",
+ "rand 0.8.5",
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "security-framework"
 version = "2.11.1"
@@ -3717,6 +3882,19 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
+[[package]]
+name = "stacker"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cddb07e32ddb770749da91081d8d0ac3a16f1a569a18b20348cd371f5dead06b"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -3886,6 +4064,15 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
 [[package]]
 name = "time"
 version = "0.3.41"
@@ -4315,6 +4502,23 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "uplc-turbo"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "214465664561ad67daf411e1d575a67cf25107369191f26c16243ac98073c0a8"
+dependencies = [
+ "blst",
+ "bumpalo",
+ "chumsky",
+ "cryptoxide",
+ "minicbor 0.25.1",
+ "once_cell",
+ "rug",
+ "secp256k1",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "ureq"
 version = "2.12.1"
@@ -4580,23 +4784,10 @@ dependencies = [
  "windows-implement 0.58.0",
  "windows-interface 0.58.0",
  "windows-result 0.2.0",
- "windows-strings 0.1.0",
+ "windows-strings",
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-core"
-version = "0.61.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
-dependencies = [
- "windows-implement 0.60.0",
- "windows-interface 0.59.1",
- "windows-link",
- "windows-result 0.3.2",
- "windows-strings 0.4.0",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.57.0"
@@ -4619,17 +4810,6 @@ dependencies = [
  "syn 2.0.100",
 ]
 
-[[package]]
-name = "windows-implement"
-version = "0.60.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "windows-interface"
 version = "0.57.0"
@@ -4652,17 +4832,6 @@ dependencies = [
  "syn 2.0.100",
 ]
 
-[[package]]
-name = "windows-interface"
-version = "0.59.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "windows-link"
 version = "0.1.1"
@@ -4676,7 +4845,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
 dependencies = [
  "windows-result 0.2.0",
- "windows-strings 0.1.0",
+ "windows-strings",
  "windows-targets 0.52.6",
 ]
 
@@ -4698,15 +4867,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-result"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows-strings"
 version = "0.1.0"
@@ -4717,15 +4877,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-strings"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5010,6 +5161,20 @@ name = "zeroize"
 version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.100",
+]
 
 [[package]]
 name = "zerovec"
diff --git a/Cargo.toml b/Cargo.toml
index 3fe039ae..ae28bb89 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,7 +31,7 @@ sentry = "0.36.0"
 blake2 = "0.10.6"
 base64 = "0.22.1"
 num_cpus = "1"
-pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
+pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2",  features = ["phase2"] }
 pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
 pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
 pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
@@ -39,7 +39,7 @@ pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockf
 pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
 pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
 pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
+pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2",  features = ["phase2"] }
 reqwest = "0.12.12"
 hex = "0.4.3"
 metrics = { version = "0.24.1", default-features = false }
diff --git a/src/api/tx/submit.rs b/src/api/tx/submit.rs
index 5122bf1a..5d27ad5b 100644
--- a/src/api/tx/submit.rs
+++ b/src/api/tx/submit.rs
@@ -1,4 +1,7 @@
-use crate::{BlockfrostError, NodePool, common::validate_content_type};
+use crate::{
+    BlockfrostError, NodePool,
+    common::{binary_or_hex_heuristic, validate_content_type},
+};
 use axum::{Extension, Json, http::HeaderMap, response::IntoResponse};
 use metrics::counter;
 
@@ -39,44 +42,3 @@ pub async fn route(
 
     Ok((response_headers, Json(response_body)))
 }
-
-/// This function allows us to take both hex-encoded and raw bytes. It has
-/// to be a heuristic: if there are input bytes that are not `[0-9a-f]`,
-/// then it must be a binary string. Otherwise, we assume it’s hex encoded.
-///
-/// **Note**: there is a small probability that the user gave us a binary
-/// string that only _looked_ like a hex-encoded one, but it’s rare enough
-/// to ignore it.
-pub fn binary_or_hex_heuristic(xs: &[u8]) -> Vec<u8> {
-    let even_length = xs.len() % 2 == 0;
-    let contains_non_hex = xs.iter().any(|&x| !x.is_ascii_hexdigit());
-
-    if !even_length || contains_non_hex {
-        xs.to_vec()
-    } else {
-        hex::decode(xs).unwrap_or_else(|_| unreachable!())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use proptest::prelude::*;
-
-    proptest! {
-        #[test]
-        fn proptest_binary_or_hex_heuristic(
-            binary in prop::collection::vec(any::<u8>(), 0..=128)
-                .prop_filter("exclude values made up only of hex digits", |xs| {
-                    let contains_non_hex = xs.iter().any(|&x| !x.is_ascii_hexdigit());
-                    contains_non_hex
-                })
-        ) {
-            let hex_string = hex::encode(&binary);
-            assert_eq!(
-                binary_or_hex_heuristic(hex_string.as_bytes()),
-                binary_or_hex_heuristic(&binary)
-            )
-        }
-    }
-}
diff --git a/src/api/utils/txs/evaluate.rs b/src/api/utils/txs/evaluate.rs
index b1ee3085..dbfda6ba 100644
--- a/src/api/utils/txs/evaluate.rs
+++ b/src/api/utils/txs/evaluate.rs
@@ -1,2 +1,3 @@
+pub mod model;
 pub mod root;
 pub mod utxos;
diff --git a/src/api/utils/txs/evaluate/model.rs b/src/api/utils/txs/evaluate/model.rs
new file mode 100644
index 00000000..cdf64e2a
--- /dev/null
+++ b/src/api/utils/txs/evaluate/model.rs
@@ -0,0 +1,306 @@
+use std::collections::HashMap;
+
+use pallas_primitives::{
+    Bytes, ExUnits, KeepRaw, PlutusScript,
+    conway::{NativeScript, RedeemerTag, ScriptRef},
+};
+use pallas_validate::phase2::EvalReport;
+use pallas_validate::phase2::tx::TxEvalResult;
+use serde::{Deserialize, Serialize, ser::SerializeMap};
+
+// JSON request
+#[derive(Deserialize)]
+pub struct TxEvaluationRequest {
+    pub cbor: String, // @todo can be base16 or base64 CBOR
+    #[serde(rename = "additionalUtxoSet")]
+    pub additional_utxo_set: Option<AdditionalUtxoSet>,
+}
+
+pub type AdditionalUtxoSet = Vec<(TxIn, TxOut)>;
+#[derive(Deserialize)]
+pub struct TxIn {
+    #[serde(rename = "txId")]
+    pub tx_id: String,
+    pub index: u64,
+}
+#[derive(Deserialize)]
+pub struct TxOut {
+    pub address: String,
+    pub value: Value,
+    #[serde(rename = "datumHash")]
+    pub datum_hash: Option<String>,
+    pub datum: Option<String>,
+    pub script: Option<Script>, // script type and details
+}
+
+impl From<Script> for ScriptRef<'_> {
+    fn from(script: Script) -> Self {
+        match script {
+            Script::PlutusV1(s) => {
+                ScriptRef::PlutusV1Script(PlutusScript::<1>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::PlutusV2(s) => {
+                ScriptRef::PlutusV2Script(PlutusScript::<2>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::PlutusV3(s) => {
+                ScriptRef::PlutusV3Script(PlutusScript::<3>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::Native(script_native) => {
+                let script: NativeScript = script_native.into();
+                let r_script: KeepRaw<'_, NativeScript> = script.into(); // @todo: does not generate a valid raw CBOR 
+                ScriptRef::NativeScript(r_script)
+            },
+        }
+    }
+}
+
+impl From<ScriptNative> for NativeScript {
+    fn from(script: ScriptNative) -> Self {
+        match script {
+            ScriptNative::Any(scripts) => {
+                NativeScript::ScriptAny(scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::All(scripts) => {
+                NativeScript::ScriptAll(scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::ExpiresAt(time) => NativeScript::InvalidHereafter(time),
+            ScriptNative::StartsAt(time) => NativeScript::InvalidBefore(time),
+            ScriptNative::NOf(n, scripts) => {
+                NativeScript::ScriptNOfK(n, scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::String(st) => {
+                let mut bytes = [0; 28];
+                hex::decode_to_slice(st, &mut bytes).unwrap();
+                NativeScript::ScriptPubkey(bytes.into())
+            },
+        }
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum Datum {
+    String(String),
+    Map(HashMap<String, String>),
+}
+
+#[derive(Deserialize)]
+pub struct Value {
+    pub coins: u64,
+    pub assets: Option<HashMap<String, u64>>, // asset name and number. Asset number can be negative when burning assets but this behaviour changed in Conway. Now it can be only PositiveCoin
+}
+
+// This is originally missing PlutusV3 since blockfrost uses Ogmios v5.6 which has slightly different data structure
+#[derive(Deserialize)]
+//#[serde(untagged)]
+pub enum Script {
+    #[serde(rename = "plutus:v1")]
+    PlutusV1(String),
+    #[serde(rename = "plutus:v2")]
+    PlutusV2(String),
+    #[serde(rename = "plutus:v3")]
+    PlutusV3(String),
+    #[serde(rename = "native")]
+    Native(ScriptNative),
+}
+
+#[derive(Deserialize)]
+pub enum ScriptNative {
+    #[serde(rename = "any")]
+    Any(Vec<ScriptNative>),
+    #[serde(rename = "all")]
+    All(Vec<ScriptNative>),
+    #[serde(rename = "expiresAt")]
+    ExpiresAt(u64),
+    #[serde(rename = "startsAt")]
+    StartsAt(u64),
+    #[serde(rename = "NOf")]
+    NOf(u32, Vec<ScriptNative>),
+    #[serde(untagged)]
+    String(String),
+}
+
+// JSON response
+#[derive(Serialize)]
+pub struct TxEvaluationResponse {
+    #[serde(rename = "spend:1")]
+    pub spend: ExecCost,
+    #[serde(rename = "mint:0")]
+    pub mint: ExecCost,
+}
+
+#[derive(Serialize)]
+
+pub struct ExecCost {
+    pub memory: u64,
+    pub cpu: u64,
+}
+
+// Create a wrapper type for TxEvalResult
+pub struct TxEvalResultResponse {
+    pub tag: RedeemerTag,
+    pub index: u32,
+    pub units: ExUnitsResponse,
+}
+
+impl From<TxEvalResultResponse> for TxEvalResult {
+    fn from(value: TxEvalResultResponse) -> Self {
+        TxEvalResult {
+            tag: value.tag,
+            index: value.index,
+            units: ExUnits {
+                mem: value.units.memory,
+                steps: value.units.cpu,
+            },
+        }
+    }
+}
+
+impl From<TxEvalResult> for TxEvalResultResponse {
+    fn from(value: TxEvalResult) -> Self {
+        TxEvalResultResponse {
+            tag: value.tag,
+            index: value.index, // @todo fix this in pallas to be u64
+            units: ExUnitsResponse {
+                memory: value.units.mem,
+                cpu: value.units.steps,
+            },
+        }
+    }
+}
+
+use serde::ser::Serializer;
+
+impl Serialize for TxEvalResultResponse {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(1))?;
+
+        let tag = match self.tag {
+            pallas_primitives::conway::RedeemerTag::Spend => "spend",
+            pallas_primitives::conway::RedeemerTag::Mint => "mint",
+            pallas_primitives::conway::RedeemerTag::Cert => "cert",
+            pallas_primitives::conway::RedeemerTag::Reward => "reward",
+            pallas_primitives::conway::RedeemerTag::Vote => "vote",
+            pallas_primitives::conway::RedeemerTag::Propose => "propose",
+        };
+
+        let tag = format!("{}:{}", tag, self.index);
+        map.serialize_entry(&tag, &self.units)?;
+        map.end()
+    }
+}
+
+#[derive(Serialize)]
+//#[serde(remote = "ExUnits")]
+pub struct ExUnitsResponse {
+    memory: u64,
+    cpu: u64,
+}
+
+impl From<ExUnitsResponse> for ExUnits {
+    fn from(value: ExUnitsResponse) -> Self {
+        ExUnits {
+            mem: value.memory,
+            steps: value.cpu,
+        }
+    }
+}
+
+impl From<ExUnits> for ExUnitsResponse {
+    fn from(value: ExUnits) -> Self {
+        ExUnitsResponse {
+            memory: value.mem,
+            cpu: value.steps,
+        }
+    }
+}
+
+pub fn convert_eval_report(pallas_report: EvalReport) -> Vec<TxEvalResultResponse> {
+    pallas_report
+        .into_iter()
+        .map(|pallas_result| pallas_result.into())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn test_json_request_native() {
+        let value = json!({
+            "cbor": "enocodedcbor",
+            "additionalUtxoSet": [
+                [
+                  {
+                    "txId": "stringstringstringstringstringstringstringstringstringstringstri",
+                    "index": 4294967295u64
+                  },
+                  {
+                    "address": "addr_test1qz66ue36465w2qq40005h2hadad6pnjht8mu6sgplsfj74qdjnshguewlx4ww0eet26y2pal4xpav5prcydf28cvxtjqx46x7f",
+                    "value": {
+                      "coins": 2,
+                      "assets": {
+                        "3542acb3a64d80c29302260d62c3b87a742ad14abf855ebc6733081e": 42,
+                        "b5ae663aaea8e500157bdf4baafd6f5ba0ce5759f7cd4101fc132f54.706174617465": 1337
+                      }
+                    },
+                    "datumHash": "iamadatumhash",
+                    "datum": "base16datum",
+                    "script": {"native": {"all":[{"startsAt": 1234567890u64},"ec09e5293d384637cd2f004356ef320f3fe3c07030e36bfffe67e2e2","3c07030e36bfff7cd2f004356ef320f3fe3c07030e7cd2f004356437"]}}
+                  }
+                ]
+                ]
+        });
+
+        let req: TxEvaluationRequest = serde_json::from_value(value).unwrap();
+        assert_eq!(req.cbor, "enocodedcbor");
+        let utxo_set = req.additional_utxo_set.unwrap();
+        assert_eq!(utxo_set.len(), 1);
+        assert_eq!(
+            utxo_set[0].0.tx_id,
+            "stringstringstringstringstringstringstringstringstringstringstri"
+        );
+        assert_eq!(utxo_set[0].0.index, 4294967295u64);
+        assert_eq!(
+            utxo_set[0].1.address,
+            "addr_test1qz66ue36465w2qq40005h2hadad6pnjht8mu6sgplsfj74qdjnshguewlx4ww0eet26y2pal4xpav5prcydf28cvxtjqx46x7f"
+        );
+        assert_eq!(utxo_set[0].1.value.coins, 2);
+    }
+
+    #[test]
+    fn test_json_request_plutusv2() {
+        let value = json!({
+            "cbor": "enocodedcbor",
+            "additionalUtxoSet": [
+                [
+                  {
+                    "txId": "stringstringstringstringstringstringstringstringstringstringstri",
+                    "index": 4294967295u64
+                  },
+                  {
+                    "address": "addr_test1qz66ue36465w2qq40005h2hadad6pnjht8mu6sgplsfj74qdjnshguewlx4ww0eet26y2pal4xpav5prcydf28cvxtjqx46x7f",
+                    "value": {
+                      "coins": 2,
+                      "assets": {
+                        "3542acb3a64d80c29302260d62c3b87a742ad14abf855ebc6733081e": 42,
+                        "b5ae663aaea8e500157bdf4baafd6f5ba0ce5759f7cd4101fc132f54.706174617465": 1337
+                      }
+                    },
+                    "datumHash": "iamadatumhash",
+                    "datum": "base16datum",
+                    "script": {"plutus:v2": "base16script"}
+                  }
+                ]
+                ]
+        });
+
+        let _req: TxEvaluationRequest = serde_json::from_value(value).unwrap();
+    }
+}
diff --git a/src/api/utils/txs/evaluate/root.rs b/src/api/utils/txs/evaluate/root.rs
index ba8d9950..a37e8547 100644
--- a/src/api/utils/txs/evaluate/root.rs
+++ b/src/api/utils/txs/evaluate/root.rs
@@ -1,6 +1,26 @@
-use crate::{BlockfrostError, api::ApiResult};
-use serde_json::Value;
+use crate::{
+    BlockfrostError, NodePool,
+    cbor::evaluate,
+    common::{binary_or_hex_heuristic, validate_content_type},
+};
+use axum::{Extension, Json, response::IntoResponse};
+use hyper::HeaderMap;
 
-pub async fn route() -> ApiResult<Value> {
-    Err(BlockfrostError::not_found())
+use super::model::convert_eval_report;
+
+pub async fn route(
+    Extension(node): Extension<NodePool>,
+    headers: HeaderMap,
+    body: axum::body::Bytes,
+) -> Result<impl IntoResponse, BlockfrostError> {
+    // Allow only application/cbor content type
+    validate_content_type(&headers, &["application/cbor"])?;
+
+    // Allow both hex-encoded and raw binary bodies
+    let binary_tx = binary_or_hex_heuristic(body.as_ref());
+
+    let report = evaluate::evaluate_binary_tx(node, &binary_tx, None).await?;
+    let result = convert_eval_report(report);
+
+    Ok(Json(result))
 }
diff --git a/src/api/utils/txs/evaluate/utxos.rs b/src/api/utils/txs/evaluate/utxos.rs
index ba8d9950..1fa272f5 100644
--- a/src/api/utils/txs/evaluate/utxos.rs
+++ b/src/api/utils/txs/evaluate/utxos.rs
@@ -1,6 +1,20 @@
-use crate::{BlockfrostError, api::ApiResult};
-use serde_json::Value;
+use crate::{BlockfrostError, NodePool, cbor::evaluate, common::validate_content_type};
+use axum::{Extension, Json, extract, response::IntoResponse};
+use hyper::HeaderMap;
 
-pub async fn route() -> ApiResult<Value> {
-    Err(BlockfrostError::not_found())
+use super::model::{TxEvaluationRequest, convert_eval_report};
+
+pub async fn route(
+    Extension(node): Extension<NodePool>,
+    headers: HeaderMap,
+    extract::Json(tx_request): extract::Json<TxEvaluationRequest>,
+) -> Result<impl IntoResponse, BlockfrostError> {
+    // Allow only application/json content type
+    validate_content_type(&headers, &["application/json"])?;
+
+    let pallas_report =
+        evaluate::evaluate_encoded_tx(node, &tx_request.cbor, tx_request.additional_utxo_set)
+            .await?;
+
+    Ok(Json(convert_eval_report(pallas_report)))
 }
diff --git a/src/cbor.rs b/src/cbor.rs
index 9cfdfb72..0b8668da 100644
--- a/src/cbor.rs
+++ b/src/cbor.rs
@@ -1,5 +1,6 @@
 pub mod fallback_decoder;
 
+pub mod evaluate;
 #[cfg(test)]
 pub mod tests;
 pub(crate) mod validation;
diff --git a/src/cbor/evaluate.rs b/src/cbor/evaluate.rs
new file mode 100644
index 00000000..e179ba70
--- /dev/null
+++ b/src/cbor/evaluate.rs
@@ -0,0 +1,652 @@
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+use std::str::FromStr;
+
+use chrono::DateTime;
+use chrono::NaiveDate;
+use chrono::NaiveDateTime;
+use chrono::NaiveTime;
+use pallas_network::miniprotocols::localstate::queries_v16::CurrentProtocolParam;
+use pallas_network::miniprotocols::localstate::queries_v16::GenesisConfig;
+use pallas_network::miniprotocols::localstate::queries_v16::SystemStart;
+use pallas_primitives::AssetName;
+use pallas_primitives::ExUnitPrices;
+use pallas_primitives::ExUnits;
+use pallas_primitives::PolicyId;
+use pallas_primitives::PositiveCoin;
+use pallas_primitives::RationalNumber;
+use pallas_primitives::conway;
+use pallas_traverse::MultiEraOutput;
+use pallas_traverse::MultiEraTx;
+use pallas_validate::utils::TxoRef;
+use pallas_validate::{
+    phase2::{EvalReport, script_context::SlotConfig},
+    utils::{ConwayProtParams, MultiEraProtocolParameters, UtxoMap},
+};
+
+use crate::BlockfrostError;
+use crate::NodePool;
+use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
+use crate::api::utils::txs::evaluate::model::Value;
+use pallas_codec::utils::CborWrap;
+use pallas_primitives::{
+    KeepRaw,
+    conway::{DatumOption, ScriptRef},
+};
+use pallas_traverse::MultiEraInput;
+use pallas_validate::utils::EraCbor;
+
+pub async fn evaluate_binary_tx(
+    node_pool: NodePool,
+    tx_cbor_binary: &[u8],
+    utxos: Option<AdditionalUtxoSet>,
+) -> Result<EvalReport, BlockfrostError> {
+    let slot_config = pallas_validate::phase2::script_context::SlotConfig::default();
+    evaluate_tx(node_pool, tx_cbor_binary, &slot_config, utxos).await
+}
+
+pub async fn evaluate_encoded_tx(
+    node_pool: NodePool,
+    tx_cbor: &String,
+    utxos: Option<AdditionalUtxoSet>,
+) -> Result<EvalReport, BlockfrostError> {
+    let tx_cbor_binary = hex::decode(tx_cbor).unwrap();
+
+    evaluate_binary_tx(node_pool, &tx_cbor_binary, utxos).await
+}
+
+pub async fn evaluate_tx(
+    node_pool: NodePool,
+    tx_cbor_binary: &[u8],
+    slot_config: &SlotConfig,
+    utxo_set: Option<AdditionalUtxoSet>,
+) -> Result<EvalReport, BlockfrostError> {
+    let mut node: deadpool::managed::Object<crate::node::pool_manager::NodePoolManager> =
+        node_pool.get().await?;
+
+    match node.genesis_config_and_pp().await {
+        Ok((genesis_config, protocol_params)) => {
+            let protocol_params: MultiEraProtocolParameters =
+                convert_protocol_param(protocol_params, genesis_config);
+            /*
+             * Prepare transaction
+             */
+            let minted_tx: conway::Tx =
+                pallas_codec::minicbor::decode::<conway::Tx>(tx_cbor_binary).unwrap();
+            let multi_era_tx: MultiEraTx = MultiEraTx::from_conway(&minted_tx);
+
+            /*
+             * make codec safe utxo for conway
+             * with inputs, script and datum option
+             */
+            let mut utxos: UtxoMap = UtxoMap::new();
+            for (tx_in, tx_out) in utxo_set.unwrap_or_default() {
+                let alonzo_tx_in: conway::TransactionInput = conway::TransactionInput {
+                    transaction_id: pallas_primitives::Hash::<32>::from_str(&tx_in.tx_id)
+                        .expect("Invalid tx_id in additional utxo set"),
+                    index: tx_in.index,
+                };
+
+                let multi_era_in: MultiEraInput =
+                    MultiEraInput::AlonzoCompatible(Box::new(Cow::Owned(alonzo_tx_in)));
+
+                /*
+                 * Prepare transaction output
+                 */
+                let address: pallas_codec::utils::Bytes = hex::decode(tx_out.address.clone())
+                    .expect("Invalid address in additional utxo output set")
+                    .into();
+
+                let value: pallas_primitives::conway::Value = match &tx_out.value {
+                    Value {
+                        coins,
+                        assets: None,
+                    } => pallas_primitives::conway::Value::Coin(*coins),
+                    Value {
+                        coins,
+                        assets: Some(assets_map),
+                    } => {
+                        let mut assets = BTreeMap::new();
+                        for (id_name, number) in assets_map {
+                            let mut asset_detail = BTreeMap::new();
+                            let coin: PositiveCoin = number.to_owned().try_into().expect(
+                                "Invalid number for PositiveCoin in additional utxo output set",
+                            );
+                            let (asset_id, asset_name) = parse_asset_string(id_name);
+
+                            asset_detail.insert(asset_name, coin);
+                            assets.insert(asset_id, asset_detail);
+                        }
+                        pallas_primitives::conway::Value::Multiasset(coins.to_owned(), assets)
+                    },
+                };
+
+                let datum_vec: Vec<u8>;
+
+                let datum_option = match &tx_out.datum {
+                    Some(d) => {
+                        let datum_bytes = hex::decode(d).unwrap();
+                        let datum_option = DatumOption::Data(CborWrap(
+                            pallas_codec::minicbor::decode(&datum_bytes).unwrap(),
+                        ));
+                        datum_vec = pallas_codec::minicbor::to_vec(datum_option).unwrap();
+
+                        let datum_option: KeepRaw<'_, DatumOption> =
+                            pallas_codec::minicbor::decode(&datum_vec).unwrap();
+
+                        Some(datum_option)
+                    },
+                    None => None,
+                };
+
+                let script_ref: Option<CborWrap<ScriptRef>> =
+                    tx_out.script.map(|script| CborWrap(script.into()));
+
+                let post_alonzo = pallas_primitives::conway::PostAlonzoTransactionOutput {
+                    address,
+                    value,
+                    datum_option,
+                    script_ref,
+                };
+
+                //let tx_out_cbor  = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
+                let tx_out_cbor = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
+                //tx_out_cbors.push(tx_out_cbor.clone());
+                let post_alonzo = pallas_codec::minicbor::decode::<
+                    pallas_codec::utils::KeepRaw<
+                        '_,
+                        pallas_primitives::conway::PostAlonzoTransactionOutput,
+                    >,
+                >(&tx_out_cbor)
+                .unwrap();
+                let tx_out =
+                    pallas_primitives::conway::TransactionOutput::<'_>::PostAlonzo(post_alonzo);
+                let multi_era_out = MultiEraOutput::<'_>::Conway(Box::new(Cow::Owned(tx_out)));
+
+                utxos.insert(TxoRef::from(&multi_era_in), EraCbor::from(multi_era_out));
+            }
+
+            match pallas_validate::phase2::evaluate_tx(
+                &multi_era_tx,
+                &protocol_params,
+                &utxos,
+                slot_config,
+            ) {
+                Ok(report) => Ok(report),
+                Err(e) => Err(BlockfrostError::custom_400(
+                    "Error evaluating transaction: ".to_string() + &e.to_string(),
+                )),
+            }
+        },
+        Err(e) => Err(BlockfrostError::custom_400(
+            "Error fetching protocol parameters: ".to_string() + &e.to_string(),
+        )),
+    }
+}
+
+fn parse_asset_string(str: &str) -> (PolicyId, AssetName) {
+    let mut parts = str.split('.');
+    let policy_id = parts.next().expect("Invalid asset string in utxo output");
+    let asset_name_bytes = hex::decode(parts.next().map(|s| s.to_string()).unwrap_or_default())
+        .expect("Invalid asset name in asset string"); // can be empty
+    let policy_id_bytes: [u8; 28] = hex::decode(policy_id)
+        .expect("Invalid policy id in asset string")
+        .try_into()
+        .expect("Policy id is not valid in additional utxo output set");
+
+    (
+        PolicyId::from(policy_id_bytes),
+        pallas_primitives::AssetName::from(asset_name_bytes),
+    )
+}
+
+fn convert_system_start(sys_start: SystemStart) -> chrono::DateTime<chrono::FixedOffset> {
+    let naive_date = NaiveDate::from_yo_opt(sys_start.year as i32, sys_start.day_of_year)
+        .expect("Invalid system start date");
+
+    let secs = (sys_start.picoseconds_of_day / 1_000_000_000_000) as u32;
+    let nano = ((sys_start.picoseconds_of_day % 1_000_000_000_000) / 1000) as u32;
+
+    let naive_time =
+        NaiveTime::from_num_seconds_from_midnight_opt(secs, nano).expect("Invalid time");
+
+    let naive_date_time = NaiveDateTime::new(naive_date, naive_time);
+
+    // Convert to DateTime with UTC timezone (zero offset)
+    let utc_offset = chrono::FixedOffset::east_opt(0).expect("Invalid offset");
+
+    DateTime::from_naive_utc_and_offset(naive_date_time, utc_offset)
+}
+
+fn convert_protocol_param(
+    pp: CurrentProtocolParam,
+    genesis: GenesisConfig,
+) -> MultiEraProtocolParameters {
+    // Create a Conway protocol parameters struct from the ProtocolParam and GenesisConfig
+    let conway_pp: ConwayProtParams = ConwayProtParams {
+        minfee_a: pp.minfee_a.unwrap() as u32,
+        minfee_b: pp.minfee_b.unwrap() as u32,
+        max_block_body_size: pp.max_block_body_size.unwrap() as u32,
+        max_transaction_size: pp.max_transaction_size.unwrap() as u32,
+        max_block_header_size: pp.max_block_header_size.unwrap() as u32,
+        system_start: convert_system_start(genesis.system_start),
+        epoch_length: genesis.epoch_length as u64,
+        slot_length: genesis.slot_length as u64,
+        desired_number_of_stake_pools: pp.desired_number_of_stake_pools.unwrap() as u32,
+        protocol_version: (7, 0), // hardcoded,
+        ada_per_utxo_byte: pp.ada_per_utxo_byte.unwrap().into(),
+        cost_models_for_script_languages: {
+            let models = pp.cost_models_for_script_languages.unwrap();
+            conway::CostModels {
+                plutus_v1: models.plutus_v1,
+                plutus_v2: models.plutus_v2,
+                plutus_v3: models.plutus_v3,
+                unknown: BTreeMap::new(), // unknowns doesn't matter
+            }
+        },
+        execution_costs: {
+            let costs = pp.execution_costs.unwrap();
+            ExUnitPrices {
+                mem_price: RationalNumber {
+                    numerator: costs.mem_price.numerator,
+                    denominator: costs.mem_price.denominator,
+                },
+                step_price: RationalNumber {
+                    numerator: costs.step_price.numerator,
+                    denominator: costs.step_price.denominator,
+                },
+            }
+        },
+        max_tx_ex_units: {
+            let ex_units = pp.max_tx_ex_units.unwrap();
+            ExUnits {
+                mem: ex_units.mem,
+                steps: ex_units.steps,
+            }
+        },
+        max_block_ex_units: {
+            let ex_units = pp.max_block_ex_units.unwrap();
+            ExUnits {
+                mem: ex_units.mem,
+                steps: ex_units.steps,
+            }
+        },
+        max_value_size: pp.max_value_size.unwrap() as u32,
+        expansion_rate: {
+            let expansion_rate = pp.expansion_rate.unwrap();
+            RationalNumber {
+                numerator: expansion_rate.numerator,
+                denominator: expansion_rate.denominator,
+            }
+        },
+        treasury_growth_rate: {
+            let growth_rate = pp.treasury_growth_rate.unwrap();
+            RationalNumber {
+                numerator: growth_rate.numerator,
+                denominator: growth_rate.denominator,
+            }
+        },
+        maximum_epoch: pp.maximum_epoch.unwrap(),
+        pool_pledge_influence: {
+            let influence = pp.pool_pledge_influence.unwrap();
+            RationalNumber {
+                numerator: influence.numerator,
+                denominator: influence.denominator,
+            }
+        },
+        pool_voting_thresholds: {
+            let thresholds = pp.pool_voting_thresholds.unwrap();
+            conway::PoolVotingThresholds {
+                motion_no_confidence: RationalNumber {
+                    numerator: thresholds.motion_no_confidence.numerator,
+                    denominator: thresholds.motion_no_confidence.denominator,
+                },
+                committee_normal: RationalNumber {
+                    numerator: thresholds.committee_normal.numerator,
+                    denominator: thresholds.committee_normal.denominator,
+                },
+                committee_no_confidence: RationalNumber {
+                    numerator: thresholds.committee_no_confidence.numerator,
+                    denominator: thresholds.committee_no_confidence.denominator,
+                },
+                hard_fork_initiation: RationalNumber {
+                    numerator: thresholds.hard_fork_initiation.numerator,
+                    denominator: thresholds.hard_fork_initiation.denominator,
+                },
+                security_voting_threshold: RationalNumber {
+                    numerator: thresholds.pp_security_group.numerator,
+                    denominator: thresholds.pp_security_group.denominator,
+                },
+            }
+        },
+        drep_voting_thresholds: {
+            let thresholds = pp.drep_voting_thresholds.unwrap();
+            conway::DRepVotingThresholds {
+                motion_no_confidence: RationalNumber {
+                    numerator: thresholds.motion_no_confidence.numerator,
+                    denominator: thresholds.motion_no_confidence.denominator,
+                },
+                committee_normal: RationalNumber {
+                    numerator: thresholds.committee_normal.numerator,
+                    denominator: thresholds.committee_normal.denominator,
+                },
+                committee_no_confidence: RationalNumber {
+                    numerator: thresholds.committee_no_confidence.numerator,
+                    denominator: thresholds.committee_no_confidence.denominator,
+                },
+                update_constitution: RationalNumber {
+                    numerator: thresholds.update_to_constitution.numerator,
+                    denominator: thresholds.update_to_constitution.denominator,
+                },
+                hard_fork_initiation: RationalNumber {
+                    numerator: thresholds.hard_fork_initiation.numerator,
+                    denominator: thresholds.hard_fork_initiation.denominator,
+                },
+                pp_network_group: RationalNumber {
+                    numerator: thresholds.pp_network_group.numerator,
+                    denominator: thresholds.pp_network_group.denominator,
+                },
+                pp_economic_group: RationalNumber {
+                    numerator: thresholds.pp_economic_group.numerator,
+                    denominator: thresholds.pp_economic_group.denominator,
+                },
+                pp_technical_group: RationalNumber {
+                    numerator: thresholds.pp_technical_group.numerator,
+                    denominator: thresholds.pp_technical_group.denominator,
+                },
+                pp_governance_group: RationalNumber {
+                    numerator: thresholds.pp_gov_group.numerator,
+                    denominator: thresholds.pp_gov_group.denominator,
+                },
+                treasury_withdrawal: RationalNumber {
+                    numerator: thresholds.treasury_withdrawal.numerator,
+                    denominator: thresholds.treasury_withdrawal.denominator,
+                },
+            }
+        },
+        minfee_refscript_cost_per_byte: {
+            let minfee_refscript_cost_per_byte = pp.minfee_refscript_cost_per_byte.unwrap();
+            RationalNumber {
+                numerator: minfee_refscript_cost_per_byte.numerator,
+                denominator: minfee_refscript_cost_per_byte.denominator,
+            }
+        },
+        key_deposit: pp.key_deposit.unwrap().into(),
+        pool_deposit: pp.pool_deposit.unwrap().into(),
+        min_pool_cost: pp.min_pool_cost.unwrap().into(),
+        collateral_percentage: pp.collateral_percentage.unwrap() as u32,
+        max_collateral_inputs: pp.max_collateral_inputs.unwrap() as u32,
+        min_committee_size: pp.min_committee_size.unwrap(),
+        committee_term_limit: pp.committee_term_limit.unwrap(),
+        governance_action_validity_period: pp.governance_action_validity_period.unwrap(),
+        governance_action_deposit: pp.governance_action_deposit.unwrap().into(),
+        drep_deposit: pp.drep_deposit.unwrap().into(),
+        drep_inactivity_period: pp.drep_inactivity_period.unwrap(),
+    };
+
+    MultiEraProtocolParameters::Conway(conway_pp)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use chrono::{Datelike, Timelike};
+
+    use pallas_codec::utils::AnyUInt;
+    use pallas_network::miniprotocols::localstate::queries_v16::{self, Fraction};
+
+    use super::*;
+
+    #[test]
+    fn test_convert_system_start() {
+        // Test case 1: Standard date
+        let sys_start = SystemStart {
+            year: 2023,
+            day_of_year: 100,
+            picoseconds_of_day: 43_200_000_000_000_000, // 12 hours
+        };
+        let result = convert_system_start(sys_start);
+        assert_eq!(result.year(), 2023);
+        assert_eq!(result.ordinal(), 100);
+        assert_eq!(result.hour(), 12);
+        assert_eq!(result.minute(), 0);
+        assert_eq!(result.second(), 0);
+
+        // Test case 2: Year boundary
+        let sys_start = SystemStart {
+            year: 2024,
+            day_of_year: 1,
+            picoseconds_of_day: 3_600_000_000_000_000, // 1 hour
+        };
+        let result = convert_system_start(sys_start);
+        assert_eq!(result.year(), 2024);
+        assert_eq!(result.ordinal(), 1);
+        assert_eq!(result.hour(), 1);
+        assert_eq!(result.minute(), 0);
+        assert_eq!(result.second(), 0);
+
+        // Test case 3: Leap year
+        let sys_start = SystemStart {
+            year: 2024,
+            day_of_year: 366,
+            picoseconds_of_day: 0, // midnight
+        };
+        let result = convert_system_start(sys_start);
+        assert_eq!(result.year(), 2024);
+        assert_eq!(result.ordinal(), 366);
+        assert_eq!(result.hour(), 0);
+        assert_eq!(result.minute(), 0);
+        assert_eq!(result.second(), 0);
+
+        // Test case 4: Partial seconds
+        let sys_start = SystemStart {
+            year: 2023,
+            day_of_year: 200,
+            picoseconds_of_day: 63_123_000_000_000_000, // 17:32:03
+        };
+        let result = convert_system_start(sys_start);
+        assert_eq!(result.year(), 2023);
+        assert_eq!(result.ordinal(), 200);
+        assert_eq!(result.hour(), 17);
+        assert_eq!(result.minute(), 32);
+        assert_eq!(result.second(), 3);
+    }
+
+    #[test]
+    fn test_convert_protocol_param() {
+        // Create minimal test data with required fields
+        let genesis = GenesisConfig {
+            system_start: SystemStart {
+                year: 2023,
+                day_of_year: 100,
+                picoseconds_of_day: 43_200_000_000_000_000, // 12 hours
+            },
+            epoch_length: 432000,
+            slot_length: 1,
+            max_lovelace_supply: AnyUInt::U64(45_000_000_000_000_000),
+            security_param: 2160,
+            active_slots_coefficient: Fraction {
+                num: 618,
+                den: 1000,
+            },
+            network_id: 1,
+            network_magic: 13,
+            slots_per_kes_period: 2160,
+            max_kes_evolutions: 62,
+            update_quorum: 5,
+        };
+        let pp = CurrentProtocolParam {
+            minfee_a: Some(44),
+            minfee_b: Some(155381),
+            max_block_body_size: Some(90112),
+            max_transaction_size: Some(16384),
+            max_block_header_size: Some(1100),
+            key_deposit: Some(AnyUInt::U64(2_000_000)),
+            pool_deposit: Some(AnyUInt::U64(500_000_000)),
+            min_pool_cost: Some(AnyUInt::U64(340_000_000)),
+            desired_number_of_stake_pools: Some(500),
+            ada_per_utxo_byte: Some(AnyUInt::U64(4310)),
+            collateral_percentage: Some(150),
+            max_collateral_inputs: Some(3),
+            cost_models_for_script_languages: Some(queries_v16::CostModels {
+                plutus_v1: Some(vec![1, 2, 3]),
+                plutus_v2: Some(vec![4, 5, 6]),
+                plutus_v3: Some(vec![7, 8, 9]),
+                unknown: [].to_vec().into(),
+            }),
+            execution_costs: Some(queries_v16::ExUnitPrices {
+                mem_price: queries_v16::PositiveInterval {
+                    numerator: 577,
+                    denominator: 10_000,
+                },
+                step_price: queries_v16::PositiveInterval {
+                    numerator: 721,
+                    denominator: 10_000_000,
+                },
+            }),
+            max_tx_ex_units: Some(queries_v16::ExUnits {
+                mem: 14_000_000,
+                steps: 10_000_000_000,
+            }),
+            max_block_ex_units: Some(queries_v16::ExUnits {
+                mem: 62_000_000,
+                steps: 40_000_000_000,
+            }),
+            max_value_size: Some(5000),
+            expansion_rate: Some(queries_v16::RationalNumber {
+                numerator: 3,
+                denominator: 1000,
+            }),
+            treasury_growth_rate: Some(queries_v16::RationalNumber {
+                numerator: 20,
+                denominator: 100,
+            }),
+            maximum_epoch: Some(18),
+            pool_pledge_influence: Some(queries_v16::RationalNumber {
+                numerator: 3,
+                denominator: 10,
+            }),
+            pool_voting_thresholds: Some(queries_v16::PoolVotingThresholds {
+                motion_no_confidence: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                committee_normal: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                committee_no_confidence: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                hard_fork_initiation: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                pp_security_group: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+            }),
+            protocol_version: Some((10, 0)),
+            drep_voting_thresholds: Some(queries_v16::DRepVotingThresholds {
+                motion_no_confidence: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                committee_normal: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                committee_no_confidence: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                update_to_constitution: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                hard_fork_initiation: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                pp_network_group: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                pp_economic_group: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                pp_technical_group: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                pp_gov_group: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+                treasury_withdrawal: queries_v16::RationalNumber {
+                    numerator: 51,
+                    denominator: 100,
+                },
+            }),
+            minfee_refscript_cost_per_byte: Some(queries_v16::RationalNumber {
+                numerator: 156,
+                denominator: 1,
+            }),
+            min_committee_size: Some(3),
+            committee_term_limit: Some(4),
+            governance_action_deposit: Some(AnyUInt::U64(1_000_000)),
+            drep_deposit: Some(AnyUInt::U64(2_000_000)),
+            drep_inactivity_period: Some(3),
+            governance_action_validity_period: Some(10),
+        };
+
+        // Convert protocol parameters
+        let result = convert_protocol_param(pp, genesis);
+
+        // Verify the result is a Conway protocol parameters
+        if let MultiEraProtocolParameters::Conway(conway_pp) = result {
+            // Verify a few fields to ensure conversion is correct
+            assert_eq!(conway_pp.minfee_a, 44);
+            assert_eq!(conway_pp.minfee_b, 155381);
+            assert_eq!(conway_pp.max_block_body_size, 90112);
+            assert_eq!(conway_pp.max_transaction_size, 16384);
+            assert_eq!(conway_pp.epoch_length, 432000);
+            assert_eq!(conway_pp.slot_length, 1);
+            assert_eq!(conway_pp.key_deposit, 2_000_000);
+            assert_eq!(conway_pp.pool_deposit, 500_000_000);
+            assert_eq!(conway_pp.min_pool_cost, 340_000_000);
+            assert_eq!(conway_pp.protocol_version, (7, 0));
+
+            // Check cost models
+            assert_eq!(
+                conway_pp.cost_models_for_script_languages.plutus_v1,
+                Some(vec![1, 2, 3])
+            );
+            assert_eq!(
+                conway_pp.cost_models_for_script_languages.plutus_v2,
+                Some(vec![4, 5, 6])
+            );
+            assert_eq!(
+                conway_pp.cost_models_for_script_languages.plutus_v3,
+                Some(vec![7, 8, 9])
+            );
+
+            // Check execution costs
+            assert_eq!(conway_pp.execution_costs.mem_price.numerator, 577);
+            assert_eq!(conway_pp.execution_costs.mem_price.denominator, 10_000);
+            assert_eq!(conway_pp.execution_costs.step_price.numerator, 721);
+            assert_eq!(conway_pp.execution_costs.step_price.denominator, 10_000_000);
+
+            // Check governance parameters
+            assert_eq!(conway_pp.governance_action_deposit, 1_000_000);
+            assert_eq!(conway_pp.drep_deposit, 2_000_000);
+            assert_eq!(conway_pp.min_committee_size, 3);
+            assert_eq!(conway_pp.committee_term_limit, 4);
+        } else {
+            panic!("Expected Conway protocol parameters");
+        }
+    }
+}
diff --git a/src/common.rs b/src/common.rs
index d97d0569..0a93015c 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -31,6 +31,24 @@ pub fn validate_content_type(
     Ok(true)
 }
 
+/// This function allows us to take both hex-encoded and raw bytes. It has
+/// to be a heuristic: if there are input bytes that are not `[0-9a-f]`,
+/// then it must be a binary string. Otherwise, we assume it’s hex encoded.
+///
+/// **Note**: there is a small probability that the user gave us a binary
+/// string that only _looked_ like a hex-encoded one, but it’s rare enough
+/// to ignore it.
+pub fn binary_or_hex_heuristic(xs: &[u8]) -> Vec<u8> {
+    let even_length = xs.len() % 2 == 0;
+    let contains_non_hex = xs.iter().any(|&x| !x.is_ascii_hexdigit());
+
+    if !even_length || contains_non_hex {
+        xs.to_vec()
+    } else {
+        hex::decode(xs).unwrap_or_else(|_| unreachable!())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -70,4 +88,23 @@ mod tests {
             }
         }
     }
+
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn proptest_binary_or_hex_heuristic(
+            binary in prop::collection::vec(any::<u8>(), 0..=128)
+                .prop_filter("exclude values made up only of hex digits", |xs| {
+                    let contains_non_hex = xs.iter().any(|&x| !x.is_ascii_hexdigit());
+                    contains_non_hex
+                })
+        ) {
+            let hex_string = hex::encode(&binary);
+            assert_eq!(
+                binary_or_hex_heuristic(hex_string.as_bytes()),
+                binary_or_hex_heuristic(&binary)
+            )
+        }
+    }
 }
diff --git a/src/node.rs b/src/node.rs
index 41a201b0..50fe4ed3 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,4 +1,5 @@
 pub mod connection;
+pub mod ledger;
 pub mod pool;
 pub mod pool_manager;
 pub mod sync_progress;
diff --git a/src/node/ledger.rs b/src/node/ledger.rs
new file mode 100644
index 00000000..dc5646f8
--- /dev/null
+++ b/src/node/ledger.rs
@@ -0,0 +1,53 @@
+use pallas_network::miniprotocols::localstate::{
+    self,
+    queries_v16::{CurrentProtocolParam, GenesisConfig},
+};
+
+use super::connection::NodeClient;
+
+use crate::BlockfrostError;
+
+impl NodeClient {
+    /// Fetches the current protocol parameters from the connected Cardano node.
+    /// @TODO These values can be cached
+    pub async fn protocol_params(&mut self) -> Result<CurrentProtocolParam, BlockfrostError> {
+        self.with_statequery(|generic_client: &mut localstate::GenericClient| {
+            Box::pin(async {
+                let era = localstate::queries_v16::get_current_era(generic_client).await?;
+                let params =
+                    localstate::queries_v16::get_current_pparams(generic_client, era).await?;
+                Ok(params)
+            })
+        })
+        .await
+    }
+
+    /// @TODO These values can be cached or read from a genesis file
+    pub async fn genesis_config(&mut self) -> Result<GenesisConfig, BlockfrostError> {
+        self.with_statequery(|generic_client: &mut localstate::GenericClient| {
+            Box::pin(async {
+                let era = localstate::queries_v16::get_current_era(generic_client).await?;
+                let genesis =
+                    localstate::queries_v16::get_genesis_config(generic_client, era).await?;
+                Ok(genesis)
+            })
+        })
+        .await
+    }
+
+    pub async fn genesis_config_and_pp(
+        &mut self,
+    ) -> Result<(GenesisConfig, CurrentProtocolParam), BlockfrostError> {
+        self.with_statequery(|generic_client: &mut localstate::GenericClient| {
+            Box::pin(async {
+                let era = localstate::queries_v16::get_current_era(generic_client).await?;
+                let genesis =
+                    localstate::queries_v16::get_genesis_config(generic_client, era).await?;
+                let params =
+                    localstate::queries_v16::get_current_pparams(generic_client, era).await?;
+                Ok((genesis, params))
+            })
+        })
+        .await
+    }
+}
diff --git a/tests/api/utils.rs b/tests/api/utils.rs
new file mode 100644
index 00000000..ddc35f71
--- /dev/null
+++ b/tests/api/utils.rs
@@ -0,0 +1,6 @@
+pub mod txs {
+    pub mod evaluate {
+        pub mod root;
+        pub mod utxos;
+    }
+}
diff --git a/tests/api/utils/txs/evaluate/root.rs b/tests/api/utils/txs/evaluate/root.rs
new file mode 100644
index 00000000..0b4828e1
--- /dev/null
+++ b/tests/api/utils/txs/evaluate/root.rs
@@ -0,0 +1,35 @@
+mod tests {
+    use tower::ServiceExt;
+
+    use crate::common::{get_blockfrost_client, initialize_app};
+    use crate::tx_builder::build_tx;
+
+    use axum::{body::Body, http::Request};
+    use reqwest::Method;
+
+    #[tokio::test]
+    async fn success() {
+        // prepare the transaction
+        let blockfrost_client = get_blockfrost_client();
+        let tx = build_tx(&blockfrost_client).await.unwrap();
+
+        // init our app
+        let app = initialize_app().await;
+
+        // prepare the request
+        let request = Request::builder()
+            .method(Method::POST)
+            .uri("/utils/tx/evaluate")
+            .header("Content-Type", "application/cbor")
+            .body(Body::from(tx.to_hex()))
+            .unwrap();
+
+        // send the request and get the response
+        let response = app
+            .oneshot(request)
+            .await
+            .expect("Request to /utils/tx/evaluate failed");
+
+        assert_eq!(200, response.status());
+    }
+}
diff --git a/tests/api/utils/txs/evaluate/utxos.rs b/tests/api/utils/txs/evaluate/utxos.rs
new file mode 100644
index 00000000..54703c54
--- /dev/null
+++ b/tests/api/utils/txs/evaluate/utxos.rs
@@ -0,0 +1,66 @@
+mod tests {
+    use serde_json::json;
+    use tower::ServiceExt;
+
+    use crate::common::initialize_app;
+
+    use axum::{
+        body::{Body, to_bytes},
+        http::Request,
+    };
+    use reqwest::Method;
+
+    #[tokio::test]
+    async fn success() {
+        // init our app
+        let app = initialize_app().await;
+
+        let input = json!({
+            "cbor": "84a800d9010282825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab01825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab000181825839005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba1a9e38e8b8021a0002c0b30b58201124502b69ef6917c02db98f8026871e95a70fcc864eb8146bfd44237612b4670dd9010281825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab0110825839005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba1a9841a75e111a0004210d12d90102818258205a3b16ae983c3623b6f516a1a1bcafc124ddd7bebf8406f541c27f24a97d8d8c00a200d90102818258202a60dcffe8ba15307556dbf8d7df142cb9eb15d601251d400d523689d575b8385840843e477f1885303639acf78b1faf47e2c6c81930ef7570c5e843a038ec8042cd3784d89ababc1d803ecd25972ebd3a50da71dd90a9182dbfdbfd8b94a002560305a182000082d8799f4568656c6c6fff82194d101a005ee1c6f5f6",
+            "additionalUtxoSet": [
+                  [
+                    {"index":0,"txId":"b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab"},
+                    {"address":"70faae60072c45d121b6e58ae35c624693ee3dad9ea8ed765eb6f76f9f","value":{"coins":100270605}}
+                  ],
+                  [
+                    {"index":0,"txId":"5a3b16ae983c3623b6f516a1a1bcafc124ddd7bebf8406f541c27f24a97d8d8c"},
+                    {"address":"70faae60072c45d121b6e58ae35c624693ee3dad9ea8ed765eb6f76f9f","script":{"plutus:v3":"58a701010032323232323225333002323232323253330073370e900118041baa0011323322533300a3370e900018059baa00513232533300f30110021533300c3370e900018069baa00313371e6eb8c040c038dd50039bae3010300e37546020601c6ea800c5858dd7180780098061baa00516300c001300c300d001300937540022c6014601600660120046010004601000260086ea8004526136565734aae7555cf2ab9f5742ae89"},"value":{"coins":1624870}}
+                  ],
+                  [
+                    {"index":1,"txId":"b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab"},
+                    {"address":"005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba","value":{"coins":2554439518u64}}
+                    ]
+
+            ]
+        });
+
+        // prepare the request
+        let request = Request::builder()
+            .method(Method::POST)
+            .uri("/utils/tx/evaluate/utxos")
+            .header("Content-Type", "application/json")
+            .body(Body::from(input.to_string()))
+            .unwrap();
+
+        // send the request and get the response
+        let response = app
+            .oneshot(request)
+            .await
+            .expect("Request to /utils/tx/evaluate failed");
+
+        assert!(
+            response.status().is_success(),
+            "Response was not successful"
+        );
+
+        // Convert the response body to bytes
+        let body_bytes = to_bytes(response.into_body(), usize::MAX)
+            .await
+            .expect("Failed to read response body");
+
+        // Convert the bytes to a string and print
+        let body_str = String::from_utf8_lossy(&body_bytes);
+
+        assert_eq!(body_str, "[{\"spend:0\":{\"memory\":958,\"cpu\":2348473}}]");
+    }
+}
diff --git a/tests/common.rs b/tests/common.rs
index e74c8f95..6dfa7282 100644
--- a/tests/common.rs
+++ b/tests/common.rs
@@ -20,6 +20,12 @@ pub fn initialize_logging() {
     let _ = INIT_LOGGING;
 }
 
+pub async fn initialize_app() -> Router {
+    initialize_logging();
+    let (app, _, _, _, _) = build_app().await.expect("Failed to build the application");
+    app
+}
+
 pub fn get_blockfrost_client() -> BlockfrostAPI {
     let settings = BlockFrostSettings::default();
 
diff --git a/tests/endpoints.rs b/tests/endpoints.rs
new file mode 100644
index 00000000..c90a07e3
--- /dev/null
+++ b/tests/endpoints.rs
@@ -0,0 +1,7 @@
+mod asserts;
+mod common;
+mod tx_builder;
+
+pub mod api {
+    pub mod utils;
+}
diff --git a/tests/endpoints_test.rs b/tests/endpoints_test.rs
index cabb8e40..a0f29493 100644
--- a/tests/endpoints_test.rs
+++ b/tests/endpoints_test.rs
@@ -3,6 +3,7 @@ mod common;
 mod tx_builder;
 
 mod tests {
+    //pub mod api;
     use std::net::{IpAddr, SocketAddr};
 
     use crate::asserts;

From 2ee68e06d03ef4704c241a0add326280a810ced0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C4=B1z=C4=B1r=20Sefa=20=C4=B0rken?= <sefairken@gmail.com>
Date: Tue, 27 May 2025 19:59:09 +0300
Subject: [PATCH 02/22] Ignare dead code warnings in the test code

---
 tests/asserts.rs | 1 +
 tests/common.rs  | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/tests/asserts.rs b/tests/asserts.rs
index 5895839c..c7467bd3 100644
--- a/tests/asserts.rs
+++ b/tests/asserts.rs
@@ -2,6 +2,7 @@ use serde_json::Value;
 
 /// This workaround exists because the final error is a Haskell string
 /// which we don't want to bother de-serializing from string.
+#[allow(dead_code)]
 pub fn assert_submit_error_responses(bf_response: &[u8], local_response: &[u8]) {
     #[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq)]
     #[serde(untagged)]
diff --git a/tests/common.rs b/tests/common.rs
index 6dfa7282..697b6214 100644
--- a/tests/common.rs
+++ b/tests/common.rs
@@ -20,6 +20,7 @@ pub fn initialize_logging() {
     let _ = INIT_LOGGING;
 }
 
+#[allow(dead_code)]
 pub async fn initialize_app() -> Router {
     initialize_logging();
     let (app, _, _, _, _) = build_app().await.expect("Failed to build the application");
@@ -69,6 +70,7 @@ pub async fn build_app() -> Result<
     build(config).await
 }
 
+#[allow(dead_code)]
 pub async fn build_app_non_solitary() -> Result<
     (
         Router,

From 597b7c19a520b7e402fc51e3d971505ad6cab354 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C4=B1z=C4=B1r=20Sefa=20=C4=B0rken?= <sefairken@gmail.com>
Date: Wed, 28 May 2025 20:10:47 +0300
Subject: [PATCH 03/22] Update pallas and resolve breaking changes

---
 Cargo.lock                | 64 +++++++++++++++------------------------
 Cargo.toml                | 18 +++++------
 src/cbor/evaluate.rs      | 63 +++++++++++++++++++++-----------------
 src/common.rs             |  9 ++++++
 src/node/sync_progress.rs | 10 +++---
 5 files changed, 82 insertions(+), 82 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3c691eab..612e05fa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -304,7 +304,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33415e24172c1b7d6066f6d999545375ab8e1d95421d6784bdfff9496f292387"
 dependencies = [
  "bitcoin_hashes 0.13.0",
- "rand_core 0.6.4",
  "serde",
  "unicode-normalization",
 ]
@@ -2434,8 +2433,8 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
 [[package]]
 name = "pallas"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "pallas-addresses",
  "pallas-codec",
@@ -2451,8 +2450,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-addresses"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "base58",
  "bech32 0.9.1",
@@ -2466,8 +2465,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-codec"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "hex",
  "minicbor 0.26.4",
@@ -2477,8 +2476,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-configs"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "base64 0.22.1",
  "num-rational",
@@ -2492,8 +2491,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-crypto"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "cryptoxide",
  "hex",
@@ -2505,8 +2504,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-hardano"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "binary-layout",
  "hex",
@@ -2525,8 +2524,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-network"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "byteorder",
  "hex",
@@ -2542,8 +2541,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-primitives"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "hex",
  "pallas-codec",
@@ -2554,8 +2553,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-traverse"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "hex",
  "itertools 0.13.0",
@@ -2570,8 +2569,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-txbuilder"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "hex",
  "pallas-addresses",
@@ -2579,7 +2578,6 @@ dependencies = [
  "pallas-crypto",
  "pallas-primitives",
  "pallas-traverse",
- "pallas-wallet",
  "serde",
  "serde_json",
  "thiserror 1.0.69",
@@ -2587,8 +2585,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-utxorpc"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "pallas-codec",
  "pallas-crypto",
@@ -2601,8 +2599,8 @@ dependencies = [
 
 [[package]]
 name = "pallas-validate"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
+version = "1.0.0-alpha.2"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
 dependencies = [
  "chrono",
  "hex",
@@ -2619,20 +2617,6 @@ dependencies = [
  "uplc-turbo",
 ]
 
-[[package]]
-name = "pallas-wallet"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha2#fa233715b67b22fd8b191c9294858a3185e1207b"
-dependencies = [
- "bech32 0.9.1",
- "bip39",
- "cryptoxide",
- "ed25519-bip32",
- "pallas-crypto",
- "rand 0.8.5",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.12.3"
diff --git a/Cargo.toml b/Cargo.toml
index ae28bb89..1151eadb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,15 +31,15 @@ sentry = "0.36.0"
 blake2 = "0.10.6"
 base64 = "0.22.1"
 num_cpus = "1"
-pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2",  features = ["phase2"] }
-pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2" }
-pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha2",  features = ["phase2"] }
+pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3",  features = ["phase2"] }
+pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3",  features = ["phase2"] }
 reqwest = "0.12.12"
 hex = "0.4.3"
 metrics = { version = "0.24.1", default-features = false }
diff --git a/src/cbor/evaluate.rs b/src/cbor/evaluate.rs
index e179ba70..65b1b9b6 100644
--- a/src/cbor/evaluate.rs
+++ b/src/cbor/evaluate.rs
@@ -28,6 +28,7 @@ use crate::BlockfrostError;
 use crate::NodePool;
 use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
 use crate::api::utils::txs::evaluate::model::Value;
+use crate::common::convert_bigint;
 use pallas_codec::utils::CborWrap;
 use pallas_primitives::{
     KeepRaw,
@@ -67,7 +68,7 @@ pub async fn evaluate_tx(
     match node.genesis_config_and_pp().await {
         Ok((genesis_config, protocol_params)) => {
             let protocol_params: MultiEraProtocolParameters =
-                convert_protocol_param(protocol_params, genesis_config);
+                convert_protocol_param(protocol_params, genesis_config)?;
             /*
              * Prepare transaction
              */
@@ -200,12 +201,18 @@ fn parse_asset_string(str: &str) -> (PolicyId, AssetName) {
     )
 }
 
-fn convert_system_start(sys_start: SystemStart) -> chrono::DateTime<chrono::FixedOffset> {
-    let naive_date = NaiveDate::from_yo_opt(sys_start.year as i32, sys_start.day_of_year)
-        .expect("Invalid system start date");
+fn convert_system_start(
+    sys_start: SystemStart,
+) -> Result<chrono::DateTime<chrono::FixedOffset>, BlockfrostError> {
+    let naive_date = NaiveDate::from_yo_opt(
+        convert_bigint(sys_start.year)? as i32,
+        sys_start.day_of_year as u32,
+    )
+    .expect("Invalid system start date");
 
-    let secs = (sys_start.picoseconds_of_day / 1_000_000_000_000) as u32;
-    let nano = ((sys_start.picoseconds_of_day % 1_000_000_000_000) / 1000) as u32;
+    let picoseconds_of_day = convert_bigint(sys_start.picoseconds_of_day)?;
+    let secs = (picoseconds_of_day / 1_000_000_000_000) as u32;
+    let nano = ((picoseconds_of_day % 1_000_000_000_000) / 1000) as u32;
 
     let naive_time =
         NaiveTime::from_num_seconds_from_midnight_opt(secs, nano).expect("Invalid time");
@@ -215,13 +222,16 @@ fn convert_system_start(sys_start: SystemStart) -> chrono::DateTime<chrono::Fixe
     // Convert to DateTime with UTC timezone (zero offset)
     let utc_offset = chrono::FixedOffset::east_opt(0).expect("Invalid offset");
 
-    DateTime::from_naive_utc_and_offset(naive_date_time, utc_offset)
+    Ok(DateTime::from_naive_utc_and_offset(
+        naive_date_time,
+        utc_offset,
+    ))
 }
 
 fn convert_protocol_param(
     pp: CurrentProtocolParam,
     genesis: GenesisConfig,
-) -> MultiEraProtocolParameters {
+) -> Result<MultiEraProtocolParameters, BlockfrostError> {
     // Create a Conway protocol parameters struct from the ProtocolParam and GenesisConfig
     let conway_pp: ConwayProtParams = ConwayProtParams {
         minfee_a: pp.minfee_a.unwrap() as u32,
@@ -229,7 +239,7 @@ fn convert_protocol_param(
         max_block_body_size: pp.max_block_body_size.unwrap() as u32,
         max_transaction_size: pp.max_transaction_size.unwrap() as u32,
         max_block_header_size: pp.max_block_header_size.unwrap() as u32,
-        system_start: convert_system_start(genesis.system_start),
+        system_start: convert_system_start(genesis.system_start)?,
         epoch_length: genesis.epoch_length as u64,
         slot_length: genesis.slot_length as u64,
         desired_number_of_stake_pools: pp.desired_number_of_stake_pools.unwrap() as u32,
@@ -384,7 +394,7 @@ fn convert_protocol_param(
         drep_inactivity_period: pp.drep_inactivity_period.unwrap(),
     };
 
-    MultiEraProtocolParameters::Conway(conway_pp)
+    Ok(MultiEraProtocolParameters::Conway(conway_pp))
 }
 
 #[cfg(test)]
@@ -393,6 +403,7 @@ mod tests {
     use chrono::{Datelike, Timelike};
 
     use pallas_codec::utils::AnyUInt;
+    use pallas_network::miniprotocols::localstate::queries_v16::BigInt;
     use pallas_network::miniprotocols::localstate::queries_v16::{self, Fraction};
 
     use super::*;
@@ -401,11 +412,11 @@ mod tests {
     fn test_convert_system_start() {
         // Test case 1: Standard date
         let sys_start = SystemStart {
-            year: 2023,
+            year: BigInt::from(2023),
             day_of_year: 100,
-            picoseconds_of_day: 43_200_000_000_000_000, // 12 hours
+            picoseconds_of_day: BigInt::from(43_200_000_000_000_000i64), // 12 hours
         };
-        let result = convert_system_start(sys_start);
+        let result = convert_system_start(sys_start).unwrap();
         assert_eq!(result.year(), 2023);
         assert_eq!(result.ordinal(), 100);
         assert_eq!(result.hour(), 12);
@@ -414,11 +425,11 @@ mod tests {
 
         // Test case 2: Year boundary
         let sys_start = SystemStart {
-            year: 2024,
+            year: BigInt::from(2024),
             day_of_year: 1,
-            picoseconds_of_day: 3_600_000_000_000_000, // 1 hour
+            picoseconds_of_day: BigInt::from(3_600_000_000_000_000i64), // 1 hour
         };
-        let result = convert_system_start(sys_start);
+        let result = convert_system_start(sys_start).unwrap();
         assert_eq!(result.year(), 2024);
         assert_eq!(result.ordinal(), 1);
         assert_eq!(result.hour(), 1);
@@ -427,11 +438,11 @@ mod tests {
 
         // Test case 3: Leap year
         let sys_start = SystemStart {
-            year: 2024,
+            year: BigInt::from(2024),
             day_of_year: 366,
-            picoseconds_of_day: 0, // midnight
+            picoseconds_of_day: BigInt::from(0), // midnight
         };
-        let result = convert_system_start(sys_start);
+        let result = convert_system_start(sys_start).unwrap();
         assert_eq!(result.year(), 2024);
         assert_eq!(result.ordinal(), 366);
         assert_eq!(result.hour(), 0);
@@ -440,11 +451,11 @@ mod tests {
 
         // Test case 4: Partial seconds
         let sys_start = SystemStart {
-            year: 2023,
+            year: BigInt::from(2023),
             day_of_year: 200,
-            picoseconds_of_day: 63_123_000_000_000_000, // 17:32:03
+            picoseconds_of_day: BigInt::from(63_123_000_000_000_000i64), // 17:32:03
         };
-        let result = convert_system_start(sys_start);
+        let result = convert_system_start(sys_start).unwrap();
         assert_eq!(result.year(), 2023);
         assert_eq!(result.ordinal(), 200);
         assert_eq!(result.hour(), 17);
@@ -457,9 +468,9 @@ mod tests {
         // Create minimal test data with required fields
         let genesis = GenesisConfig {
             system_start: SystemStart {
-                year: 2023,
+                year: BigInt::from(2023),
                 day_of_year: 100,
-                picoseconds_of_day: 43_200_000_000_000_000, // 12 hours
+                picoseconds_of_day: BigInt::from(43_200_000_000_000_000i64), // 12 hours
             },
             epoch_length: 432000,
             slot_length: 1,
@@ -604,7 +615,7 @@ mod tests {
         };
 
         // Convert protocol parameters
-        let result = convert_protocol_param(pp, genesis);
+        let result = convert_protocol_param(pp, genesis).unwrap();
 
         // Verify the result is a Conway protocol parameters
         if let MultiEraProtocolParameters::Conway(conway_pp) = result {
@@ -645,8 +656,6 @@ mod tests {
             assert_eq!(conway_pp.drep_deposit, 2_000_000);
             assert_eq!(conway_pp.min_committee_size, 3);
             assert_eq!(conway_pp.committee_term_limit, 4);
-        } else {
-            panic!("Expected Conway protocol parameters");
         }
     }
 }
diff --git a/src/common.rs b/src/common.rs
index 0a93015c..ac287644 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -1,5 +1,6 @@
 use crate::BlockfrostError;
 use axum::http::{HeaderMap, header::CONTENT_TYPE};
+use pallas_network::miniprotocols::localstate::queries_v16::BigInt;
 
 /// Helper to validate content type or return custom BlockfrostError 400
 ///   Arguments:
@@ -49,6 +50,14 @@ pub fn binary_or_hex_heuristic(xs: &[u8]) -> Vec<u8> {
     }
 }
 
+pub fn convert_bigint(bigint: BigInt) -> Result<i128, BlockfrostError> {
+    match bigint {
+        BigInt::Int(big) => Ok(i128::from(big)),
+        _ => Err(BlockfrostError::internal_server_error(
+            "Invalid/unsupported BigInt format".to_string(),
+        )),
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/node/sync_progress.rs b/src/node/sync_progress.rs
index 3439bc78..b9223a6a 100644
--- a/src/node/sync_progress.rs
+++ b/src/node/sync_progress.rs
@@ -1,5 +1,5 @@
 use super::connection::NodeClient;
-use crate::BlockfrostError;
+use crate::{BlockfrostError, common::convert_bigint};
 use chrono::{Duration, TimeZone, Utc};
 use pallas_network::{miniprotocols, miniprotocols::localstate};
 use pallas_traverse::wellknown;
@@ -40,9 +40,7 @@ impl NodeClient {
                 let chain_point = localstate::queries_v16::get_chain_point(generic_client).await?;
                 let slot = chain_point.slot_or_default();
 
-                let year: i32 = system_start.year.try_into().map_err(|e| {
-                    BlockfrostError::internal_server_error(format!("Failed to convert year: {}", e))
-                })?;
+                let year: i32 = convert_bigint(system_start.year)? as i32;
 
                 let base_date = Utc
                     .with_ymd_and_hms(year, 1, 1, 0, 0, 0)
@@ -51,9 +49,9 @@ impl NodeClient {
                         BlockfrostError::internal_server_error("Invalid base date".to_string())
                     })?;
 
-                let days = Duration::days((system_start.day_of_year - 1).into());
+                let days = Duration::days(system_start.day_of_year - 1);
 
-                let nanoseconds: i64 = (system_start.picoseconds_of_day / 1_000)
+                let nanoseconds: i64 = (convert_bigint(system_start.picoseconds_of_day)? / 1_000)
                     .try_into()
                     .map_err(|e| {
                         BlockfrostError::internal_server_error(format!(

From 52a6f761dc6a2210e777f431eb722b1d33599e4e Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Thu, 29 May 2025 15:03:30 +0200
Subject: [PATCH 04/22] chore: add missing compile-time dependencies

---
 Cargo.toml            | 8 ++++++--
 nix/devshells.nix     | 5 ++++-
 nix/internal/unix.nix | 9 ++++++---
 3 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 1151eadb..3d280449 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,7 +31,9 @@ sentry = "0.36.0"
 blake2 = "0.10.6"
 base64 = "0.22.1"
 num_cpus = "1"
-pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3",  features = ["phase2"] }
+pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
+  "phase2",
+] }
 pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
@@ -39,7 +41,9 @@ pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockf
 pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3",  features = ["phase2"] }
+pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
+  "phase2",
+] }
 reqwest = "0.12.12"
 hex = "0.4.3"
 metrics = { version = "0.24.1", default-features = false }
diff --git a/nix/devshells.nix b/nix/devshells.nix
index be8ee28f..81e16e0a 100644
--- a/nix/devshells.nix
+++ b/nix/devshells.nix
@@ -88,7 +88,10 @@ in {
 
   devshell = {
     packages =
-      [pkgs.unixtools.xxd]
+      [
+        pkgs.unixtools.xxd
+        pkgs.gnum4
+      ]
       ++ lib.optionals pkgs.stdenv.isLinux [
         pkgs.pkg-config
       ]
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 784f9edf..5332ef02 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -27,13 +27,16 @@ in
       {
         inherit src;
         strictDeps = true;
-        nativeBuildInputs = lib.optionals pkgs.stdenv.isLinux [
-          pkgs.pkg-config
-        ];
+        nativeBuildInputs =
+          [pkgs.gnum4]
+          ++ lib.optionals pkgs.stdenv.isLinux [
+            pkgs.pkg-config
+          ];
         TESTGEN_HS_PATH = lib.getExe testgen-hs; # Don’t try to download it in `build.rs`.
         buildInputs =
           lib.optionals pkgs.stdenv.isLinux [
             pkgs.openssl
+            pkgs.gnum4
           ]
           ++ lib.optionals pkgs.stdenv.isDarwin [
             pkgs.libiconv

From e45a90175175aa071533e8bcf7f1cb5fa01f005b Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Thu, 29 May 2025 16:27:40 +0200
Subject: [PATCH 05/22] chore: relax `cargo-deny`

---
 deny.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/deny.toml b/deny.toml
index 55a4d71e..e8792caf 100644
--- a/deny.toml
+++ b/deny.toml
@@ -5,6 +5,7 @@ allow = [
   "BSD-3-Clause",
   "CC0-1.0",
   "ISC",
+  "LGPL-3.0",
   "MIT",
   "Unicode-3.0",
   "MPL-2.0",

From bbf706a90d406e6ca7829a4c333392c52288937d Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Fri, 30 May 2025 10:28:12 +0200
Subject: [PATCH 06/22] chore: fix the OCI (Docker) build

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 22899df8..332c613f 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,5 @@
 FROM lukemathwalker/cargo-chef:0.1.68-rust-slim-bookworm AS base
-RUN apt-get update ; apt-get install sccache=0.4.* pkg-config=1.8.* libssl-dev=3.0.* bzip2=1.0.* -y --no-install-recommends \
+RUN apt-get update ; apt-get install build-essential m4=1.4.* sccache=0.4.* pkg-config=1.8.* libssl-dev=3.0.* bzip2=1.0.* -y --no-install-recommends \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 ENV RUSTC_WRAPPER=sccache SCCACHE_DIR=/sccache

From f06e1a0d51ca114e6ee82bdc66a4299aed229761 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Fri, 30 May 2025 10:38:21 +0200
Subject: [PATCH 07/22] chore: lint the Dockerfile

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 332c613f..a6cf3e81 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,5 @@
 FROM lukemathwalker/cargo-chef:0.1.68-rust-slim-bookworm AS base
-RUN apt-get update ; apt-get install build-essential m4=1.4.* sccache=0.4.* pkg-config=1.8.* libssl-dev=3.0.* bzip2=1.0.* -y --no-install-recommends \
+RUN apt-get update ; apt-get install build-essential=12.* m4=1.4.* sccache=0.4.* pkg-config=1.8.* libssl-dev=3.0.* bzip2=1.0.* -y --no-install-recommends \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 ENV RUSTC_WRAPPER=sccache SCCACHE_DIR=/sccache

From 581d7dee73b0ec621ce65940e579a5464587ce97 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C4=B1z=C4=B1r=20Sefa=20=C4=B0rken?= <sefairken@gmail.com>
Date: Wed, 18 Jun 2025 14:22:22 +0300
Subject: [PATCH 08/22] feat: Create compile config 'evaluate'

---
 Cargo.lock                  | 289 ++----------------------------------
 Cargo.toml                  |  11 +-
 build.rs                    |  66 +++++---
 nix/devshells.nix           |   3 +
 src/api/utils.rs            |   1 +
 src/api/utils/txs.rs        |   1 +
 src/cbor.rs                 |   4 +-
 src/server/routes/hidden.rs |  23 ++-
 tests/common.rs             |   1 +
 tests/endpoints.rs          |   1 +
 tests/tx_builder.rs         |   2 +-
 11 files changed, 88 insertions(+), 314 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 612e05fa..7c79d89e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -132,17 +132,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
-[[package]]
-name = "async-trait"
-version = "0.1.88"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -162,7 +151,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de45108900e1f9b9242f7f2e254aa3e2c029c921c258fe9e6b4217eeebd54288"
 dependencies = [
  "axum-core",
- "base64 0.22.1",
+ "base64",
  "bytes",
  "form_urlencoded",
  "futures-util",
@@ -239,12 +228,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6107fe1be6682a68940da878d9e9f5e90ca5745b3dec9fd1bb393c8777d4f581"
 
-[[package]]
-name = "base64"
-version = "0.21.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -288,7 +271,7 @@ dependencies = [
  "bitflags 2.9.0",
  "cexpr",
  "clang-sys",
- "itertools 0.13.0",
+ "itertools 0.10.5",
  "proc-macro2",
  "quote",
  "regex",
@@ -430,7 +413,7 @@ version = "0.0.2"
 dependencies = [
  "anyhow",
  "axum",
- "base64 0.22.1",
+ "base64",
  "bech32 0.9.1",
  "bip39",
  "blake2",
@@ -454,7 +437,6 @@ dependencies = [
  "metrics-exporter-prometheus",
  "metrics-process",
  "num_cpus",
- "pallas",
  "pallas-addresses",
  "pallas-codec",
  "pallas-crypto",
@@ -491,9 +473,9 @@ dependencies = [
 
 [[package]]
 name = "blst"
-version = "0.3.14"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47c79a94619fade3c0b887670333513a67ac28a6a7e653eb260bf0d4103db38d"
+checksum = "4fd49896f12ac9b6dcd7a5998466b9b58263a695a3dd1ecc1aaca2e12a90b080"
 dependencies = [
  "cc",
  "glob",
@@ -1142,12 +1124,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "fixedbitset"
-version = "0.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
-
 [[package]]
 name = "flate2"
 version = "1.1.1"
@@ -1624,7 +1600,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.58.0",
+ "windows-core 0.57.0",
 ]
 
 [[package]]
@@ -2041,7 +2017,7 @@ version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd7399781913e5393588a8d8c6a2867bf85fb38eaf2502fdce465aad2dc6f034"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "indexmap 2.9.0",
  "metrics",
  "metrics-util",
@@ -2176,12 +2152,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "multimap"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
-
 [[package]]
 name = "native-tls"
 version = "0.2.14"
@@ -2431,23 +2401,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
-[[package]]
-name = "pallas"
-version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
-dependencies = [
- "pallas-addresses",
- "pallas-codec",
- "pallas-configs",
- "pallas-crypto",
- "pallas-network",
- "pallas-primitives",
- "pallas-traverse",
- "pallas-txbuilder",
- "pallas-utxorpc",
- "pallas-validate",
-]
-
 [[package]]
 name = "pallas-addresses"
 version = "1.0.0-alpha.2"
@@ -2474,21 +2427,6 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "pallas-configs"
-version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
-dependencies = [
- "base64 0.22.1",
- "num-rational",
- "pallas-addresses",
- "pallas-crypto",
- "pallas-primitives",
- "serde",
- "serde_json",
- "serde_with",
-]
-
 [[package]]
 name = "pallas-crypto"
 version = "1.0.0-alpha.2"
@@ -2567,36 +2505,6 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "pallas-txbuilder"
-version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
-dependencies = [
- "hex",
- "pallas-addresses",
- "pallas-codec",
- "pallas-crypto",
- "pallas-primitives",
- "pallas-traverse",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "pallas-utxorpc"
-version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
-dependencies = [
- "pallas-codec",
- "pallas-crypto",
- "pallas-primitives",
- "pallas-traverse",
- "pallas-validate",
- "prost-types",
- "utxorpc-spec",
-]
-
 [[package]]
 name = "pallas-validate"
 version = "1.0.0-alpha.2"
@@ -2657,43 +2565,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
-[[package]]
-name = "pbjson"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7e6349fa080353f4a597daffd05cb81572a9c031a6d4fff7e504947496fcc68"
-dependencies = [
- "base64 0.21.7",
- "serde",
-]
-
-[[package]]
-name = "pbjson-build"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eea3058763d6e656105d1403cb04e0a41b7bbac6362d413e7c33be0c32279c9"
-dependencies = [
- "heck 0.5.0",
- "itertools 0.13.0",
- "prost",
- "prost-types",
-]
-
-[[package]]
-name = "pbjson-types"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e54e5e7bfb1652f95bc361d76f3c780d8e526b134b85417e774166ee941f0887"
-dependencies = [
- "bytes",
- "chrono",
- "pbjson",
- "pbjson-build",
- "prost",
- "prost-build",
- "serde",
-]
-
 [[package]]
 name = "pbkdf2"
 version = "0.11.0"
@@ -2712,36 +2583,6 @@ version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
-[[package]]
-name = "petgraph"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
-dependencies = [
- "fixedbitset",
- "indexmap 2.9.0",
-]
-
-[[package]]
-name = "pin-project"
-version = "1.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
-dependencies = [
- "pin-project-internal",
-]
-
-[[package]]
-name = "pin-project-internal"
-version = "1.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
@@ -2791,16 +2632,6 @@ dependencies = [
  "yansi",
 ]
 
-[[package]]
-name = "prettyplease"
-version = "0.2.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
-dependencies = [
- "proc-macro2",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "proc-macro-crate"
 version = "3.3.0"
@@ -2861,58 +2692,6 @@ dependencies = [
  "unarray",
 ]
 
-[[package]]
-name = "prost"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-build"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
-dependencies = [
- "heck 0.5.0",
- "itertools 0.14.0",
- "log",
- "multimap",
- "once_cell",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn 2.0.100",
- "tempfile",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
-dependencies = [
- "anyhow",
- "itertools 0.14.0",
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
-dependencies = [
- "prost",
-]
-
 [[package]]
 name = "psm"
 version = "0.1.26"
@@ -3214,7 +2993,7 @@ version = "0.12.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43e734407157c3c2034e0258f5e4473ddb361b1e85f95a66690d67264d7cd1da"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "bytes",
  "encoding_rs",
  "futures-channel",
@@ -3716,7 +3495,7 @@ version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "chrono",
  "hex",
  "indexmap 1.9.3",
@@ -4161,17 +3940,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-stream"
-version = "0.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "tokio-tungstenite"
 version = "0.26.2"
@@ -4240,27 +4008,6 @@ dependencies = [
  "winnow",
 ]
 
-[[package]]
-name = "tonic"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52"
-dependencies = [
- "async-trait",
- "base64 0.22.1",
- "bytes",
- "http",
- "http-body",
- "http-body-util",
- "percent-encoding",
- "pin-project",
- "prost",
- "tokio-stream",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "tower"
 version = "0.5.2"
@@ -4509,7 +4256,7 @@ version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "log",
  "native-tls",
  "once_cell",
@@ -4552,22 +4299,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
-[[package]]
-name = "utxorpc-spec"
-version = "0.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7148c5cd211c397a41245cfbd8d4cb8371d748ed5e3cf131ebcd9cacfa794206"
-dependencies = [
- "bytes",
- "futures-core",
- "pbjson",
- "pbjson-types",
- "prost",
- "prost-types",
- "serde",
- "tonic",
-]
-
 [[package]]
 name = "uuid"
 version = "1.16.0"
diff --git a/Cargo.toml b/Cargo.toml
index 3d280449..fd8d2e98 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,9 +31,6 @@ sentry = "0.36.0"
 blake2 = "0.10.6"
 base64 = "0.22.1"
 num_cpus = "1"
-pallas = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
-  "phase2",
-] }
 pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
@@ -41,9 +38,6 @@ pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockf
 pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
 pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
-  "phase2",
-] }
 reqwest = "0.12.12"
 hex = "0.4.3"
 metrics = { version = "0.24.1", default-features = false }
@@ -63,6 +57,11 @@ blockfrost-openapi = "0.1.75"
 bech32 = "0.9.1"
 cardano-serialization-lib = "12.1.1"
 
+[target.'cfg(not(any(target_os = "windows", all(target_os = "linux", target_arch = "aarch64"))))'.dependencies]
+pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
+  "phase2",
+] }
+
 [features]
 tarpaulin = []
 
diff --git a/build.rs b/build.rs
index 17dc484a..6d2c92ed 100644
--- a/build.rs
+++ b/build.rs
@@ -1,8 +1,33 @@
 fn main() {
+    let os = target_os();
+    let arch = target_arch();
+
     git_revision::set();
-    testgen_hs::ensure();
+    features::evaluate(os, arch);
+    testgen_hs::ensure(os, arch);
+}
+
+fn target_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");
+    }) as _
 }
 
+fn target_arch() -> &'static str {
+    (if cfg!(target_arch = "x86_64") {
+        "x86_64"
+    } else if cfg!(target_arch = "aarch64") {
+        "aarch64"
+    } else {
+        panic!("Unsupported architecture");
+    }) as _
+}
 mod git_revision {
     use std::env;
 
@@ -50,7 +75,7 @@ mod testgen_hs {
 
     const TESTGEN_HS_PATH: &str = "TESTGEN_HS_PATH";
 
-    pub fn ensure() {
+    pub fn ensure(target_os: &str, arch: &str) {
         if env::var(TESTGEN_HS_PATH).is_ok() {
             println!(
                 "Environment variable {} is set. Skipping the download.",
@@ -61,24 +86,6 @@ mod testgen_hs {
 
         let testgen_lib_version = "10.4.1.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 arch = if cfg!(target_arch = "x86_64") {
-            "x86_64"
-        } else if cfg!(target_arch = "aarch64") {
-            "aarch64"
-        } else {
-            panic!("Unsupported architecture");
-        };
-
         let suffix = if target_os == "windows" {
             ".zip"
         } else {
@@ -227,3 +234,22 @@ mod testgen_hs {
         }
     }
 }
+
+mod features {
+    pub fn evaluate(target_os: &str, target_arch: &str) {
+        println!("cargo::rustc-check-cfg=cfg(evaluate)");
+
+        if (target_os == "linux" && target_arch == "aarch64") || target_os == "windows" {
+            println!(
+                "cargo:warning=Skipping 'evaluate' cfg for {}-{}",
+                target_os, target_arch
+            );
+        } else {
+            println!(
+                "cargo:warning=Going to build with 'evaluate' cfg for {}-{}",
+                target_os, target_arch
+            );
+            println!("cargo:rustc-cfg=evaluate");
+        }
+    }
+}
diff --git a/nix/devshells.nix b/nix/devshells.nix
index 81e16e0a..e5e31cec 100644
--- a/nix/devshells.nix
+++ b/nix/devshells.nix
@@ -91,6 +91,9 @@ in {
       [
         pkgs.unixtools.xxd
         pkgs.gnum4
+        pkgs.gnumake
+        pkgs.gawk
+        pkgs.diffutils
       ]
       ++ lib.optionals pkgs.stdenv.isLinux [
         pkgs.pkg-config
diff --git a/src/api/utils.rs b/src/api/utils.rs
index e9dad824..02060e91 100644
--- a/src/api/utils.rs
+++ b/src/api/utils.rs
@@ -1 +1,2 @@
+#[cfg(evaluate)]
 pub mod txs;
diff --git a/src/api/utils/txs.rs b/src/api/utils/txs.rs
index 98a84498..67a328e5 100644
--- a/src/api/utils/txs.rs
+++ b/src/api/utils/txs.rs
@@ -1 +1,2 @@
+#[cfg(evaluate)]
 pub mod evaluate;
diff --git a/src/cbor.rs b/src/cbor.rs
index 0b8668da..29e50230 100644
--- a/src/cbor.rs
+++ b/src/cbor.rs
@@ -1,6 +1,6 @@
-pub mod fallback_decoder;
-
+#[cfg(evaluate)]
 pub mod evaluate;
+pub mod fallback_decoder;
 #[cfg(test)]
 pub mod tests;
 pub(crate) mod validation;
diff --git a/src/server/routes/hidden.rs b/src/server/routes/hidden.rs
index addfb35c..3e9e6801 100644
--- a/src/server/routes/hidden.rs
+++ b/src/server/routes/hidden.rs
@@ -1,6 +1,8 @@
+#[cfg(evaluate)]
+use crate::api::utils;
 use crate::api::{
     accounts, addresses, assets, blocks, epochs, governance, health, ledger, metadata, network,
-    pools, scripts, tx, txs, utils,
+    pools, scripts, tx, txs,
 };
 use crate::middlewares::metrics::track_http_metrics;
 use crate::server::state::AppState;
@@ -132,11 +134,20 @@ pub fn get_hidden_api_routes(enable_metrics: bool) -> Router<AppState> {
         .route("/txs/{hash}/metadata/cbor", get(txs::hash::metadata::cbor::route))
         .route("/txs/{hash}/redeemers", get(txs::hash::redeemers::route))
         .route("/txs/{hash}/required_signers", get(txs::hash::required_signers::route))
-        .route("/txs/{hash}/cbor", get(txs::hash::cbor::route))
-
-        // utils
-        .route("/utils/tx/evaluate", post(utils::txs::evaluate::root::route))
-        .route("/utils/tx/evaluate/utxos", post(utils::txs::evaluate::utxos::route));
+        .route("/txs/{hash}/cbor", get(txs::hash::cbor::route));
+
+    #[cfg(evaluate)]
+    {
+        router = router
+            .route(
+                "/utils/tx/evaluate",
+                post(utils::txs::evaluate::root::route),
+            )
+            .route(
+                "/utils/tx/evaluate/utxos",
+                post(utils::txs::evaluate::utxos::route),
+            );
+    }
 
     if enable_metrics {
         router = router.route_layer(from_fn(track_http_metrics));
diff --git a/tests/common.rs b/tests/common.rs
index 697b6214..2c494e08 100644
--- a/tests/common.rs
+++ b/tests/common.rs
@@ -27,6 +27,7 @@ pub async fn initialize_app() -> Router {
     app
 }
 
+#[allow(dead_code)]
 pub fn get_blockfrost_client() -> BlockfrostAPI {
     let settings = BlockFrostSettings::default();
 
diff --git a/tests/endpoints.rs b/tests/endpoints.rs
index c90a07e3..6630675a 100644
--- a/tests/endpoints.rs
+++ b/tests/endpoints.rs
@@ -3,5 +3,6 @@ mod common;
 mod tx_builder;
 
 pub mod api {
+    #[cfg(evaluate)]
     pub mod utils;
 }
diff --git a/tests/tx_builder.rs b/tests/tx_builder.rs
index 16c38b32..e138e287 100644
--- a/tests/tx_builder.rs
+++ b/tests/tx_builder.rs
@@ -11,7 +11,7 @@ use cardano_serialization_lib::{
     TransactionUnspentOutput, TransactionUnspentOutputs, TransactionWitnessSet, Vkeywitnesses,
     hash_transaction, make_vkey_witness,
 };
-
+#[allow(dead_code)]
 pub async fn build_tx(blockfrost_client: &BlockfrostAPI) -> Result<Transaction> {
     let output_amount = BigNum::from_str("1000000");
     let mnemonic = "bright despair immune pause column saddle legal minimum erode thank silver ordinary pet next symptom second grow chapter fiber donate humble syrup glad early";

From c177b7af9f4d1109682259e7db31203b32a25914 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 14:25:04 +0200
Subject: [PATCH 09/22] =?UTF-8?q?fix:=20`aarch64-linux`=20compilation=20of?=
 =?UTF-8?q?=20Pallas=E2=80=99=20`phase2`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Cargo.toml                                    |   2 +-
 build.rs                                      |   2 +-
 flake.nix                                     |   8 +-
 nix/internal/linux-cross-arm64.nix            |  92 -------------
 .../testgen-hs--enable-aarch64-linux.diff     | 124 ++++++++++++++++++
 nix/internal/unix.nix                         |  19 ++-
 6 files changed, 146 insertions(+), 101 deletions(-)
 delete mode 100644 nix/internal/linux-cross-arm64.nix
 create mode 100644 nix/internal/testgen-hs--enable-aarch64-linux.diff

diff --git a/Cargo.toml b/Cargo.toml
index fd8d2e98..cc0dd054 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -57,7 +57,7 @@ blockfrost-openapi = "0.1.75"
 bech32 = "0.9.1"
 cardano-serialization-lib = "12.1.1"
 
-[target.'cfg(not(any(target_os = "windows", all(target_os = "linux", target_arch = "aarch64"))))'.dependencies]
+[target.'cfg(not(target_os = "windows"))'.dependencies]
 pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
   "phase2",
 ] }
diff --git a/build.rs b/build.rs
index 6d2c92ed..69ad8e53 100644
--- a/build.rs
+++ b/build.rs
@@ -239,7 +239,7 @@ mod features {
     pub fn evaluate(target_os: &str, target_arch: &str) {
         println!("cargo::rustc-check-cfg=cfg(evaluate)");
 
-        if (target_os == "linux" && target_arch == "aarch64") || target_os == "windows" {
+        if target_os == "windows" {
             println!(
                 "cargo:warning=Skipping 'evaluate' cfg for {}-{}",
                 target_os, target_arch
diff --git a/flake.nix b/flake.nix
index a1224f05..6484277f 100644
--- a/flake.nix
+++ b/flake.nix
@@ -36,7 +36,7 @@
 
       systems = [
         "x86_64-linux"
-        # "aarch64-linux"
+        "aarch64-linux"
         "aarch64-darwin"
         "x86_64-darwin"
       ];
@@ -51,7 +51,6 @@
           }
           // (lib.optionalAttrs (system == "x86_64-linux") {
             blockfrost-platform-x86_64-windows = inputs.self.internal.x86_64-windows.package;
-            blockfrost-platform-aarch64-linux = inputs.self.internal.aarch64-linux.package;
           });
 
         devshells.default = import ./nix/devshells.nix {inherit inputs;};
@@ -113,9 +112,6 @@
           )
           // lib.genAttrs ["x86_64-windows"] (
             targetSystem: import ./nix/internal/windows.nix {inherit inputs targetSystem;}
-          )
-          // lib.genAttrs ["aarch64-linux"] (
-            targetSystem: import ./nix/internal/linux-cross-arm64.nix {inherit inputs targetSystem;}
           );
 
         nixosModule = {
@@ -128,7 +124,7 @@
         };
 
         hydraJobs = let
-          crossSystems = ["x86_64-windows" "aarch64-linux"];
+          crossSystems = ["x86_64-windows"];
           allJobs = {
             blockfrost-platform = lib.genAttrs (config.systems ++ crossSystems) (
               targetSystem: inputs.self.internal.${targetSystem}.package
diff --git a/nix/internal/linux-cross-arm64.nix b/nix/internal/linux-cross-arm64.nix
deleted file mode 100644
index 0c29fa48..00000000
--- a/nix/internal/linux-cross-arm64.nix
+++ /dev/null
@@ -1,92 +0,0 @@
-{
-  inputs,
-  targetSystem,
-}:
-assert builtins.elem targetSystem ["aarch64-linux"]; let
-  buildSystem = "x86_64-linux";
-  pkgs = inputs.nixpkgs.legacyPackages.${buildSystem};
-in rec {
-  toolchain = with inputs.fenix.packages.${buildSystem};
-    combine [
-      minimal.rustc
-      minimal.cargo
-      targets.aarch64-unknown-linux-gnu.latest.rust-std
-    ];
-
-  craneLib = (inputs.crane.mkLib pkgs).overrideToolchain toolchain;
-
-  src = craneLib.cleanCargoSource ../../.;
-
-  pkgsCross = pkgs.pkgsCross.aarch64-multiplatform;
-
-  commonArgs = rec {
-    inherit src;
-    strictDeps = true;
-
-    CARGO_BUILD_TARGET = "aarch64-unknown-linux-gnu";
-    TARGET_CC = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
-
-    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = TARGET_CC;
-
-    TESTGEN_HS_PATH = "unused"; # Don’t try to download it in `build.rs`.
-
-    OPENSSL_DIR = "${pkgsCross.openssl.dev}";
-    OPENSSL_LIB_DIR = "${pkgsCross.openssl.out}/lib";
-    OPENSSL_INCLUDE_DIR = "${pkgsCross.openssl.dev}/include/";
-
-    depsBuildBuild = [
-      pkgsCross.stdenv.cc
-      #pkgsCross.windows.pthreads
-    ];
-  };
-
-  # For better caching:
-  cargoArtifacts = craneLib.buildDepsOnly commonArgs;
-
-  packageName = (craneLib.crateNameFromCargoToml {cargoToml = src + "/Cargo.toml";}).pname;
-
-  GIT_REVISION = inputs.self.rev or "dirty";
-
-  package = craneLib.buildPackage (commonArgs
-    // {
-      inherit cargoArtifacts GIT_REVISION;
-      doCheck = false;
-      postPatch = ''
-        sed -r '/^build = .*/d' -i Cargo.toml
-        rm build.rs
-      '';
-    });
-
-  archive = let
-    outFileName = "${package.pname}-${package.version}-${inputs.self.shortRev or "dirty"}-${targetSystem}.tar.bz2";
-  in
-    pkgs.runCommandNoCC "${package.pname}-archive" {} ''
-      cp -r ${bundle} ${package.pname}
-
-      mkdir -p $out
-      tar -cjvf $out/${outFileName} ${package.pname}/
-
-      # Make it downloadable from Hydra:
-      mkdir -p $out/nix-support
-      echo "file binary-dist \"$out/${outFileName}\"" >$out/nix-support/hydra-build-products
-    '';
-
-  nix-bundle-exe = import inputs.nix-bundle-exe;
-
-  # Portable directory that can be run on any modern Linux:
-  bundle =
-    (nix-bundle-exe {
-      inherit pkgs;
-      bin_dir = "bin";
-      exe_dir = "exe";
-      lib_dir = "lib";
-    } "${package}/bin/${packageName}")
-    .overrideAttrs (drv: {
-      name = packageName;
-      buildCommand =
-        drv.buildCommand
-        + ''
-          ( cd $out ; ln -s bin/${packageName} . ; )
-        '';
-    });
-}
diff --git a/nix/internal/testgen-hs--enable-aarch64-linux.diff b/nix/internal/testgen-hs--enable-aarch64-linux.diff
new file mode 100644
index 00000000..dfbdf727
--- /dev/null
+++ b/nix/internal/testgen-hs--enable-aarch64-linux.diff
@@ -0,0 +1,124 @@
+diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
+index 197c881..59ce8cc 100644
+--- a/.github/workflows/release.yml
++++ b/.github/workflows/release.yml
+@@ -30,6 +30,10 @@ jobs:
+             result-archive-x86_64-linux \
+             .#hydraJobs.testgen-hs.x86_64-linux
+ 
++          nix build -L --builders '' --max-jobs 0 --out-link \
++            result-archive-aarch64-linux \
++            .#hydraJobs.testgen-hs.aarch64-linux
++
+           nix build -L --builders '' --max-jobs 0 --out-link \
+             result-archive-x86_64-windows \
+             .#hydraJobs.testgen-hs.x86_64-windows
+@@ -48,6 +52,7 @@ jobs:
+         with:
+           files: |
+             result-archive-x86_64-linux/*.tar.bz2
++            result-archive-aarch64-linux/*.tar.bz2
+             result-archive-x86_64-darwin/*.tar.bz2
+             result-archive-aarch64-darwin/*.tar.bz2
+             result-archive-x86_64-windows/*.zip
+diff --git a/.github/workflows/upload.yml b/.github/workflows/upload.yml
+index e54ea87..6c3f02b 100644
+--- a/.github/workflows/upload.yml
++++ b/.github/workflows/upload.yml
+@@ -22,6 +22,7 @@ jobs:
+         run: |
+           set -euo pipefail
+           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-linux   && cp result/testgen-hs-*.* .
++          nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.aarch64-linux  && cp result/testgen-hs-*.* .
+           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-windows && cp result/testgen-hs-*.* .
+           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-darwin  && cp result/testgen-hs-*.* .
+           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.aarch64-darwin && cp result/testgen-hs-*.* .
+@@ -49,6 +50,12 @@ jobs:
+           name: testgen-hs-${{ env.version }}-x86_64-linux.tar.bz2
+           path: testgen-hs-${{ env.version }}-x86_64-linux.tar.bz2
+           if-no-files-found: error
++      - name: Upload Artifact (aarch64-linux)
++        uses: actions/upload-artifact@v4
++        with:
++          name: testgen-hs-${{ env.version }}-aarch64-linux.tar.bz2
++          path: testgen-hs-${{ env.version }}-aarch64-linux.tar.bz2
++          if-no-files-found: error
+       - name: Upload Artifact (x86_64-windows)
+         uses: actions/upload-artifact@v4
+         with:
+diff --git a/flake.nix b/flake.nix
+index 72d2f8f..b192741 100644
+--- a/flake.nix
++++ b/flake.nix
+@@ -28,7 +28,7 @@
+           targetSystem: import ./nix/internal.nix {inherit inputs targetSystem;}
+         );
+ 
+-      systems = ["x86_64-linux" "aarch64-darwin" "x86_64-darwin"];
++      systems = ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86_64-darwin"];
+       perSystem = {
+         config,
+         system,
+diff --git a/nix/internal.nix b/nix/internal.nix
+index 51248ac..32b65f7 100644
+--- a/nix/internal.nix
++++ b/nix/internal.nix
+@@ -13,11 +13,29 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
+ in rec {
+   defaultPackage = testgen-hs;
+ 
+-  cardano-node-flake = (import inputs.flake-compat {src = inputs.cardano-node;}).defaultNix;
++  cardano-node-flake = let
++    unpatched = inputs.cardano-node;
++  in
++    (import inputs.flake-compat {
++      src =
++        if targetSystem != "aarch64-linux"
++        then unpatched
++        else {
++          outPath = toString (pkgs.runCommand "source" {} ''
++            cp -r ${unpatched} $out
++            chmod -R +w $out
++            cd $out
++            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
++          '');
++          inherit (unpatched) rev shortRev lastModified lastModifiedDate;
++        };
++    })
++    .defaultNix;
+ 
+   cardano-node-packages =
+     {
+       x86_64-linux = cardano-node-flake.hydraJobs.x86_64-linux.musl;
++      aarch64-linux = cardano-node-flake.hydraJobs.aarch64-linux.musl;
+       x86_64-darwin = cardano-node-flake.packages.x86_64-darwin;
+       aarch64-darwin = cardano-node-flake.packages.aarch64-darwin;
+     }
+@@ -25,7 +43,6 @@ in rec {
+ 
+   inherit (cardano-node-packages) cardano-node cardano-cli;
+ 
+-  testgen-hs = let
+     patched-flake = let
+       unpatched = inputs.cardano-node;
+     in
+@@ -48,9 +65,11 @@ in rec {
+         };
+       })
+       .defaultNix;
++  testgen-hs = let
+   in
+     {
+       x86_64-linux = patched-flake.hydraJobs.x86_64-linux.musl.testgen-hs;
++      aarch64-linux = patched-flake.project.aarch64-linux.projectCross.aarch64-multiplatform-musl.packages.testgen-hs.components.exes.testgen-hs;
+       x86_64-darwin = patched-flake.packages.x86_64-darwin.testgen-hs;
+       aarch64-darwin = patched-flake.packages.aarch64-darwin.testgen-hs;
+       x86_64-windows = patched-flake.legacyPackages.x86_64-linux.hydraJobs.windows.testgen-hs;
+@@ -113,6 +132,7 @@ in rec {
+       aarch64-darwin = darwinLike;
+       x86_64-darwin = darwinLike;
+       x86_64-linux = linuxLike {};
++      aarch64-linux = linuxLike {};
+       x86_64-windows = linuxLike {useZip = true;};
+     }
+     .${targetSystem};
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 5332ef02..c13bfe32 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -212,7 +212,24 @@ in
         done
       '';
 
-    testgen-hs-flake = (import inputs.flake-compat {src = inputs.testgen-hs;}).defaultNix;
+    testgen-hs-flake = let
+      unpatched = inputs.testgen-hs;
+    in
+      (import inputs.flake-compat {
+        src =
+          if targetSystem != "aarch64-linux"
+          then unpatched
+          else {
+            outPath = toString (pkgs.runCommand "source" {} ''
+              cp -r ${unpatched} $out
+              chmod -R +w $out
+              cd $out
+              patch -p1 -i ${./testgen-hs--enable-aarch64-linux.diff}
+            '');
+            inherit (unpatched) rev shortRev lastModified lastModifiedDate;
+          };
+      })
+      .defaultNix;
 
     testgen-hs = testgen-hs-flake.packages.${targetSystem}.default;
 

From d719558cfee2920176a4552845992dd4241bfb33 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 14:49:21 +0200
Subject: [PATCH 10/22] fix: a silly redirection bug

---
 nix/internal/testgen-hs--enable-aarch64-linux.diff | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/nix/internal/testgen-hs--enable-aarch64-linux.diff b/nix/internal/testgen-hs--enable-aarch64-linux.diff
index dfbdf727..814f2207 100644
--- a/nix/internal/testgen-hs--enable-aarch64-linux.diff
+++ b/nix/internal/testgen-hs--enable-aarch64-linux.diff
@@ -60,7 +60,7 @@ index 72d2f8f..b192741 100644
          config,
          system,
 diff --git a/nix/internal.nix b/nix/internal.nix
-index 51248ac..32b65f7 100644
+index 51248ac..09382ab 100644
 --- a/nix/internal.nix
 +++ b/nix/internal.nix
 @@ -13,11 +13,29 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
@@ -102,6 +102,15 @@ index 51248ac..32b65f7 100644
      patched-flake = let
        unpatched = inputs.cardano-node;
      in
+@@ -35,7 +52,7 @@ in rec {
+             cp -r ${unpatched} $out
+             chmod -R +w $out
+             cd $out
+-            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
++            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} >$out/nix/supported-systems.nix
+             cp -r ${../testgen-hs} ./testgen-hs
+             sed -r '/^packages:/ a\  testgen-hs' -i cabal.project
+             sed -r 's/other-modules:\s*/                    , /g' -i cardano-submit-api/cardano-submit-api.cabal
 @@ -48,9 +65,11 @@ in rec {
          };
        })

From d99849e3bc3af53d73cbdc527882289a31c33dac Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 15:17:56 +0200
Subject: [PATCH 11/22] fix: `cargo-clippy` issues

---
 build.rs | 34 +++++++++++++---------------------
 1 file changed, 13 insertions(+), 21 deletions(-)

diff --git a/build.rs b/build.rs
index 69ad8e53..67e95fa8 100644
--- a/build.rs
+++ b/build.rs
@@ -37,7 +37,7 @@ mod git_revision {
         use std::process::Command;
 
         if env::var(GIT_REVISION).is_ok() {
-            println!("Environment variable {} is set. Not setting.", GIT_REVISION);
+            println!("Environment variable {GIT_REVISION} is set. Not setting.");
             return;
         }
 
@@ -58,7 +58,7 @@ mod git_revision {
                 .to_string()
         };
 
-        println!("cargo:rustc-env={}={}", GIT_REVISION, revision);
+        println!("cargo:rustc-env={GIT_REVISION}={revision}");
     }
 }
 
@@ -77,10 +77,7 @@ mod testgen_hs {
 
     pub fn ensure(target_os: &str, arch: &str) {
         if env::var(TESTGEN_HS_PATH).is_ok() {
-            println!(
-                "Environment variable {} is set. Skipping the download.",
-                TESTGEN_HS_PATH
-            );
+            println!("Environment variable {TESTGEN_HS_PATH} is set. Skipping the download.");
             return;
         }
 
@@ -92,13 +89,12 @@ mod testgen_hs {
             ".tar.bz2"
         };
 
-        let file_name = format!("testgen-hs-{}-{}-{}", testgen_lib_version, arch, target_os);
+        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/input-output-hk/testgen-hs/releases/download/{testgen_lib_version}/{file_name}{suffix}"
         );
 
-        println!("Looking for {}", file_name);
+        println!("Looking for {file_name}");
 
         // Use the project’s target directory instead of a system cache location.
         let cargo_manifest_dir =
@@ -112,16 +108,16 @@ mod testgen_hs {
         create_dir_all(&download_dir).expect("Unable to create testgen directory");
 
         let archive_name = if target_os == "windows" {
-            format!("{}.zip", file_name)
+            format!("{file_name}.zip")
         } else {
-            format!("{}.tar.bz2", file_name)
+            format!("{file_name}.tar.bz2")
         };
 
         let archive_path = download_dir.join(&archive_name);
 
         // Download the artifact if not already in the target directory.
         if !archive_path.exists() {
-            println!("Downloading from: {}", download_url);
+            println!("Downloading from: {download_url}");
 
             let response = reqwest::blocking::get(&download_url)
                 .expect("Failed to download archive")
@@ -165,7 +161,7 @@ mod testgen_hs {
 
         // Verify version by running --version.
         println!("Verifying testgen-hs version...");
-        println!("Executing: {:?}", executable);
+        println!("Executing: {executable:?}");
 
         let output = Command::new(&executable)
             .arg("--version")
@@ -182,7 +178,7 @@ mod testgen_hs {
         let version_output = String::from_utf8_lossy(&output.stdout);
         println!("testgen-hs version: {}", version_output.trim());
 
-        let testgen_lib_version = format!("testgen-hs {}", testgen_lib_version);
+        let testgen_lib_version = format!("testgen-hs {testgen_lib_version}");
 
         if version_output.trim() != testgen_lib_version {
             panic!(
@@ -240,14 +236,10 @@ mod features {
         println!("cargo::rustc-check-cfg=cfg(evaluate)");
 
         if target_os == "windows" {
-            println!(
-                "cargo:warning=Skipping 'evaluate' cfg for {}-{}",
-                target_os, target_arch
-            );
+            println!("cargo:warning=Skipping 'evaluate' cfg for {target_os}-{target_arch}");
         } else {
             println!(
-                "cargo:warning=Going to build with 'evaluate' cfg for {}-{}",
-                target_os, target_arch
+                "cargo:warning=Going to build with 'evaluate' cfg for {target_os}-{target_arch}"
             );
             println!("cargo:rustc-cfg=evaluate");
         }

From 079683f41546de32a9a48bbdae5a653b86690809 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 15:24:46 +0200
Subject: [PATCH 12/22] fix: `devshell` on `aarch64-linux`

---
 nix/internal/unix.nix | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index c13bfe32..0d4c23b3 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -166,14 +166,14 @@ in
     in
       (import inputs.flake-compat {
         src =
-          if targetSystem != "aarch64-darwin"
+          if targetSystem != "aarch64-darwin" && targetSystem != "aarch64-linux"
           then unpatched
           else {
             outPath = toString (pkgs.runCommand "source" {} ''
               cp -r ${unpatched} $out
               chmod -R +w $out
               cd $out
-              echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
+              echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} >$out/nix/supported-systems.nix
             '');
             inherit (unpatched) rev shortRev lastModified lastModifiedDate;
           };
@@ -183,7 +183,7 @@ in
     cardano-node-packages =
       {
         x86_64-linux = cardano-node-flake.hydraJobs.x86_64-linux.musl;
-        inherit (cardano-node-flake.packages) x86_64-darwin aarch64-darwin;
+        inherit (cardano-node-flake.packages) x86_64-darwin aarch64-darwin aarch64-linux;
       }
       .${targetSystem};
 

From 65d0f786c72acff4542ebc4c33c5a986b46041c8 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 15:58:55 +0200
Subject: [PATCH 13/22] =?UTF-8?q?fix:=20don=E2=80=99t=20use=20`musl`=20on?=
 =?UTF-8?q?=20`aarch64-linux`=20=E2=80=93=20back=20to=20GNU?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../testgen-hs--enable-aarch64-linux.diff     | 22 ++----
 nix/internal/unix.nix                         | 72 +++++++++++--------
 2 files changed, 46 insertions(+), 48 deletions(-)

diff --git a/nix/internal/testgen-hs--enable-aarch64-linux.diff b/nix/internal/testgen-hs--enable-aarch64-linux.diff
index 814f2207..257c0adc 100644
--- a/nix/internal/testgen-hs--enable-aarch64-linux.diff
+++ b/nix/internal/testgen-hs--enable-aarch64-linux.diff
@@ -60,7 +60,7 @@ index 72d2f8f..b192741 100644
          config,
          system,
 diff --git a/nix/internal.nix b/nix/internal.nix
-index 51248ac..09382ab 100644
+index 51248ac..7eb910e 100644
 --- a/nix/internal.nix
 +++ b/nix/internal.nix
 @@ -13,11 +13,29 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
@@ -90,19 +90,11 @@ index 51248ac..09382ab 100644
    cardano-node-packages =
      {
        x86_64-linux = cardano-node-flake.hydraJobs.x86_64-linux.musl;
-+      aarch64-linux = cardano-node-flake.hydraJobs.aarch64-linux.musl;
++      aarch64-linux = cardano-node-flake.packages.aarch64-linux;
        x86_64-darwin = cardano-node-flake.packages.x86_64-darwin;
        aarch64-darwin = cardano-node-flake.packages.aarch64-darwin;
      }
-@@ -25,7 +43,6 @@ in rec {
- 
-   inherit (cardano-node-packages) cardano-node cardano-cli;
- 
--  testgen-hs = let
-     patched-flake = let
-       unpatched = inputs.cardano-node;
-     in
-@@ -35,7 +52,7 @@ in rec {
+@@ -35,7 +53,7 @@ in rec {
              cp -r ${unpatched} $out
              chmod -R +w $out
              cd $out
@@ -111,15 +103,11 @@ index 51248ac..09382ab 100644
              cp -r ${../testgen-hs} ./testgen-hs
              sed -r '/^packages:/ a\  testgen-hs' -i cabal.project
              sed -r 's/other-modules:\s*/                    , /g' -i cardano-submit-api/cardano-submit-api.cabal
-@@ -48,9 +65,11 @@ in rec {
-         };
-       })
-       .defaultNix;
-+  testgen-hs = let
+@@ -51,6 +69,7 @@ in rec {
    in
      {
        x86_64-linux = patched-flake.hydraJobs.x86_64-linux.musl.testgen-hs;
-+      aarch64-linux = patched-flake.project.aarch64-linux.projectCross.aarch64-multiplatform-musl.packages.testgen-hs.components.exes.testgen-hs;
++      aarch64-linux = patched-flake.packages.aarch64-linux.testgen-hs;
        x86_64-darwin = patched-flake.packages.x86_64-darwin.testgen-hs;
        aarch64-darwin = patched-flake.packages.aarch64-darwin.testgen-hs;
        x86_64-windows = patched-flake.legacyPackages.x86_64-linux.hydraJobs.windows.testgen-hs;
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 0d4c23b3..60715e5d 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -254,37 +254,47 @@ in
     # For generating a signing key from a recovery phrase. It’s a little
     # controversial to download a binary, but we only need it for the devshell. If
     # needed, we can use the source instead.
-    cardano-address = let
-      release = "v2024-09-29";
-      baseUrl = "https://github.com/cardano-foundation/cardano-wallet/releases/download/${release}/cardano-wallet";
-      archive = pkgs.fetchzip {
-        name = "cardano-wallet-${release}";
-        url =
-          {
-            "x86_64-linux" = "${baseUrl}-${release}-linux64.tar.gz";
-            "x86_64-darwin" = "${baseUrl}-${release}-macos-intel.tar.gz";
-            "aarch64-darwin" = "${baseUrl}-${release}-macos-silicon.tar.gz";
-          }
-          .${targetSystem};
-        hash =
-          {
-            "x86_64-linux" = "sha256-EOe6ooqvSGylJMJnWbqDrUIVYzwTCw5Up/vU/gPK6tE=";
-            "x86_64-darwin" = "sha256-POUj3Loo8o7lBI4CniaA/Z9mTRAmWv9VWAdtcIMe27I=";
-            "aarch64-darwin" = "sha256-+6bzdUXnJ+nnYdZuhLueT0+bYmXzwDXTe9JqWrWnfe4=";
-          }
-          .${targetSystem};
-      };
-    in
-      pkgs.runCommandNoCC "cardano-address" {
-        meta.description = "Command-line for address and key manipulation in Cardano";
-      } ''
-        mkdir -p $out/bin $out/libexec
-        cp ${archive}/cardano-address $out/libexec/
-        ${lib.optionalString pkgs.stdenv.isDarwin ''
-          cp ${archive}/{libz,libiconv.2,libgmp.10,libffi.8}.dylib $out/libexec
-        ''}
-        ln -sf $out/libexec/cardano-address $out/bin/
-      '';
+    cardano-address =
+      if targetSystem == "aarch64-linux"
+      then
+        pkgs.writeShellApplication {
+          name = "cardano-address";
+          text = ''
+            echo >&2 "TODO: unimplemented: compile \`cardano-address\` for \`${targetSystem}\`!"
+            exit 1
+          '';
+        }
+      else let
+        release = "v2024-09-29";
+        baseUrl = "https://github.com/cardano-foundation/cardano-wallet/releases/download/${release}/cardano-wallet";
+        archive = pkgs.fetchzip {
+          name = "cardano-wallet-${release}";
+          url =
+            {
+              "x86_64-linux" = "${baseUrl}-${release}-linux64.tar.gz";
+              "x86_64-darwin" = "${baseUrl}-${release}-macos-intel.tar.gz";
+              "aarch64-darwin" = "${baseUrl}-${release}-macos-silicon.tar.gz";
+            }
+            .${targetSystem};
+          hash =
+            {
+              "x86_64-linux" = "sha256-EOe6ooqvSGylJMJnWbqDrUIVYzwTCw5Up/vU/gPK6tE=";
+              "x86_64-darwin" = "sha256-POUj3Loo8o7lBI4CniaA/Z9mTRAmWv9VWAdtcIMe27I=";
+              "aarch64-darwin" = "sha256-+6bzdUXnJ+nnYdZuhLueT0+bYmXzwDXTe9JqWrWnfe4=";
+            }
+            .${targetSystem};
+        };
+      in
+        pkgs.runCommandNoCC "cardano-address" {
+          meta.description = "Command-line for address and key manipulation in Cardano";
+        } ''
+          mkdir -p $out/bin $out/libexec
+          cp ${archive}/cardano-address $out/libexec/
+          ${lib.optionalString pkgs.stdenv.isDarwin ''
+            cp ${archive}/{libz,libiconv.2,libgmp.10,libffi.8}.dylib $out/libexec
+          ''}
+          ln -sf $out/libexec/cardano-address $out/bin/
+        '';
 
     tx-build = pkgs.writeShellApplication {
       name = "tx-build";

From 46dc3414cce4fcd2505e65a146124f38651cb860 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 16:50:57 +0200
Subject: [PATCH 14/22] fix: drop `-fexternal-interpreter` for `plutus-core`

---
 .../testgen-hs--enable-aarch64-linux.diff        | 16 +++++++++++-----
 nix/internal/unix.nix                            |  3 +++
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/nix/internal/testgen-hs--enable-aarch64-linux.diff b/nix/internal/testgen-hs--enable-aarch64-linux.diff
index 257c0adc..9ad78090 100644
--- a/nix/internal/testgen-hs--enable-aarch64-linux.diff
+++ b/nix/internal/testgen-hs--enable-aarch64-linux.diff
@@ -60,10 +60,10 @@ index 72d2f8f..b192741 100644
          config,
          system,
 diff --git a/nix/internal.nix b/nix/internal.nix
-index 51248ac..7eb910e 100644
+index 51248ac..61a7c70 100644
 --- a/nix/internal.nix
 +++ b/nix/internal.nix
-@@ -13,11 +13,29 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
+@@ -13,11 +13,32 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
  in rec {
    defaultPackage = testgen-hs;
  
@@ -81,6 +81,9 @@ index 51248ac..7eb910e 100644
 +            chmod -R +w $out
 +            cd $out
 +            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
++            ${lib.optionalString (targetSystem == "aarch64-linux") ''
++              sed -r 's/"-fexternal-interpreter"//g' -i $out/nix/haskell.nix
++            ''}
 +          '');
 +          inherit (unpatched) rev shortRev lastModified lastModifiedDate;
 +        };
@@ -94,16 +97,19 @@ index 51248ac..7eb910e 100644
        x86_64-darwin = cardano-node-flake.packages.x86_64-darwin;
        aarch64-darwin = cardano-node-flake.packages.aarch64-darwin;
      }
-@@ -35,7 +53,7 @@ in rec {
+@@ -35,7 +56,10 @@ in rec {
              cp -r ${unpatched} $out
              chmod -R +w $out
              cd $out
 -            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
 +            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} >$out/nix/supported-systems.nix
++            ${lib.optionalString (targetSystem == "aarch64-linux") ''
++              sed -r 's/"-fexternal-interpreter"//g' -i $out/nix/haskell.nix
++            ''}
              cp -r ${../testgen-hs} ./testgen-hs
              sed -r '/^packages:/ a\  testgen-hs' -i cabal.project
              sed -r 's/other-modules:\s*/                    , /g' -i cardano-submit-api/cardano-submit-api.cabal
-@@ -51,6 +69,7 @@ in rec {
+@@ -51,6 +75,7 @@ in rec {
    in
      {
        x86_64-linux = patched-flake.hydraJobs.x86_64-linux.musl.testgen-hs;
@@ -111,7 +117,7 @@ index 51248ac..7eb910e 100644
        x86_64-darwin = patched-flake.packages.x86_64-darwin.testgen-hs;
        aarch64-darwin = patched-flake.packages.aarch64-darwin.testgen-hs;
        x86_64-windows = patched-flake.legacyPackages.x86_64-linux.hydraJobs.windows.testgen-hs;
-@@ -113,6 +132,7 @@ in rec {
+@@ -113,6 +138,7 @@ in rec {
        aarch64-darwin = darwinLike;
        x86_64-darwin = darwinLike;
        x86_64-linux = linuxLike {};
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 60715e5d..41304937 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -174,6 +174,9 @@ in
               chmod -R +w $out
               cd $out
               echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} >$out/nix/supported-systems.nix
+              ${lib.optionalString (targetSystem == "aarch64-linux") ''
+                sed -r 's/"-fexternal-interpreter"//g' -i $out/nix/haskell.nix
+              ''}
             '');
             inherit (unpatched) rev shortRev lastModified lastModifiedDate;
           };

From bf6469ea22285326d4b6d70ab2567f29a397c24e Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 16:54:17 +0200
Subject: [PATCH 15/22] chore: update `nixpkgs` for the new Rust and Clippy

---
 flake.lock              | 50 ++++++++++++++++++++---------------------
 flake.nix               |  2 +-
 nix/devshells.nix       | 12 +++-------
 nix/internal/darwin.nix | 23 +++++++++----------
 nix/internal/unix.nix   | 12 +++++++---
 5 files changed, 49 insertions(+), 50 deletions(-)

diff --git a/flake.lock b/flake.lock
index 587928ab..cbd3041f 100644
--- a/flake.lock
+++ b/flake.lock
@@ -3,11 +3,11 @@
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1748950236,
-        "narHash": "sha256-kNiGMrXi5Bq/aWoQmnpK0v+ufQA4FOInhbkY56iUndc=",
+        "lastModified": 1750151065,
+        "narHash": "sha256-il+CAqChFIB82xP6bO43dWlUVs+NlG7a4g8liIP5HcI=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "a1f651cba8bf224f52c5d55d8182b3bb0ebce49e",
+        "rev": "7573f55ba337263f61167dbb0ea926cdc7c8eb5d",
         "type": "github"
       },
       "original": {
@@ -52,11 +52,11 @@
     },
     "crane": {
       "locked": {
-        "lastModified": 1743908961,
-        "narHash": "sha256-e1idZdpnnHWuosI3KsBgAgrhMR05T2oqskXCmNzGPq0=",
+        "lastModified": 1750266157,
+        "narHash": "sha256-tL42YoNg9y30u7zAqtoGDNdTyXTi8EALDeCB13FtbQA=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "80ceeec0dc94ef967c371dcdc56adb280328f591",
+        "rev": "e37c943371b73ed87faf33f7583860f81f1d5a48",
         "type": "github"
       },
       "original": {
@@ -93,11 +93,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1742452566,
-        "narHash": "sha256-sVuLDQ2UIWfXUBbctzrZrXM2X05YjX08K7XHMztt36E=",
+        "lastModified": 1751265761,
+        "narHash": "sha256-VSbk7ppgFSqBxlsWtzIO52iT9TKkLJrmVYOIhQi13Kg=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "7d9ba794daf5e8cc7ee728859bc688d8e26d5f06",
+        "rev": "19c910fe3de1768e64e76b5ee6daa346e6b07410",
         "type": "github"
       },
       "original": {
@@ -127,11 +127,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1743550720,
-        "narHash": "sha256-hIshGgKZCgWh6AYJpJmRgFdR3WUbkY04o82X05xqQiY=",
+        "lastModified": 1749398372,
+        "narHash": "sha256-tYBdgS56eXYaWVW3fsnPQ/nFlgWi/Z2Ymhyu21zVM98=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "c621e8422220273271f52058f618c94e405bb0f5",
+        "rev": "9305fe4e5c2a6fcf5ba6a3ff155720fbe4076569",
         "type": "github"
       },
       "original": {
@@ -158,27 +158,27 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1743975612,
-        "narHash": "sha256-o4FjFOUmjSRMK7dn0TFdAT0RRWUWD+WsspPHa+qEQT8=",
+        "lastModified": 1751211869,
+        "narHash": "sha256-1Cu92i1KSPbhPCKxoiVG5qnoRiKTgR5CcGSRyLpOd7Y=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "a880f49904d68b5e53338d1e8c7bf80f59903928",
+        "rev": "b43c397f6c213918d6cfe6e3550abfe79b5d1c51",
         "type": "github"
       },
       "original": {
         "owner": "nixos",
-        "ref": "nixos-24.11",
+        "ref": "nixos-25.05",
         "repo": "nixpkgs",
         "type": "github"
       }
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1743296961,
-        "narHash": "sha256-b1EdN3cULCqtorQ4QeWgLMrd5ZGOjLSLemfa00heasc=",
+        "lastModified": 1748740939,
+        "narHash": "sha256-rQaysilft1aVMwF14xIdGS3sj1yHlI6oKQNBRTF40cc=",
         "owner": "nix-community",
         "repo": "nixpkgs.lib",
-        "rev": "e4822aea2a6d1cdd36653c134cacfd64c97ff4fa",
+        "rev": "656a64127e9d791a334452c6b6606d17539476e2",
         "type": "github"
       },
       "original": {
@@ -224,11 +224,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1742296961,
-        "narHash": "sha256-gCpvEQOrugHWLimD1wTFOJHagnSEP6VYBDspq96Idu0=",
+        "lastModified": 1751210071,
+        "narHash": "sha256-v7XmmLBNRMzRXiVCeH60ZeGEqo+aagmwawI0Z9+EoXY=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "15d87419f1a123d8f888d608129c3ce3ff8f13d4",
+        "rev": "6df12139bccaaeecf6a34789e0ca799d1fe99c53",
         "type": "github"
       },
       "original": {
@@ -262,11 +262,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1743748085,
-        "narHash": "sha256-uhjnlaVTWo5iD3LXics1rp9gaKgDRQj6660+gbUU3cE=",
+        "lastModified": 1750931469,
+        "narHash": "sha256-0IEdQB1nS+uViQw4k3VGUXntjkDp7aAlqcxdewb/hAc=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "815e4121d6a5d504c0f96e5be2dd7f871e4fd99d",
+        "rev": "ac8e6f32e11e9c7f153823abc3ab007f2a65d3e1",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 6484277f..d1e30082 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-24.11";
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-25.05";
     flake-parts.url = "github:hercules-ci/flake-parts";
     treefmt-nix.url = "github:numtide/treefmt-nix";
     treefmt-nix.inputs.nixpkgs.follows = "nixpkgs";
diff --git a/nix/devshells.nix b/nix/devshells.nix
index e5e31cec..a218c2bb 100644
--- a/nix/devshells.nix
+++ b/nix/devshells.nix
@@ -10,7 +10,6 @@ in {
 
   imports = [
     "${inputs.devshell}/extra/language/c.nix"
-    "${inputs.devshell}/extra/language/rust.nix"
   ];
 
   commands = [
@@ -31,10 +30,11 @@ in {
       name = "cardano-address";
       package = internal.cardano-address;
     }
-    {package = config.language.rust.packageSet.cargo;}
     {package = pkgs.cargo-nextest;}
     {package = pkgs.cargo-tarpaulin;}
-    {package = config.language.rust.packageSet.rust-analyzer;}
+    {package = internal.rustPackages.cargo;}
+    {package = internal.rustPackages.clippy;}
+    {package = internal.rustPackages.rust-analyzer;}
     {
       category = "handy";
       package = internal.runNode "preview";
@@ -66,12 +66,6 @@ in {
     includes = internal.commonArgs.buildInputs;
   };
 
-  language.rust.packageSet =
-    internal.rustPackages
-    // {
-      clippy = internal.rustPackages.clippy-unwrapped;
-    };
-
   env =
     [
       {
diff --git a/nix/internal/darwin.nix b/nix/internal/darwin.nix
index c85fbc62..304efa37 100644
--- a/nix/internal/darwin.nix
+++ b/nix/internal/darwin.nix
@@ -40,19 +40,18 @@ in
       };
 
     # Portable directory that can be run on any modern Darwin:
-    bundle =
-      (nix-bundle-exe-lib-subdir "${unix.package}/libexec/${unix.packageName}")
+    bundle = (nix-bundle-exe-lib-subdir "${unix.package}/libexec/${unix.packageName}")
       .overrideAttrs (drv: {
-        name = unix.packageName;
-        buildCommand =
-          drv.buildCommand
-          + ''
-            mkdir -p $out/libexec
-            mv $out/{${unix.packageName},lib} $out/libexec
-            mkdir -p $out/bin
-            ( cd $out/bin ; ln -s ../libexec/${unix.packageName} ./ ; )
-          '';
-      });
+      name = unix.packageName;
+      buildCommand =
+        drv.buildCommand
+        + ''
+          mkdir -p $out/libexec
+          mv $out/{${unix.packageName},lib} $out/libexec
+          mkdir -p $out/bin
+          ( cd $out/bin ; ln -s ../libexec/${unix.packageName} ./ ; )
+        '';
+    });
 
     bundle-testgen-hs = nix-bundle-exe-lib-subdir (lib.getExe unix.testgen-hs);
 
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 41304937..1add453c 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -188,7 +188,9 @@ in
         x86_64-linux = cardano-node-flake.hydraJobs.x86_64-linux.musl;
         inherit (cardano-node-flake.packages) x86_64-darwin aarch64-darwin aarch64-linux;
       }
-      .${targetSystem};
+      .${
+        targetSystem
+      };
 
     inherit (cardano-node-packages) cardano-node cardano-cli cardano-submit-api;
 
@@ -278,14 +280,18 @@ in
               "x86_64-darwin" = "${baseUrl}-${release}-macos-intel.tar.gz";
               "aarch64-darwin" = "${baseUrl}-${release}-macos-silicon.tar.gz";
             }
-            .${targetSystem};
+            .${
+              targetSystem
+            };
           hash =
             {
               "x86_64-linux" = "sha256-EOe6ooqvSGylJMJnWbqDrUIVYzwTCw5Up/vU/gPK6tE=";
               "x86_64-darwin" = "sha256-POUj3Loo8o7lBI4CniaA/Z9mTRAmWv9VWAdtcIMe27I=";
               "aarch64-darwin" = "sha256-+6bzdUXnJ+nnYdZuhLueT0+bYmXzwDXTe9JqWrWnfe4=";
             }
-            .${targetSystem};
+            .${
+              targetSystem
+            };
         };
       in
         pkgs.runCommandNoCC "cardano-address" {

From 52cd86c78965b575abc4cb84667a37d88e5f4cea Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 30 Jun 2025 16:58:35 +0200
Subject: [PATCH 16/22] =?UTF-8?q?chore:=20apply=20Clippy=E2=80=99s=20corre?=
 =?UTF-8?q?ctions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/assets.rs                |  3 +--
 src/cbor/fallback_decoder.rs | 17 ++++++++---------
 src/cbor/tests.rs            | 11 +++++------
 src/cli.rs                   |  4 ++--
 src/common.rs                |  2 +-
 src/config.rs                |  3 +--
 src/errors.rs                | 16 ++++++++--------
 src/icebreakers_api.rs       |  8 ++++----
 src/load_balancer.rs         | 26 +++++++++-----------------
 src/middlewares/errors.rs    | 17 ++++++++---------
 src/node/pool.rs             |  2 +-
 src/node/sync_progress.rs    |  9 +++------
 src/payment_cred.rs          | 12 ++++--------
 src/server/state.rs          |  2 +-
 14 files changed, 56 insertions(+), 76 deletions(-)

diff --git a/src/assets.rs b/src/assets.rs
index ba453976..64f63e4a 100644
--- a/src/assets.rs
+++ b/src/assets.rs
@@ -44,8 +44,7 @@ pub fn validate_asset_name(asset_name: &str) -> bool {
 pub fn parse_asset(hex: &str) -> Result<ParsedAsset, BlockfrostError> {
     if hex.len() < POLICY_ID_SIZE {
         return Err(BlockfrostError::internal_server_error(format!(
-            "Asset name is too short: {}",
-            hex,
+            "Asset name is too short: {hex}",
         )));
     }
 
diff --git a/src/cbor/fallback_decoder.rs b/src/cbor/fallback_decoder.rs
index cf57d569..a9526127 100644
--- a/src/cbor/fallback_decoder.rs
+++ b/src/cbor/fallback_decoder.rs
@@ -73,7 +73,7 @@ impl FallbackDecoder {
                 response_tx,
             })
             .await
-            .map_err(|err| format!("FallbackDecoder: failed to send request: {:?}", err))?;
+            .map_err(|err| format!("FallbackDecoder: failed to send request: {err:?}"))?;
 
         response_rx.await.unwrap_or_else(|err| {
             unreachable!(
@@ -168,8 +168,7 @@ impl FallbackDecoder {
             Ok(())
         } else {
             Err(format!(
-                "FallbackDecoder: startup_sanity_test failed: {:?}",
-                result
+                "FallbackDecoder: startup_sanity_test failed: {result:?}"
             ))
         }
     }
@@ -199,7 +198,7 @@ impl FallbackDecoder {
             .stdin(proc::Stdio::piped())
             .stdout(proc::Stdio::piped())
             .spawn()
-            .map_err(|err| format!("couldn’t start the child: {:?}", err))?;
+            .map_err(|err| format!("couldn’t start the child: {err:?}"))?;
 
         current_child_pid.store(child.id(), atomic::Ordering::Relaxed);
 
@@ -209,10 +208,10 @@ impl FallbackDecoder {
         // Will return Ok(()) if already dead.
         child
             .kill()
-            .map_err(|err| format!("couldn’t kill the child: {:?}", err))?;
+            .map_err(|err| format!("couldn’t kill the child: {err:?}"))?;
         child
             .wait()
-            .map_err(|err| format!("couldn’t reap the child: {:?}", err))?;
+            .map_err(|err| format!("couldn’t reap the child: {err:?}"))?;
 
         result
     }
@@ -242,12 +241,12 @@ impl FallbackDecoder {
             *last_unfulfilled_request = Some(request);
 
             let mut ask_and_receive = || -> Result<Result<serde_json::Value, String>, String> {
-                writeln!(stdin, "{}", cbor_hex)
-                    .map_err(|err| format!("couldn’t write to stdin: {:?}", err))?;
+                writeln!(stdin, "{cbor_hex}")
+                    .map_err(|err| format!("couldn’t write to stdin: {err:?}"))?;
 
                 match stdout_lines.next() {
                     Some(Ok(line)) => Ok(Self::parse_json(&line)),
-                    Some(Err(e)) => Err(format!("failed to read from subprocess: {}", e)),
+                    Some(Err(e)) => Err(format!("failed to read from subprocess: {e}")),
                     None => Err("no output from subprocess".to_string()),
                 }
             };
diff --git a/src/cbor/tests.rs b/src/cbor/tests.rs
index f214fe8a..f0f28d10 100644
--- a/src/cbor/tests.rs
+++ b/src/cbor/tests.rs
@@ -65,7 +65,7 @@ pub fn check_generated_cases<F>(
         .args(["--number", &num_cases.to_string()])
         .args(["--generator-size", &generator_size.to_string()])
         .args(seed.map_or(vec![], |seed| vec!["--seed".to_string(), seed.to_string()]))
-        .arg(format!("{:?}", case_type))
+        .arg(format!("{case_type:?}"))
         .stdout(std::process::Stdio::piped())
         .spawn()
         .expect("failed to spawn child");
@@ -101,7 +101,7 @@ pub fn check_generated_cases<F>(
                             Ok(a) => a,
                             Err(_) => Err("panic! (see above for details)".to_string()),
                         },
-                        Err(e) => Err(format!("CborTestCase JSON parse error: {}", e)),
+                        Err(e) => Err(format!("CborTestCase JSON parse error: {e}")),
                     };
                     let _ = result_tx.send(outcome);
                 }
@@ -149,18 +149,17 @@ pub fn check_generated_cases<F>(
                     if num_failed <= show_n_failures {
                         "".to_string()
                     } else {
-                        format!(" (first {})", show_n_failures)
+                        format!(" (first {show_n_failures})")
                     }
                 ));
 
                 for case in first_n_failures {
-                    details.push_str(&format!("\n- {}", case));
+                    details.push_str(&format!("\n- {case}"));
                 }
             }
 
             panic!(
-                "For size {}: {} out of {} ({:.2}%) failed. Seed: {}.{}",
-                generator_size, num_failed, num_total, percent, random_seed, details
+                "For size {generator_size}: {num_failed} out of {num_total} ({percent:.2}%) failed. Seed: {random_seed}.{details}"
             )
         }
     });
diff --git a/src/cli.rs b/src/cli.rs
index 2af78682..c64de97d 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -135,7 +135,7 @@ impl Args {
             message,
             enum_values
                 .iter()
-                .map(|it| format!("{:?}", it))
+                .map(|it| format!("{it:?}"))
                 .collect::<Vec<_>>(),
         )
         .with_starting_cursor(starting_cursor)
@@ -260,7 +260,7 @@ impl Args {
         }
 
         app_config.to_file(&config_path)?;
-        println!("\nConfig has been written to {:?}", config_path);
+        println!("\nConfig has been written to {config_path:?}");
 
         std::process::exit(0);
     }
diff --git a/src/common.rs b/src/common.rs
index ac287644..bbcb854a 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -22,7 +22,7 @@ pub fn validate_content_type(
             let error_message = if allowed_content_types.len() == 1 {
                 format!("Content-Type must be: {:?}", allowed_content_types[0])
             } else {
-                format!("Content-Type must be one of: {:?}", allowed_content_types)
+                format!("Content-Type must be one of: {allowed_content_types:?}")
             };
 
             return Err(BlockfrostError::custom_400(error_message));
diff --git a/src/config.rs b/src/config.rs
index 22b43872..22da1f0e 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -185,7 +185,6 @@ async fn detect_network(socket_path: &str) -> Result<Network, AppError> {
     }
 
     Err(AppError::Server(format!(
-        "Could not detect network from '{}' is the node running?",
-        socket_path
+        "Could not detect network from '{socket_path}' is the node running?"
     )))
 }
diff --git a/src/errors.rs b/src/errors.rs
index d2a46762..67f58846 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -39,13 +39,13 @@ pub struct BlockfrostError {
 
 impl From<std::num::TryFromIntError> for BlockfrostError {
     fn from(err: std::num::TryFromIntError) -> Self {
-        Self::internal_server_error(format!("ConversionError: {}", err))
+        Self::internal_server_error(format!("ConversionError: {err}"))
     }
 }
 
 impl From<serde_json::Error> for BlockfrostError {
     fn from(err: serde_json::Error) -> Self {
-        Self::internal_server_error(format!("SerdeError: {}", err))
+        Self::internal_server_error(format!("SerdeError: {err}"))
     }
 }
 
@@ -75,25 +75,25 @@ impl From<io::Error> for AppError {
 
 impl From<pallas_network::miniprotocols::txsubmission::Error> for BlockfrostError {
     fn from(err: pallas_network::miniprotocols::txsubmission::Error) -> Self {
-        BlockfrostError::internal_server_error(format!("TxSubmissionError: {}", err))
+        BlockfrostError::internal_server_error(format!("TxSubmissionError: {err}"))
     }
 }
 
 impl From<pallas_network::miniprotocols::handshake::Error> for BlockfrostError {
     fn from(err: pallas_network::miniprotocols::handshake::Error) -> Self {
-        BlockfrostError::internal_server_error(format!("CardanoNodeHandshakeError: {}", err))
+        BlockfrostError::internal_server_error(format!("CardanoNodeHandshakeError: {err}"))
     }
 }
 
 impl From<pallas_network::miniprotocols::localstate::ClientError> for BlockfrostError {
     fn from(err: pallas_network::miniprotocols::localstate::ClientError) -> Self {
-        BlockfrostError::internal_server_error(format!("localstate::ClientError: {}", err))
+        BlockfrostError::internal_server_error(format!("localstate::ClientError: {err}"))
     }
 }
 
 impl From<TryFromSliceError> for BlockfrostError {
     fn from(err: TryFromSliceError) -> Self {
-        BlockfrostError::internal_server_error(format!("Hash conversion failed: {}", err))
+        BlockfrostError::internal_server_error(format!("Hash conversion failed: {err}"))
     }
 }
 
@@ -105,13 +105,13 @@ impl From<pallas_network::facades::Error> for AppError {
 
 impl From<reqwest::header::InvalidHeaderValue> for BlockfrostError {
     fn from(err: reqwest::header::InvalidHeaderValue) -> Self {
-        BlockfrostError::internal_server_error(format!("Invalid header value: {}", err))
+        BlockfrostError::internal_server_error(format!("Invalid header value: {err}"))
     }
 }
 
 impl From<TxSubmissionError> for BlockfrostError {
     fn from(err: TxSubmissionError) -> Self {
-        BlockfrostError::internal_server_error(format!("Transaction submission error: {}", err))
+        BlockfrostError::internal_server_error(format!("Transaction submission error: {err}"))
     }
 }
 
diff --git a/src/icebreakers_api.rs b/src/icebreakers_api.rs
index 4036a548..f21dc3c1 100644
--- a/src/icebreakers_api.rs
+++ b/src/icebreakers_api.rs
@@ -60,7 +60,7 @@ impl IcebreakersAPI {
                 let client = Client::builder()
                     .local_address(config.server_address)
                     .build()
-                    .map_err(|e| AppError::Registration(format!("Registering failed: {}", e)))?;
+                    .map_err(|e| AppError::Registration(format!("Registering failed: {e}")))?;
                 let base_url = api_url.to_string();
                 let icebreakers_api = IcebreakersAPI {
                     client,
@@ -114,11 +114,11 @@ impl IcebreakersAPI {
             .json(&body)
             .send()
             .await
-            .map_err(|e| AppError::Registration(format!("Registering failed: {}", e)))?;
+            .map_err(|e| AppError::Registration(format!("Registering failed: {e}")))?;
 
         if response.status().is_success() {
             let success_response = response.json::<SuccessResponse>().await.map_err(|e| {
-                AppError::Registration(format!("Failed to parse success response: {}", e))
+                AppError::Registration(format!("Failed to parse success response: {e}"))
             })?;
 
             info!("Successfully registered with Icebreakers API.");
@@ -159,7 +159,7 @@ impl IcebreakersAPI {
             Ok(success_response)
         } else {
             let error_response = response.json::<ErrorResponse>().await.map_err(|e| {
-                AppError::Registration(format!("Failed to parse error response: {}", e))
+                AppError::Registration(format!("Failed to parse error response: {e}"))
             })?;
 
             Err(AppError::Registration(format!(
diff --git a/src/load_balancer.rs b/src/load_balancer.rs
index a98c080d..5fa06871 100644
--- a/src/load_balancer.rs
+++ b/src/load_balancer.rs
@@ -53,15 +53,14 @@ pub async fn run_all(
     let (first_res, first_idx, remaining) = futures::future::select_all(connections).await;
 
     let maybe_error = match first_res {
-        Err(panic) => format!(" with a panic: {:?}", panic),
-        Ok(Err(err)) => format!(" with an error: {}", err),
+        Err(panic) => format!(" with a panic: {panic:?}"),
+        Ok(Err(err)) => format!(" with an error: {err}"),
         Ok(Ok(())) => "".to_string(),
     };
 
     *health_errors.lock().await = vec![
         AppError::LoadBalancer(format!(
-            "Load balancer connection ended unexpectedly{}",
-            maybe_error
+            "Load balancer connection ended unexpectedly{maybe_error}"
         ))
         .into(),
     ];
@@ -323,8 +322,7 @@ mod event_loop {
                 // This branch is practically impossible, but for the sake of completeness:
                 // Let’s break 'event_loop, this seems the most elegant.
                 let err = format!(
-                    "error when serializing request to JSON (this will never happen): {:?}",
-                    err
+                    "error when serializing request to JSON (this will never happen): {err:?}"
                 );
                 error!("load balancer: {}: {}", config.uri, err);
                 Err(err)
@@ -352,7 +350,7 @@ mod event_loop {
                     },
                     Some(Err(err)) => {
                         let _ignored_failure: Result<_, _> = event_tx
-                            .send(LBEvent::SocketError(format!("stream error: {:?}", err)))
+                            .send(LBEvent::SocketError(format!("stream error: {err:?}")))
                             .await;
                         break 'read_loop;
                     },
@@ -421,10 +419,7 @@ mod event_loop {
                     .map_err(|_elapsed| {
                         (
                             StatusCode::GATEWAY_TIMEOUT,
-                            format!(
-                                "Timed out while waiting {:?} for a response",
-                                REQUEST_TIMEOUT
-                            ),
+                            format!("Timed out while waiting {REQUEST_TIMEOUT:?} for a response"),
                         )
                     })?
                     .unwrap(); // unwrap is safe, because the error is a non-instantiable [`std::convert::Infallible`]
@@ -467,7 +462,7 @@ fn json_to_request(
                     .map_err(|err| {
                         (
                             StatusCode::BAD_REQUEST,
-                            format!("Invalid base64 encoding of body_base64: {}", err),
+                            format!("Invalid base64 encoding of body_base64: {err}"),
                         )
                     })?;
             Body::from(body_bytes)
@@ -485,10 +480,7 @@ fn json_to_request(
     rv.body(body).map_err(|err| {
         (
             StatusCode::BAD_REQUEST,
-            format!(
-                "Error when constructing a request from JSON request: {}",
-                err
-            ),
+            format!("Error when constructing a request from JSON request: {err}"),
         )
     })
 }
@@ -519,7 +511,7 @@ async fn response_to_json(
             .map_err(|err| {
                 (
                     StatusCode::BAD_GATEWAY,
-                    format!("Cannot read body of the response: {}", err),
+                    format!("Cannot read body of the response: {err}"),
                 )
             })?;
         use base64::{Engine as _, engine::general_purpose};
diff --git a/src/middlewares/errors.rs b/src/middlewares/errors.rs
index 2cae704c..44f0a00c 100644
--- a/src/middlewares/errors.rs
+++ b/src/middlewares/errors.rs
@@ -63,18 +63,18 @@ async fn parse_and_log_error(bytes: Bytes, request_path: &str, status_code: Stat
                 request_path,
                 error_info.message
             );
-            log_to_sentry("|", format!("{:?}", error_info), request_path, status_code)
+            log_to_sentry("|", format!("{error_info:?}"), request_path, status_code)
         },
         Err(e) => {
-            println!("Failed to parse body as JSON: {:?}", e);
+            println!("Failed to parse body as JSON: {e:?}");
             log_to_sentry(
                 "JSON Parse Error",
-                format!("{:?}", e),
+                format!("{e:?}"),
                 request_path,
                 status_code,
             );
             let body_str = String::from_utf8_lossy(&bytes);
-            println!("Raw Body: {}", body_str);
+            println!("Raw Body: {body_str}");
         },
     }
 }
@@ -95,14 +95,13 @@ fn log_and_capture_error(
 
     let exception = Exception {
         ty: "ServerError".to_string(),
-        value: Some(format!("{:?}", error)),
+        value: Some(format!("{error:?}")),
         ..Default::default()
     };
 
     let event = Event {
         message: Some(format!(
-            "{}: Path: {}, Status: {}",
-            message, request_path, status_code
+            "{message}: Path: {request_path}, Status: {status_code}"
         )),
         level: Level::Error,
         exception: vec![exception].into(),
@@ -114,7 +113,7 @@ fn log_and_capture_error(
 
 fn log_to_sentry(context: &str, detail: String, request_path: &str, status_code: StatusCode) {
     let breadcrumb = Breadcrumb {
-        message: Some(format!("Request at {}", request_path)),
+        message: Some(format!("Request at {request_path}")),
         category: Some("request".into()),
         level: Level::Info,
         ..Default::default()
@@ -123,7 +122,7 @@ fn log_to_sentry(context: &str, detail: String, request_path: &str, status_code:
     sentry::add_breadcrumb(breadcrumb);
 
     let event = Event {
-        message: Some(format!("{} - {}: {}", status_code, context, detail)),
+        message: Some(format!("{status_code} - {context}: {detail}")),
         level: Level::Error,
         ..Default::default()
     };
diff --git a/src/node/pool.rs b/src/node/pool.rs
index 657e6ffa..711cfe0e 100644
--- a/src/node/pool.rs
+++ b/src/node/pool.rs
@@ -37,6 +37,6 @@ impl NodePool {
         self.pool_manager
             .get()
             .await
-            .map_err(|err| AppError::Node(format!("NodeConnPool: {}", err)))
+            .map_err(|err| AppError::Node(format!("NodeConnPool: {err}")))
     }
 }
diff --git a/src/node/sync_progress.rs b/src/node/sync_progress.rs
index b9223a6a..8d8b22be 100644
--- a/src/node/sync_progress.rs
+++ b/src/node/sync_progress.rs
@@ -30,8 +30,7 @@ impl NodeClient {
                 )
                 .ok_or_else(|| {
                     BlockfrostError::internal_server_error(format!(
-                        "Only well-known networks are supported (unsupported network magic: {})",
-                        network_magic
+                        "Only well-known networks are supported (unsupported network magic: {network_magic})"
                     ))
                 })?;
 
@@ -55,8 +54,7 @@ impl NodeClient {
                     .try_into()
                     .map_err(|e| {
                         BlockfrostError::internal_server_error(format!(
-                            "Failed to convert picoseconds: {}",
-                            e
+                            "Failed to convert picoseconds: {e}"
                         ))
                     })?;
 
@@ -80,8 +78,7 @@ impl NodeClient {
                     .try_into()
                     .map_err(|e| {
                         BlockfrostError::internal_server_error(format!(
-                            "Failed to convert slot time: {}",
-                            e
+                            "Failed to convert slot time: {e}"
                         ))
                     })?;
 
diff --git a/src/payment_cred.rs b/src/payment_cred.rs
index cfe5e29b..1a0fac39 100644
--- a/src/payment_cred.rs
+++ b/src/payment_cred.rs
@@ -110,8 +110,7 @@ impl PaymentCred {
                     Ok(bytes) => bytes.to_base32(),
                     err => {
                         return Err(BlockfrostError::internal_server_error(format!(
-                            "get_bech32_from_payment_cred hex decode error: {:?}",
-                            err
+                            "get_bech32_from_payment_cred hex decode error: {err:?}"
                         )));
                     },
                 };
@@ -121,8 +120,7 @@ impl PaymentCred {
                     PaymentCredPrefix::Script => "script",
                     err => {
                         return Err(BlockfrostError::internal_server_error(format!(
-                            "get_bech32_from_payment_cred hex decode error: {:?}",
-                            err
+                            "get_bech32_from_payment_cred hex decode error: {err:?}"
                         )));
                     },
                 };
@@ -131,8 +129,7 @@ impl PaymentCred {
                     Ok(address) => address,
                     err => {
                         return Err(BlockfrostError::internal_server_error(format!(
-                            "get_bech32_from_payment_cred hex decode error: {:?}",
-                            err
+                            "get_bech32_from_payment_cred hex decode error: {err:?}"
                         )));
                     },
                 };
@@ -140,8 +137,7 @@ impl PaymentCred {
                 Ok(address)
             },
             err => Err(BlockfrostError::internal_server_error(format!(
-                "get_bech32_from_payment_cred hex decode error: {:?}",
-                err
+                "get_bech32_from_payment_cred hex decode error: {err:?}"
             ))),
         }
     }
diff --git a/src/server/state.rs b/src/server/state.rs
index c188d883..be3942b1 100644
--- a/src/server/state.rs
+++ b/src/server/state.rs
@@ -18,7 +18,7 @@ pub struct ApiPrefix(pub Option<uuid::Uuid>);
 impl std::fmt::Display for ApiPrefix {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.0 {
-            Some(u) => write!(f, "/{}", u),
+            Some(u) => write!(f, "/{u}"),
             None => write!(f, "/"),
         }
     }

From 136faf888fb1b58561b21fb35f47d9c5ecca8a6f Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Tue, 1 Jul 2025 10:04:41 +0200
Subject: [PATCH 17/22] fix: the DMGs

---
 nix/internal/darwin.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nix/internal/darwin.nix b/nix/internal/darwin.nix
index 304efa37..59a3c48d 100644
--- a/nix/internal/darwin.nix
+++ b/nix/internal/darwin.nix
@@ -426,7 +426,7 @@ in
         };
         buildInputs = with pkgs; [apple-sdk_11 (darwinMinVersionHook "11.0") darwin.libffi];
         hardeningDisable = ["strictoverflow"]; # -fno-strict-overflow is not supported in clang on darwin
-        NIX_CFLAGS_COMPILE = ["-Wno-error=deprecated-declarations" "-Wno-error=cast-of-sel-type"];
+        NIX_CFLAGS_COMPILE = ["-Wno-error=deprecated-declarations" "-Wno-error=cast-of-sel-type" "-Wno-error=cast-function-type-mismatch"];
         preBuild =
           commonPreBuild
           + ''

From 6795489035a17c29d5aff788a528647ffc89a159 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Thu, 3 Jul 2025 15:16:10 +0200
Subject: [PATCH 18/22] chore: use the native `aarch64-linux` build of
 `testgen-hs` (with extra tx-gen features)

---
 build.rs                                      |   2 +-
 flake.lock                                    |   8 +-
 flake.nix                                     |   2 +-
 .../testgen-hs--enable-aarch64-linux.diff     | 127 ------------------
 nix/internal/unix.nix                         |  19 +--
 5 files changed, 7 insertions(+), 151 deletions(-)
 delete mode 100644 nix/internal/testgen-hs--enable-aarch64-linux.diff

diff --git a/build.rs b/build.rs
index 67e95fa8..33894f93 100644
--- a/build.rs
+++ b/build.rs
@@ -81,7 +81,7 @@ mod testgen_hs {
             return;
         }
 
-        let testgen_lib_version = "10.4.1.0";
+        let testgen_lib_version = "10.4.1.1";
 
         let suffix = if target_os == "windows" {
             ".zip"
diff --git a/flake.lock b/flake.lock
index cbd3041f..81c8124d 100644
--- a/flake.lock
+++ b/flake.lock
@@ -241,16 +241,16 @@
     "testgen-hs": {
       "flake": false,
       "locked": {
-        "lastModified": 1748953639,
-        "narHash": "sha256-DgbM5UUsxYMPJ1nl19AnCi3VdTj8WElB1A7zSE8iPII=",
+        "lastModified": 1751542906,
+        "narHash": "sha256-FYz1P11du5tSakpl2ec9CGdwEB5h+0FcdGPU3zXte60=",
         "owner": "input-output-hk",
         "repo": "testgen-hs",
-        "rev": "4f81d654fbd4a2bfa9d00c99b75e9725e8abd8e7",
+        "rev": "7d58736ed578a9ccf8337376b302bb188b74303f",
         "type": "github"
       },
       "original": {
         "owner": "input-output-hk",
-        "ref": "10.4.1.0",
+        "ref": "10.4.1.1",
         "repo": "testgen-hs",
         "type": "github"
       }
diff --git a/flake.nix b/flake.nix
index d1e30082..bf4ffedb 100644
--- a/flake.nix
+++ b/flake.nix
@@ -11,7 +11,7 @@
     flake-compat.flake = false;
     cardano-node.url = "github:IntersectMBO/cardano-node/10.4.1";
     cardano-node.flake = false; # otherwise, +2k dependencies we don’t really use
-    testgen-hs.url = "github:input-output-hk/testgen-hs/10.4.1.0"; # make sure it follows cardano-node
+    testgen-hs.url = "github:input-output-hk/testgen-hs/10.4.1.1"; # make sure it follows cardano-node
     testgen-hs.flake = false; # otherwise, +2k dependencies we don’t really use
     devshell.url = "github:numtide/devshell";
     devshell.inputs.nixpkgs.follows = "nixpkgs";
diff --git a/nix/internal/testgen-hs--enable-aarch64-linux.diff b/nix/internal/testgen-hs--enable-aarch64-linux.diff
deleted file mode 100644
index 9ad78090..00000000
--- a/nix/internal/testgen-hs--enable-aarch64-linux.diff
+++ /dev/null
@@ -1,127 +0,0 @@
-diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
-index 197c881..59ce8cc 100644
---- a/.github/workflows/release.yml
-+++ b/.github/workflows/release.yml
-@@ -30,6 +30,10 @@ jobs:
-             result-archive-x86_64-linux \
-             .#hydraJobs.testgen-hs.x86_64-linux
- 
-+          nix build -L --builders '' --max-jobs 0 --out-link \
-+            result-archive-aarch64-linux \
-+            .#hydraJobs.testgen-hs.aarch64-linux
-+
-           nix build -L --builders '' --max-jobs 0 --out-link \
-             result-archive-x86_64-windows \
-             .#hydraJobs.testgen-hs.x86_64-windows
-@@ -48,6 +52,7 @@ jobs:
-         with:
-           files: |
-             result-archive-x86_64-linux/*.tar.bz2
-+            result-archive-aarch64-linux/*.tar.bz2
-             result-archive-x86_64-darwin/*.tar.bz2
-             result-archive-aarch64-darwin/*.tar.bz2
-             result-archive-x86_64-windows/*.zip
-diff --git a/.github/workflows/upload.yml b/.github/workflows/upload.yml
-index e54ea87..6c3f02b 100644
---- a/.github/workflows/upload.yml
-+++ b/.github/workflows/upload.yml
-@@ -22,6 +22,7 @@ jobs:
-         run: |
-           set -euo pipefail
-           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-linux   && cp result/testgen-hs-*.* .
-+          nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.aarch64-linux  && cp result/testgen-hs-*.* .
-           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-windows && cp result/testgen-hs-*.* .
-           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.x86_64-darwin  && cp result/testgen-hs-*.* .
-           nix build --builders "" --max-jobs 0 .#hydraJobs.testgen-hs.aarch64-darwin && cp result/testgen-hs-*.* .
-@@ -49,6 +50,12 @@ jobs:
-           name: testgen-hs-${{ env.version }}-x86_64-linux.tar.bz2
-           path: testgen-hs-${{ env.version }}-x86_64-linux.tar.bz2
-           if-no-files-found: error
-+      - name: Upload Artifact (aarch64-linux)
-+        uses: actions/upload-artifact@v4
-+        with:
-+          name: testgen-hs-${{ env.version }}-aarch64-linux.tar.bz2
-+          path: testgen-hs-${{ env.version }}-aarch64-linux.tar.bz2
-+          if-no-files-found: error
-       - name: Upload Artifact (x86_64-windows)
-         uses: actions/upload-artifact@v4
-         with:
-diff --git a/flake.nix b/flake.nix
-index 72d2f8f..b192741 100644
---- a/flake.nix
-+++ b/flake.nix
-@@ -28,7 +28,7 @@
-           targetSystem: import ./nix/internal.nix {inherit inputs targetSystem;}
-         );
- 
--      systems = ["x86_64-linux" "aarch64-darwin" "x86_64-darwin"];
-+      systems = ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86_64-darwin"];
-       perSystem = {
-         config,
-         system,
-diff --git a/nix/internal.nix b/nix/internal.nix
-index 51248ac..61a7c70 100644
---- a/nix/internal.nix
-+++ b/nix/internal.nix
-@@ -13,11 +13,32 @@ assert __elem targetSystem ["x86_64-linux" "aarch64-linux" "aarch64-darwin" "x86
- in rec {
-   defaultPackage = testgen-hs;
- 
--  cardano-node-flake = (import inputs.flake-compat {src = inputs.cardano-node;}).defaultNix;
-+  cardano-node-flake = let
-+    unpatched = inputs.cardano-node;
-+  in
-+    (import inputs.flake-compat {
-+      src =
-+        if targetSystem != "aarch64-linux"
-+        then unpatched
-+        else {
-+          outPath = toString (pkgs.runCommand "source" {} ''
-+            cp -r ${unpatched} $out
-+            chmod -R +w $out
-+            cd $out
-+            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
-+            ${lib.optionalString (targetSystem == "aarch64-linux") ''
-+              sed -r 's/"-fexternal-interpreter"//g' -i $out/nix/haskell.nix
-+            ''}
-+          '');
-+          inherit (unpatched) rev shortRev lastModified lastModifiedDate;
-+        };
-+    })
-+    .defaultNix;
- 
-   cardano-node-packages =
-     {
-       x86_64-linux = cardano-node-flake.hydraJobs.x86_64-linux.musl;
-+      aarch64-linux = cardano-node-flake.packages.aarch64-linux;
-       x86_64-darwin = cardano-node-flake.packages.x86_64-darwin;
-       aarch64-darwin = cardano-node-flake.packages.aarch64-darwin;
-     }
-@@ -35,7 +56,10 @@ in rec {
-             cp -r ${unpatched} $out
-             chmod -R +w $out
-             cd $out
--            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} $out/nix/supported-systems.nix
-+            echo ${lib.escapeShellArg (builtins.toJSON [targetSystem])} >$out/nix/supported-systems.nix
-+            ${lib.optionalString (targetSystem == "aarch64-linux") ''
-+              sed -r 's/"-fexternal-interpreter"//g' -i $out/nix/haskell.nix
-+            ''}
-             cp -r ${../testgen-hs} ./testgen-hs
-             sed -r '/^packages:/ a\  testgen-hs' -i cabal.project
-             sed -r 's/other-modules:\s*/                    , /g' -i cardano-submit-api/cardano-submit-api.cabal
-@@ -51,6 +75,7 @@ in rec {
-   in
-     {
-       x86_64-linux = patched-flake.hydraJobs.x86_64-linux.musl.testgen-hs;
-+      aarch64-linux = patched-flake.packages.aarch64-linux.testgen-hs;
-       x86_64-darwin = patched-flake.packages.x86_64-darwin.testgen-hs;
-       aarch64-darwin = patched-flake.packages.aarch64-darwin.testgen-hs;
-       x86_64-windows = patched-flake.legacyPackages.x86_64-linux.hydraJobs.windows.testgen-hs;
-@@ -113,6 +138,7 @@ in rec {
-       aarch64-darwin = darwinLike;
-       x86_64-darwin = darwinLike;
-       x86_64-linux = linuxLike {};
-+      aarch64-linux = linuxLike {};
-       x86_64-windows = linuxLike {useZip = true;};
-     }
-     .${targetSystem};
diff --git a/nix/internal/unix.nix b/nix/internal/unix.nix
index 1add453c..2864d946 100644
--- a/nix/internal/unix.nix
+++ b/nix/internal/unix.nix
@@ -217,24 +217,7 @@ in
         done
       '';
 
-    testgen-hs-flake = let
-      unpatched = inputs.testgen-hs;
-    in
-      (import inputs.flake-compat {
-        src =
-          if targetSystem != "aarch64-linux"
-          then unpatched
-          else {
-            outPath = toString (pkgs.runCommand "source" {} ''
-              cp -r ${unpatched} $out
-              chmod -R +w $out
-              cd $out
-              patch -p1 -i ${./testgen-hs--enable-aarch64-linux.diff}
-            '');
-            inherit (unpatched) rev shortRev lastModified lastModifiedDate;
-          };
-      })
-      .defaultNix;
+    testgen-hs-flake = (import inputs.flake-compat {src = inputs.testgen-hs;}).defaultNix;
 
     testgen-hs = testgen-hs-flake.packages.${targetSystem}.default;
 

From 0ee8127ff23a6fcec49b8562bda7005ae2ecf450 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 7 Jul 2025 18:12:12 +0200
Subject: [PATCH 19/22] feat: connect `testgen-hs` new `Tx'Conway` generator to
 the Rust evaluation tests

---
 nix/devshells.nix                   |   4 +
 src/api/utils/txs/evaluate/model.rs |  12 +-
 src/cbor/tests.rs                   |   3 +
 src/cbor/tests/random_eval_tx.rs    | 536 ++++++++++++++++++++++++++++
 4 files changed, 549 insertions(+), 6 deletions(-)
 create mode 100644 src/cbor/tests/random_eval_tx.rs

diff --git a/nix/devshells.nix b/nix/devshells.nix
index a218c2bb..638e5a55 100644
--- a/nix/devshells.nix
+++ b/nix/devshells.nix
@@ -72,6 +72,10 @@ in {
         name = "TESTGEN_HS_PATH";
         value = lib.getExe internal.testgen-hs;
       }
+      {
+        name = "RUST_SRC_PATH";
+        value = "${internal.rustPackages.rust-src}/lib/rustlib/src/rust/library";
+      }
     ]
     ++ lib.optionals pkgs.stdenv.isDarwin [
       {
diff --git a/src/api/utils/txs/evaluate/model.rs b/src/api/utils/txs/evaluate/model.rs
index cdf64e2a..a549903b 100644
--- a/src/api/utils/txs/evaluate/model.rs
+++ b/src/api/utils/txs/evaluate/model.rs
@@ -17,13 +17,13 @@ pub struct TxEvaluationRequest {
 }
 
 pub type AdditionalUtxoSet = Vec<(TxIn, TxOut)>;
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub struct TxIn {
     #[serde(rename = "txId")]
     pub tx_id: String,
     pub index: u64,
 }
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub struct TxOut {
     pub address: String,
     pub value: Value,
@@ -77,21 +77,21 @@ impl From<ScriptNative> for NativeScript {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 #[serde(untagged)]
 pub enum Datum {
     String(String),
     Map(HashMap<String, String>),
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub struct Value {
     pub coins: u64,
     pub assets: Option<HashMap<String, u64>>, // asset name and number. Asset number can be negative when burning assets but this behaviour changed in Conway. Now it can be only PositiveCoin
 }
 
 // This is originally missing PlutusV3 since blockfrost uses Ogmios v5.6 which has slightly different data structure
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 //#[serde(untagged)]
 pub enum Script {
     #[serde(rename = "plutus:v1")]
@@ -104,7 +104,7 @@ pub enum Script {
     Native(ScriptNative),
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub enum ScriptNative {
     #[serde(rename = "any")]
     Any(Vec<ScriptNative>),
diff --git a/src/cbor/tests.rs b/src/cbor/tests.rs
index f0f28d10..173b11d4 100644
--- a/src/cbor/tests.rs
+++ b/src/cbor/tests.rs
@@ -11,6 +11,8 @@ use std::process::Command;
 #[cfg(not(feature = "tarpaulin"))]
 mod random;
 #[cfg(not(feature = "tarpaulin"))]
+mod random_eval_tx;
+#[cfg(not(feature = "tarpaulin"))]
 mod specific;
 
 #[derive(Deserialize, Debug)]
@@ -30,6 +32,7 @@ pub struct CborTestSeed {
 #[derive(Debug, Clone, Copy)]
 #[allow(non_camel_case_types, dead_code)]
 pub enum CaseType {
+    Tx_Conway,
     ApplyTxErr_Byron,
     ApplyTxErr_Shelley,
     ApplyTxErr_Allegra,
diff --git a/src/cbor/tests/random_eval_tx.rs b/src/cbor/tests/random_eval_tx.rs
new file mode 100644
index 00000000..791c29b0
--- /dev/null
+++ b/src/cbor/tests/random_eval_tx.rs
@@ -0,0 +1,536 @@
+use super::*;
+
+// -------------------------- random evaluation tests -------------------------- //
+
+#[test]
+#[allow(non_snake_case)]
+fn proptest_eval_Tx_Conway_size_001() {
+    proptest_with_params(CaseType::Tx_Conway, 100, 10, None)
+}
+
+// -------------------------- random UTxO decoder tests -------------------------- //
+
+#[test]
+fn proptest_utxo_decoder() {
+    check_generated_cases(CaseType::Tx_Conway, 500, 10, 5, None, |case| {
+        let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
+        let utxo_cbor = json.utxo_set_cbor;
+        let utxo_decoded = utxo_decoder::decode_utxo(&hex::decode(&utxo_cbor).unwrap());
+        if utxo_decoded.is_ok() {
+            Ok(())
+        } else {
+            Err(utxo_cbor)
+        }
+    })
+}
+
+// -------------------------- helper functions -------------------------- //
+
+/// Tests the native Rust deserializer with the given params.
+fn proptest_with_params(
+    case_type: CaseType,
+    num_cases: u32,
+    generator_size: u16,
+    seed: Option<u64>,
+) {
+    use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
+
+    check_generated_cases(case_type, num_cases, generator_size, 5, seed, |case| {
+        let tx_cbor = case.cbor.clone();
+        let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
+        let expected = json.execution_units;
+        let utxo_cbor = json.utxo_set_cbor;
+        let utxo: AdditionalUtxoSet =
+            utxo_decoder::decode_utxo(&hex::decode(&utxo_cbor).unwrap()).unwrap();
+
+        // TODO: okay, so now we have `tx_cbor`, `AdditionalUtxoSet`, and the `expected` JSON.
+        // TODO: it’s time to call `crate::cbor::evaluate_tx()`, but it needs a `cardano-node` 👀
+
+        todo!()
+    })
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all(deserialize = "camelCase"))]
+pub struct TestCaseJson {
+    pub execution_units: serde_json::Value,
+    #[serde(rename = "utxoSetCBOR")]
+    pub utxo_set_cbor: String,
+}
+
+// -------------------------- draft UTxO decoder (could be wrong!) -------------------------- //
+
+mod utxo_decoder {
+    use crate::api::utils::txs::evaluate::model::{
+        AdditionalUtxoSet, Script, ScriptNative, TxIn, TxOut, Value,
+    };
+    use pallas_codec::minicbor;
+
+    use anyhow::{Result, anyhow, bail};
+    use bech32::{ToBase32, Variant, encode};
+    use minicbor::{data::Type as CborType, decode::Decoder};
+    use std::collections::HashMap;
+
+    pub fn decode_utxo(bytes: &[u8]) -> Result<AdditionalUtxoSet> {
+        let mut d = Decoder::new(bytes);
+
+        let map_len = d
+            .map()?
+            .ok_or_else(|| anyhow!("UTxO map must be definite"))?;
+        let mut out = Vec::with_capacity(map_len as usize);
+
+        for _ in 0..map_len {
+            let tx_in = decode_txin(&mut d)?;
+            let tx_out = decode_txout(&mut d, bytes)?;
+            out.push((tx_in, tx_out));
+        }
+        Ok(out)
+    }
+
+    fn decode_txin(d: &mut Decoder<'_>) -> Result<TxIn> {
+        match d.array()? {
+            Some(2) => {},
+            Some(n) => bail!("TxIn array length {n} ≠ 2"),
+            None => bail!("TxIn must be definite-length"),
+        }
+
+        let txid = d.bytes()?;
+        if txid.len() != 32 {
+            bail!("TxId len {} ≠ 32", txid.len());
+        }
+        let idx = d.u64()?;
+
+        Ok(TxIn {
+            tx_id: hex::encode(txid),
+            index: idx,
+        })
+    }
+
+    fn decode_txout<'b>(d: &mut Decoder<'b>, src: &'b [u8]) -> Result<TxOut> {
+        match d.datatype()? {
+            CborType::Map => decode_txout_map(d, src),
+            CborType::Array => decode_txout_array(d, src),
+            other => bail!("TxOut must be map or array, got {:?}", other),
+        }
+    }
+
+    fn decode_txout_map<'b>(d: &mut Decoder<'b>, src: &'b [u8]) -> Result<TxOut> {
+        let pairs = d
+            .map()?
+            .ok_or_else(|| anyhow!("TxOut map must be definite"))?;
+
+        let mut addr_bytes = None;
+        let mut value = None;
+        let mut datum_hash = None;
+        let mut datum = None;
+        let mut script = None;
+
+        for _ in 0..pairs {
+            let key = d.u64()?;
+            match key {
+                0 => {
+                    let bytes = d.bytes()?;
+                    addr_bytes = Some(bytes.to_vec());
+                },
+
+                1 => value = Some(decode_value(d)?),
+
+                2 => {
+                    let start = d.position();
+                    match d.datatype()? {
+                        CborType::Bytes => {
+                            let bs = d.bytes()?;
+                            if bs.len() == 32 {
+                                datum_hash = Some(hex::encode(bs));
+                            } else {
+                                datum = Some(hex::encode(bs));
+                            }
+                        },
+                        _ => {
+                            let raw = read_term(d, src, start)?;
+                            datum = Some(hex::encode(&raw));
+                        },
+                    }
+                },
+
+                3 => {
+                    let start = d.position();
+                    let raw = read_term(d, src, start)?;
+                    script = Some(parse_script(&raw)?);
+                },
+
+                _ => {
+                    d.skip()?;
+                },
+            }
+        }
+
+        let addr_bytes = addr_bytes.ok_or_else(|| anyhow!("TxOut missing address"))?;
+        let value = value.ok_or_else(|| anyhow!("TxOut missing value"))?;
+
+        let hrp = if addr_bytes.first().map_or(false, |b| b & 0b0001_0000 == 0) {
+            "addr"
+        } else {
+            "addr_test"
+        };
+        let address = encode(hrp, addr_bytes.to_base32(), Variant::Bech32)?;
+
+        Ok(TxOut {
+            address,
+            value,
+            datum_hash,
+            datum,
+            script,
+        })
+    }
+
+    fn decode_txout_array<'b>(d: &mut Decoder<'b>, src: &'b [u8]) -> Result<TxOut> {
+        let len = d
+            .array()?
+            .ok_or_else(|| anyhow!("TxOut must be definite"))?;
+        if !(2..=4).contains(&len) {
+            bail!("unexpected TxOut length {len}");
+        }
+
+        let addr_bytes = d.bytes()?;
+        let hrp = if addr_bytes.first().map_or(false, |b| b & 0b0001_0000 == 0) {
+            "addr"
+        } else {
+            "addr_test"
+        };
+        let address = encode(hrp, addr_bytes.to_base32(), Variant::Bech32)?;
+
+        let value = decode_value(d)?;
+
+        let mut datum_hash = None;
+        let mut datum = None;
+        let mut script = None;
+
+        match len {
+            2 => {},
+            3 => {
+                let dh = d.bytes()?;
+                if dh.len() != 32 {
+                    bail!("datumHash len {} ≠ 32", dh.len());
+                }
+                datum_hash = Some(hex::encode(dh));
+            },
+            4 => {
+                let start = d.position();
+                match d.datatype()? {
+                    CborType::Bytes => {
+                        let bs = d.bytes()?;
+                        if bs.len() == 32 {
+                            datum_hash = Some(hex::encode(bs));
+                        } else {
+                            datum = Some(hex::encode(bs));
+                        }
+                    },
+                    _ => {
+                        let bytes = read_term(d, src, start)?;
+                        datum = Some(hex::encode(&bytes));
+                    },
+                }
+                let start = d.position();
+                let raw = read_term(d, src, start)?;
+                script = Some(parse_script(&raw)?);
+            },
+            _ => unreachable!(),
+        }
+
+        Ok(TxOut {
+            address,
+            value,
+            datum_hash,
+            datum,
+            script,
+        })
+    }
+
+    fn decode_value(d: &mut Decoder<'_>) -> Result<Value> {
+        match d.datatype()? {
+            CborType::U8 | CborType::U16 | CborType::U32 | CborType::U64 => Ok(Value {
+                coins: d.u64()?,
+                assets: None,
+            }),
+
+            CborType::Map => {
+                let outer = d
+                    .map()?
+                    .ok_or_else(|| anyhow!("multi-asset must be definite"))?;
+                let mut assets = HashMap::<String, u64>::new();
+                let mut coin = 0u64;
+
+                for _ in 0..outer {
+                    match d.datatype()? {
+                        CborType::U8 | CborType::U16 | CborType::U32 | CborType::U64 => {
+                            if d.u64()? != 0 {
+                                bail!("unexpected integer key in value map");
+                            }
+                            coin = d.u64()?;
+                        },
+                        CborType::Bytes => {
+                            let policy = d.bytes()?.to_vec();
+                            let inner = d
+                                .map()?
+                                .ok_or_else(|| anyhow!("asset map must be definite"))?;
+                            for _ in 0..inner {
+                                let name = d.bytes()?.to_vec();
+                                let qty = d.i64()?;
+                                if qty < 0 {
+                                    bail!("burning not allowed in Conway value");
+                                }
+                                let key =
+                                    format!("{}.{}", hex::encode(&policy), hex::encode(&name));
+                                assets.insert(key, qty as u64);
+                            }
+                        },
+                        t => bail!("unexpected CBOR type {:?} in value map", t),
+                    }
+                }
+
+                Ok(Value {
+                    coins: coin,
+                    assets: if assets.is_empty() {
+                        None
+                    } else {
+                        Some(assets)
+                    },
+                })
+            },
+
+            t => bail!("unexpected CBOR type {:?} for TxOut value", t),
+        }
+    }
+
+    fn peel_tags(input: &[u8]) -> Result<&[u8]> {
+        let mut d = Decoder::new(input);
+
+        while let CborType::Tag = d.datatype()? {
+            let _t = d.tag()?; // ignore tag number
+        }
+
+        let start = d.position();
+        Ok(&input[start..])
+    }
+
+    fn parse_script(bytes: &[u8]) -> Result<Script> {
+        let payload = peel_tags(bytes)?;
+
+        let mut d = Decoder::new(payload);
+
+        if matches!(d.datatype()?, CborType::Bytes) {
+            return parse_script(d.bytes()?);
+        }
+
+        if matches!(d.datatype()?, CborType::Array) {
+            let len = d
+                .array()?
+                .ok_or_else(|| anyhow!("script array indefinite"))?;
+            if len == 0 {
+                bail!("empty script array");
+            }
+
+            let tag = d.u64()?; // first element
+
+            if (1..=3).contains(&tag) && len == 2 {
+                let start = d.position(); // 2nd element
+                d.skip()?; // walk over it
+                let end = d.position();
+                let hex = hex::encode(&payload[start..end]);
+                return Ok(match tag {
+                    1 => Script::PlutusV1(hex),
+                    2 => Script::PlutusV2(hex),
+                    3 => Script::PlutusV3(hex),
+                    _ => unreachable!(),
+                });
+            }
+
+            return Ok(Script::Native(parse_native_array(payload)?));
+        }
+
+        if matches!(d.datatype()?, CborType::Map) {
+            return Ok(Script::Native(parse_native_map(payload)?));
+        }
+
+        bail!("reference script must be array, map, or Tag-24-wrapped bytes")
+    }
+
+    fn parse_native_array(bytes: &[u8]) -> Result<ScriptNative> {
+        let mut d = Decoder::new(bytes);
+        let len = d
+            .array()?
+            .ok_or_else(|| anyhow!("native array indefinite"))?;
+
+        if len == 0 {
+            return Ok(ScriptNative::All(Vec::new()));
+        }
+
+        let first_ty = d.datatype()?;
+        if !matches!(
+            first_ty,
+            CborType::U8 | CborType::U16 | CborType::U32 | CborType::U64
+        ) {
+            let subs = gather_subscripts(len as usize, &mut d, bytes)?;
+            return Ok(ScriptNative::All(subs));
+        }
+
+        let tag = d.u64()?;
+        match tag {
+            0 => match d.datatype()? {
+                CborType::Bytes => {
+                    return Ok(ScriptNative::String(hex::encode(d.bytes()?)));
+                },
+
+                _ => {
+                    let subs = gather_subscripts((len - 1) as usize, &mut d, bytes)?;
+                    return Ok(ScriptNative::Any(subs));
+                },
+            },
+
+            1 => {
+                let subs = gather_subscripts((len - 1) as usize, &mut d, bytes)?;
+                Ok(ScriptNative::All(subs))
+            },
+
+            2 => {
+                let subs = gather_subscripts((len - 1) as usize, &mut d, bytes)?;
+                Ok(ScriptNative::Any(subs))
+            },
+
+            3 => {
+                let start_tail = d.position(); // decoder is already at 1st payload item
+
+                for _ in 0..(len - 1) {
+                    d.skip()?;
+                }
+                let end_tail = d.position();
+
+                let tail = &bytes[start_tail..end_tail];
+
+                let mut d2 = Decoder::new(tail);
+                let mut subs = Vec::<ScriptNative>::new();
+                let mut last_int = None;
+
+                while d2.position() < tail.len() {
+                    match d2.datatype()? {
+                        CborType::U8 | CborType::U16 | CborType::U32 | CborType::U64 => {
+                            last_int = Some(d2.u64()?);
+                        },
+
+                        CborType::Array => {
+                            let start = d2.position();
+                            d2.skip()?;
+                            let end = d2.position();
+                            let slice = &tail[start..end];
+                            subs.push(
+                                parse_native_array(slice).or_else(|_| parse_native_map(slice))?,
+                            );
+                        },
+
+                        CborType::Map => {
+                            let start = d2.position();
+                            d2.skip()?;
+                            let end = d2.position();
+                            subs.push(parse_native_map(&tail[start..end])?);
+                        },
+
+                        other => bail!("unexpected CBOR type {:?} inside N-of payload", other),
+                    }
+                }
+
+                let n = last_int.ok_or_else(|| anyhow!("N-of payload missing threshold"))? as u32;
+                return Ok(ScriptNative::NOf(n, subs));
+            },
+
+            4 | 5 => {
+                let slot = match d.datatype()? {
+                    CborType::U8 | CborType::U16 | CborType::U32 | CborType::U64 => d.u64()?,
+                    CborType::Array => {
+                        // unwrap single-element array
+                        let alen = d.array()?.ok_or_else(|| anyhow!("slot array indefinite"))?;
+                        if alen != 1 {
+                            bail!("slot array len {} ≠ 1", alen);
+                        }
+                        d.u64()?
+                    },
+                    other => bail!("slot must be integer or single-item array, got {:?}", other),
+                };
+                return Ok(if tag == 4 {
+                    ScriptNative::StartsAt(slot)
+                } else {
+                    ScriptNative::ExpiresAt(slot)
+                });
+            },
+
+            _ => bail!("unknown or malformed native script tag {tag}"),
+        }
+    }
+
+    fn parse_native_map(bytes: &[u8]) -> Result<ScriptNative> {
+        let mut d = Decoder::new(bytes);
+        let len = d.map()?.ok_or_else(|| anyhow!("native map indefinite"))?;
+        if len != 1 {
+            bail!("native map must have exactly 1 pair, got {}", len);
+        }
+
+        let tag = d.u64()?;
+        match tag {
+            0 => Ok(ScriptNative::String(hex::encode(d.bytes()?))),
+
+            1 => {
+                let subs = gather_subscripts_from_cbor(&mut d, bytes)?;
+                Ok(ScriptNative::All(subs))
+            },
+
+            2 => {
+                let subs = gather_subscripts_from_cbor(&mut d, bytes)?;
+                Ok(ScriptNative::Any(subs))
+            },
+
+            3 => {
+                let n = d.u64()? as u32;
+                let subs = gather_subscripts_from_cbor(&mut d, bytes)?;
+                Ok(ScriptNative::NOf(n, subs))
+            },
+
+            4 => Ok(ScriptNative::StartsAt(d.u64()?)),
+            5 => Ok(ScriptNative::ExpiresAt(d.u64()?)),
+            _ => bail!("unknown native map tag {tag}"),
+        }
+    }
+
+    fn gather_subscripts(
+        count: usize,
+        d: &mut Decoder<'_>,
+        src: &[u8],
+    ) -> Result<Vec<ScriptNative>> {
+        let mut out = Vec::with_capacity(count);
+        for _ in 0..count {
+            let start = d.position();
+            d.skip()?;
+            let end = d.position();
+            let slice = &src[start..end];
+
+            match Decoder::new(slice).datatype()? {
+                CborType::Array => out.push(parse_native_array(slice)?),
+                CborType::Map => out.push(parse_native_map(slice)?),
+                other => bail!("unexpected CBOR type {:?} in sub-script", other),
+            }
+        }
+        Ok(out)
+    }
+
+    fn gather_subscripts_from_cbor(d: &mut Decoder<'_>, src: &[u8]) -> Result<Vec<ScriptNative>> {
+        let remaining = d
+            .array()?
+            .ok_or_else(|| anyhow!("sub-script list indefinite"))?;
+        gather_subscripts(remaining as usize, d, src)
+    }
+
+    fn read_term<'b>(d: &mut Decoder<'b>, src: &'b [u8], start: usize) -> Result<Vec<u8>> {
+        d.skip()?;
+        let end = d.position();
+        Ok(src[start..end].to_vec())
+    }
+}

From 9086d55669089f0645b04a48991a94a6603dc7fc Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 7 Jul 2025 18:21:40 +0200
Subject: [PATCH 20/22] fix: compilation warnings about unused variables

---
 src/cbor/tests/random_eval_tx.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cbor/tests/random_eval_tx.rs b/src/cbor/tests/random_eval_tx.rs
index 791c29b0..7ae96284 100644
--- a/src/cbor/tests/random_eval_tx.rs
+++ b/src/cbor/tests/random_eval_tx.rs
@@ -36,11 +36,11 @@ fn proptest_with_params(
     use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
 
     check_generated_cases(case_type, num_cases, generator_size, 5, seed, |case| {
-        let tx_cbor = case.cbor.clone();
+        let _tx_cbor = case.cbor.clone();
         let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
-        let expected = json.execution_units;
+        let _expected = json.execution_units;
         let utxo_cbor = json.utxo_set_cbor;
-        let utxo: AdditionalUtxoSet =
+        let _utxo: AdditionalUtxoSet =
             utxo_decoder::decode_utxo(&hex::decode(&utxo_cbor).unwrap()).unwrap();
 
         // TODO: okay, so now we have `tx_cbor`, `AdditionalUtxoSet`, and the `expected` JSON.

From c8e5fb023258e198d8a270042c004ff213ead246 Mon Sep 17 00:00:00 2001
From: Michal Rus <michal.rus@iohk.io>
Date: Mon, 7 Jul 2025 18:39:12 +0200
Subject: [PATCH 21/22] fix: make the failures prettier, and _not_ `panic`s

---
 src/cbor/tests/random_eval_tx.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/cbor/tests/random_eval_tx.rs b/src/cbor/tests/random_eval_tx.rs
index 7ae96284..e87115c4 100644
--- a/src/cbor/tests/random_eval_tx.rs
+++ b/src/cbor/tests/random_eval_tx.rs
@@ -4,7 +4,7 @@ use super::*;
 
 #[test]
 #[allow(non_snake_case)]
-fn proptest_eval_Tx_Conway_size_001() {
+fn proptest_eval_Tx_Conway_size_010() {
     proptest_with_params(CaseType::Tx_Conway, 100, 10, None)
 }
 
@@ -36,17 +36,22 @@ fn proptest_with_params(
     use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
 
     check_generated_cases(case_type, num_cases, generator_size, 5, seed, |case| {
-        let _tx_cbor = case.cbor.clone();
+        let tx_cbor = case.cbor.clone();
         let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
-        let _expected = json.execution_units;
+        let expected = json.execution_units;
         let utxo_cbor = json.utxo_set_cbor;
-        let _utxo: AdditionalUtxoSet =
+        let utxo: AdditionalUtxoSet =
             utxo_decoder::decode_utxo(&hex::decode(&utxo_cbor).unwrap()).unwrap();
 
         // TODO: okay, so now we have `tx_cbor`, `AdditionalUtxoSet`, and the `expected` JSON.
         // TODO: it’s time to call `crate::cbor::evaluate_tx()`, but it needs a `cardano-node` 👀
 
-        todo!()
+        Err(format!(
+            "Unimplemented:\n  Transaction: {tx_cbor}\n  Expected: {}\n  UTxO: {utxo:?}",
+            serde_json::to_string_pretty(&expected)
+                .unwrap()
+                .replace("\n", "\n  ")
+        ))
     })
 }
 

From 0fdfd5b46b16e2e2af093f7c8f182f2d19f44457 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C4=B1z=C4=B1r=20Sefa=20=C4=B0rken?= <sefairken@gmail.com>
Date: Thu, 24 Jul 2025 12:19:20 +0300
Subject: [PATCH 22/22] feat: Native Rust evaluate, Haskell evaluate and tests

---
 Cargo.lock                                    |  76 ++---
 Cargo.toml                                    |  16 +-
 build.rs                                      |   2 +-
 flake.lock                                    |   2 +-
 flake.nix                                     |   2 +-
 src/api/utils/txs/evaluate/model.rs           |  68 +++-
 src/api/utils/txs/evaluate/root.rs            |  12 +-
 src/api/utils/txs/evaluate/utxos.rs           |  18 +-
 src/cbor.rs                                   |   3 +-
 src/cbor/evaluate.rs                          | 305 +++++++++++-------
 src/cbor/external.rs                          |   3 +
 src/cbor/external/fallback_decoder.rs         | 102 ++++++
 src/cbor/external/fallback_evaluator.rs       | 230 +++++++++++++
 .../testgen.rs}                               | 141 ++------
 src/cbor/tests.rs                             |   7 +-
 src/cbor/tests/random_eval_tx.rs              |  55 +++-
 src/cbor/tests/test_data.rs                   | 185 +++++++++++
 src/node.rs                                   |   1 +
 src/node/utxo.rs                              |  23 ++
 src/server.rs                                 |  12 +
 src/server/chain_config.rs                    |  59 ++++
 src/server/state.rs                           |   1 +
 tests/api/utils/txs/evaluate/root.rs          | 113 ++++++-
 tests/api/utils/txs/evaluate/utxos.rs         |  86 +++--
 24 files changed, 1182 insertions(+), 340 deletions(-)
 create mode 100644 src/cbor/external.rs
 create mode 100644 src/cbor/external/fallback_decoder.rs
 create mode 100644 src/cbor/external/fallback_evaluator.rs
 rename src/cbor/{fallback_decoder.rs => external/testgen.rs} (69%)
 create mode 100644 src/cbor/tests/test_data.rs
 create mode 100644 src/node/utxo.rs
 create mode 100644 src/server/chain_config.rs

diff --git a/Cargo.lock b/Cargo.lock
index 7c79d89e..87641106 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -201,12 +201,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "az"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
-
 [[package]]
 name = "backtrace"
 version = "0.3.74"
@@ -1336,16 +1330,6 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
-[[package]]
-name = "gmp-mpfr-sys"
-version = "1.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66d61197a68f6323b9afa616cf83d55d69191e1bf364d4eb7d35ae18defe776"
-dependencies = [
- "libc",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "h2"
 version = "0.4.9"
@@ -1600,7 +1584,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.57.0",
+ "windows-core 0.58.0",
 ]
 
 [[package]]
@@ -1612,6 +1596,17 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "ibig"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1fcc7f316b2c079dde77564a1360639c1a956a23fa96122732e416cb10717bb"
+dependencies = [
+ "cfg-if",
+ "num-traits",
+ "static_assertions",
+]
+
 [[package]]
 name = "icu_collections"
 version = "1.5.0"
@@ -1900,12 +1895,6 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
-[[package]]
-name = "libm"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
-
 [[package]]
 name = "libproc"
 version = "0.14.10"
@@ -2404,7 +2393,7 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 [[package]]
 name = "pallas-addresses"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "base58",
  "bech32 0.9.1",
@@ -2419,7 +2408,7 @@ dependencies = [
 [[package]]
 name = "pallas-codec"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "hex",
  "minicbor 0.26.4",
@@ -2430,7 +2419,7 @@ dependencies = [
 [[package]]
 name = "pallas-crypto"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "cryptoxide",
  "hex",
@@ -2443,7 +2432,7 @@ dependencies = [
 [[package]]
 name = "pallas-hardano"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "binary-layout",
  "hex",
@@ -2463,7 +2452,7 @@ dependencies = [
 [[package]]
 name = "pallas-network"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "byteorder",
  "hex",
@@ -2480,7 +2469,7 @@ dependencies = [
 [[package]]
 name = "pallas-primitives"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "hex",
  "pallas-codec",
@@ -2492,7 +2481,7 @@ dependencies = [
 [[package]]
 name = "pallas-traverse"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "hex",
  "itertools 0.13.0",
@@ -2508,7 +2497,7 @@ dependencies = [
 [[package]]
 name = "pallas-validate"
 version = "1.0.0-alpha.2"
-source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha3#00acd70a069cfeb1913148ab7b38cf3a1bbd4668"
+source = "git+https://github.com/blockfrost/pallas.git?tag=blockfrost-platform-0.0.3-alpha5#b35d3bd96f29cb19b80fbc0acfa038532ddd0da4"
 dependencies = [
  "chrono",
  "hex",
@@ -2518,7 +2507,6 @@ dependencies = [
  "pallas-crypto",
  "pallas-primitives",
  "pallas-traverse",
- "rug",
  "serde",
  "thiserror 1.0.69",
  "tracing",
@@ -3086,18 +3074,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "rug"
-version = "1.27.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4207e8d668e5b8eb574bda8322088ccd0d7782d3d03c7e8d562e82ed82bdcbc3"
-dependencies = [
- "az",
- "gmp-mpfr-sys",
- "libc",
- "libm",
-]
-
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -3658,6 +3634,12 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -4236,16 +4218,16 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 [[package]]
 name = "uplc-turbo"
 version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214465664561ad67daf411e1d575a67cf25107369191f26c16243ac98073c0a8"
+source = "git+https://github.com/txpipe/uplc-turbo.git?rev=bd174b3#bd174b318a69b09d4b67642e60b60cc2be51b087"
 dependencies = [
  "blst",
  "bumpalo",
  "chumsky",
  "cryptoxide",
+ "ibig",
  "minicbor 0.25.1",
+ "num-traits",
  "once_cell",
- "rug",
  "secp256k1",
  "thiserror 1.0.69",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index cc0dd054..bb346f02 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,13 +31,13 @@ sentry = "0.36.0"
 blake2 = "0.10.6"
 base64 = "0.22.1"
 num_cpus = "1"
-pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
-pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3" }
+pallas-network = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-crypto = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-traverse = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-codec = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-addresses = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-primitives = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
+pallas-hardano = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5" }
 reqwest = "0.12.12"
 hex = "0.4.3"
 metrics = { version = "0.24.1", default-features = false }
@@ -58,7 +58,7 @@ bech32 = "0.9.1"
 cardano-serialization-lib = "12.1.1"
 
 [target.'cfg(not(target_os = "windows"))'.dependencies]
-pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha3", features = [
+pallas-validate = { git = "https://github.com/blockfrost/pallas.git", tag = "blockfrost-platform-0.0.3-alpha5", features = [
   "phase2",
 ] }
 
diff --git a/build.rs b/build.rs
index 33894f93..c20823b2 100644
--- a/build.rs
+++ b/build.rs
@@ -81,7 +81,7 @@ mod testgen_hs {
             return;
         }
 
-        let testgen_lib_version = "10.4.1.1";
+        let testgen_lib_version = "10.4.1.2";
 
         let suffix = if target_os == "windows" {
             ".zip"
diff --git a/flake.lock b/flake.lock
index 81c8124d..e2534c77 100644
--- a/flake.lock
+++ b/flake.lock
@@ -250,7 +250,7 @@
       },
       "original": {
         "owner": "input-output-hk",
-        "ref": "10.4.1.1",
+        "ref": "10.4.1.2",
         "repo": "testgen-hs",
         "type": "github"
       }
diff --git a/flake.nix b/flake.nix
index bf4ffedb..fee8cc54 100644
--- a/flake.nix
+++ b/flake.nix
@@ -11,7 +11,7 @@
     flake-compat.flake = false;
     cardano-node.url = "github:IntersectMBO/cardano-node/10.4.1";
     cardano-node.flake = false; # otherwise, +2k dependencies we don’t really use
-    testgen-hs.url = "github:input-output-hk/testgen-hs/10.4.1.1"; # make sure it follows cardano-node
+    testgen-hs.url = "github:input-output-hk/testgen-hs/10.4.1.2"; # make sure it follows cardano-node
     testgen-hs.flake = false; # otherwise, +2k dependencies we don’t really use
     devshell.url = "github:numtide/devshell";
     devshell.inputs.nixpkgs.follows = "nixpkgs";
diff --git a/src/api/utils/txs/evaluate/model.rs b/src/api/utils/txs/evaluate/model.rs
index a549903b..388f5a3d 100644
--- a/src/api/utils/txs/evaluate/model.rs
+++ b/src/api/utils/txs/evaluate/model.rs
@@ -1,9 +1,6 @@
 use std::collections::HashMap;
 
-use pallas_primitives::{
-    Bytes, ExUnits, KeepRaw, PlutusScript,
-    conway::{NativeScript, RedeemerTag, ScriptRef},
-};
+use pallas_primitives::{Bytes, ExUnits, KeepRaw, conway::RedeemerTag};
 use pallas_validate::phase2::EvalReport;
 use pallas_validate::phase2::tx::TxEvalResult;
 use serde::{Deserialize, Serialize, ser::SerializeMap};
@@ -33,8 +30,10 @@ pub struct TxOut {
     pub script: Option<Script>, // script type and details
 }
 
-impl From<Script> for ScriptRef<'_> {
+impl From<Script> for pallas_primitives::conway::ScriptRef<'_> {
     fn from(script: Script) -> Self {
+        use pallas_primitives::PlutusScript;
+        use pallas_primitives::conway::ScriptRef;
         match script {
             Script::PlutusV1(s) => {
                 ScriptRef::PlutusV1Script(PlutusScript::<1>(Bytes::from(hex::decode(s).unwrap())))
@@ -46,6 +45,7 @@ impl From<Script> for ScriptRef<'_> {
                 ScriptRef::PlutusV3Script(PlutusScript::<3>(Bytes::from(hex::decode(s).unwrap())))
             },
             Script::Native(script_native) => {
+                use pallas_primitives::conway::NativeScript;
                 let script: NativeScript = script_native.into();
                 let r_script: KeepRaw<'_, NativeScript> = script.into(); // @todo: does not generate a valid raw CBOR 
                 ScriptRef::NativeScript(r_script)
@@ -54,8 +54,57 @@ impl From<Script> for ScriptRef<'_> {
     }
 }
 
-impl From<ScriptNative> for NativeScript {
+impl From<Script> for pallas_network::miniprotocols::localtxsubmission::primitives::ScriptRef {
+    fn from(script: Script) -> Self {
+        use pallas_network::miniprotocols::localtxsubmission::primitives::PlutusScript;
+        use pallas_network::miniprotocols::localtxsubmission::primitives::ScriptRef;
+        match script {
+            Script::PlutusV1(s) => {
+                ScriptRef::PlutusV1Script(PlutusScript::<1>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::PlutusV2(s) => {
+                ScriptRef::PlutusV2Script(PlutusScript::<2>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::PlutusV3(s) => {
+                ScriptRef::PlutusV3Script(PlutusScript::<3>(Bytes::from(hex::decode(s).unwrap())))
+            },
+            Script::Native(script_native) => {
+                let script: pallas_network::miniprotocols::localtxsubmission::primitives::NativeScript = script_native.into();
+                ScriptRef::NativeScript(script)
+            },
+        }
+    }
+}
+
+impl From<ScriptNative>
+    for pallas_network::miniprotocols::localtxsubmission::primitives::NativeScript
+{
     fn from(script: ScriptNative) -> Self {
+        use pallas_network::miniprotocols::localtxsubmission::primitives::NativeScript;
+        match script {
+            ScriptNative::Any(scripts) => {
+                NativeScript::ScriptAny(scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::All(scripts) => {
+                NativeScript::ScriptAll(scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::ExpiresAt(time) => NativeScript::InvalidHereafter(time),
+            ScriptNative::StartsAt(time) => NativeScript::InvalidBefore(time),
+            ScriptNative::NOf(n, scripts) => {
+                NativeScript::ScriptNOfK(n, scripts.into_iter().map(|s| s.into()).collect())
+            },
+            ScriptNative::String(st) => {
+                let mut bytes = [0; 28];
+                hex::decode_to_slice(st, &mut bytes).unwrap();
+                NativeScript::ScriptPubkey(bytes.into())
+            },
+        }
+    }
+}
+
+impl From<ScriptNative> for pallas_primitives::conway::NativeScript {
+    fn from(script: ScriptNative) -> Self {
+        use pallas_primitives::conway::NativeScript;
         match script {
             ScriptNative::Any(scripts) => {
                 NativeScript::ScriptAny(scripts.into_iter().map(|s| s.into()).collect())
@@ -91,7 +140,7 @@ pub struct Value {
 }
 
 // This is originally missing PlutusV3 since blockfrost uses Ogmios v5.6 which has slightly different data structure
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 //#[serde(untagged)]
 pub enum Script {
     #[serde(rename = "plutus:v1")]
@@ -104,7 +153,7 @@ pub enum Script {
     Native(ScriptNative),
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub enum ScriptNative {
     #[serde(rename = "any")]
     Any(Vec<ScriptNative>),
@@ -145,6 +194,7 @@ pub struct TxEvalResultResponse {
 
 impl From<TxEvalResultResponse> for TxEvalResult {
     fn from(value: TxEvalResultResponse) -> Self {
+        // pallas-validate is rapidly evolving. logs and success are new fields, not yet handled.
         TxEvalResult {
             tag: value.tag,
             index: value.index,
@@ -152,6 +202,8 @@ impl From<TxEvalResultResponse> for TxEvalResult {
                 mem: value.units.memory,
                 steps: value.units.cpu,
             },
+            logs: Vec::new(),
+            success: true
         }
     }
 }
diff --git a/src/api/utils/txs/evaluate/root.rs b/src/api/utils/txs/evaluate/root.rs
index a37e8547..fdbdc61a 100644
--- a/src/api/utils/txs/evaluate/root.rs
+++ b/src/api/utils/txs/evaluate/root.rs
@@ -1,15 +1,14 @@
 use crate::{
     BlockfrostError, NodePool,
-    cbor::evaluate,
+    cbor::external::fallback_evaluator::FallbackEvaluator,
     common::{binary_or_hex_heuristic, validate_content_type},
 };
 use axum::{Extension, Json, response::IntoResponse};
 use hyper::HeaderMap;
 
-use super::model::convert_eval_report;
-
 pub async fn route(
     Extension(node): Extension<NodePool>,
+    Extension(fallback_evaluator): Extension<FallbackEvaluator>,
     headers: HeaderMap,
     body: axum::body::Bytes,
 ) -> Result<impl IntoResponse, BlockfrostError> {
@@ -17,10 +16,11 @@ pub async fn route(
     validate_content_type(&headers, &["application/cbor"])?;
 
     // Allow both hex-encoded and raw binary bodies
-    let binary_tx = binary_or_hex_heuristic(body.as_ref());
+    let tx_cbor_binary = binary_or_hex_heuristic(body.as_ref());
 
-    let report = evaluate::evaluate_binary_tx(node, &binary_tx, None).await?;
-    let result = convert_eval_report(report);
+    let result = fallback_evaluator
+        .evaluate_binary_tx(node, tx_cbor_binary.as_slice(), None)
+        .await?;
 
     Ok(Json(result))
 }
diff --git a/src/api/utils/txs/evaluate/utxos.rs b/src/api/utils/txs/evaluate/utxos.rs
index 1fa272f5..5963e2ee 100644
--- a/src/api/utils/txs/evaluate/utxos.rs
+++ b/src/api/utils/txs/evaluate/utxos.rs
@@ -1,20 +1,26 @@
-use crate::{BlockfrostError, NodePool, cbor::evaluate, common::validate_content_type};
+use crate::{
+    BlockfrostError, NodePool, cbor::external::fallback_evaluator::FallbackEvaluator,
+    common::validate_content_type,
+};
 use axum::{Extension, Json, extract, response::IntoResponse};
 use hyper::HeaderMap;
 
-use super::model::{TxEvaluationRequest, convert_eval_report};
+use super::model::TxEvaluationRequest;
 
 pub async fn route(
     Extension(node): Extension<NodePool>,
+    Extension(fallback_evaluator): Extension<FallbackEvaluator>,
     headers: HeaderMap,
     extract::Json(tx_request): extract::Json<TxEvaluationRequest>,
 ) -> Result<impl IntoResponse, BlockfrostError> {
     // Allow only application/json content type
     validate_content_type(&headers, &["application/json"])?;
 
-    let pallas_report =
-        evaluate::evaluate_encoded_tx(node, &tx_request.cbor, tx_request.additional_utxo_set)
-            .await?;
+    let tx_cbor = hex::decode(tx_request.cbor).unwrap();
 
-    Ok(Json(convert_eval_report(pallas_report)))
+    let result = fallback_evaluator
+        .evaluate_binary_tx(node, tx_cbor.as_slice(), tx_request.additional_utxo_set)
+        .await?;
+
+    Ok(Json(result))
 }
diff --git a/src/cbor.rs b/src/cbor.rs
index 29e50230..ee106e25 100644
--- a/src/cbor.rs
+++ b/src/cbor.rs
@@ -1,6 +1,7 @@
 #[cfg(evaluate)]
 pub mod evaluate;
-pub mod fallback_decoder;
+
+pub mod external;
 #[cfg(test)]
 pub mod tests;
 pub(crate) mod validation;
diff --git a/src/cbor/evaluate.rs b/src/cbor/evaluate.rs
index 65b1b9b6..97744c83 100644
--- a/src/cbor/evaluate.rs
+++ b/src/cbor/evaluate.rs
@@ -6,10 +6,15 @@ use chrono::DateTime;
 use chrono::NaiveDate;
 use chrono::NaiveDateTime;
 use chrono::NaiveTime;
+use pallas_addresses::Address;
+use pallas_codec::utils::AnyUInt;
+use pallas_codec::utils::NonEmptyKeyValuePairs;
+use pallas_network::miniprotocols::localstate::queries_v16;
 use pallas_network::miniprotocols::localstate::queries_v16::CurrentProtocolParam;
 use pallas_network::miniprotocols::localstate::queries_v16::GenesisConfig;
 use pallas_network::miniprotocols::localstate::queries_v16::SystemStart;
 use pallas_primitives::AssetName;
+use pallas_primitives::Bytes;
 use pallas_primitives::ExUnitPrices;
 use pallas_primitives::ExUnits;
 use pallas_primitives::PolicyId;
@@ -37,6 +42,9 @@ use pallas_primitives::{
 use pallas_traverse::MultiEraInput;
 use pallas_validate::utils::EraCbor;
 
+//* This implementation uses pallas validate.
+//  Since pallas validate behaves differently from the ogmios validation (which uses ledger)
+//  this implementation is not used at the moment  */
 pub async fn evaluate_binary_tx(
     node_pool: NodePool,
     tx_cbor_binary: &[u8],
@@ -62,122 +70,13 @@ pub async fn evaluate_tx(
     slot_config: &SlotConfig,
     utxo_set: Option<AdditionalUtxoSet>,
 ) -> Result<EvalReport, BlockfrostError> {
-    let mut node: deadpool::managed::Object<crate::node::pool_manager::NodePoolManager> =
-        node_pool.get().await?;
+    let mut node = node_pool.get().await?;
 
     match node.genesis_config_and_pp().await {
         Ok((genesis_config, protocol_params)) => {
             let protocol_params: MultiEraProtocolParameters =
                 convert_protocol_param(protocol_params, genesis_config)?;
-            /*
-             * Prepare transaction
-             */
-            let minted_tx: conway::Tx =
-                pallas_codec::minicbor::decode::<conway::Tx>(tx_cbor_binary).unwrap();
-            let multi_era_tx: MultiEraTx = MultiEraTx::from_conway(&minted_tx);
-
-            /*
-             * make codec safe utxo for conway
-             * with inputs, script and datum option
-             */
-            let mut utxos: UtxoMap = UtxoMap::new();
-            for (tx_in, tx_out) in utxo_set.unwrap_or_default() {
-                let alonzo_tx_in: conway::TransactionInput = conway::TransactionInput {
-                    transaction_id: pallas_primitives::Hash::<32>::from_str(&tx_in.tx_id)
-                        .expect("Invalid tx_id in additional utxo set"),
-                    index: tx_in.index,
-                };
-
-                let multi_era_in: MultiEraInput =
-                    MultiEraInput::AlonzoCompatible(Box::new(Cow::Owned(alonzo_tx_in)));
-
-                /*
-                 * Prepare transaction output
-                 */
-                let address: pallas_codec::utils::Bytes = hex::decode(tx_out.address.clone())
-                    .expect("Invalid address in additional utxo output set")
-                    .into();
-
-                let value: pallas_primitives::conway::Value = match &tx_out.value {
-                    Value {
-                        coins,
-                        assets: None,
-                    } => pallas_primitives::conway::Value::Coin(*coins),
-                    Value {
-                        coins,
-                        assets: Some(assets_map),
-                    } => {
-                        let mut assets = BTreeMap::new();
-                        for (id_name, number) in assets_map {
-                            let mut asset_detail = BTreeMap::new();
-                            let coin: PositiveCoin = number.to_owned().try_into().expect(
-                                "Invalid number for PositiveCoin in additional utxo output set",
-                            );
-                            let (asset_id, asset_name) = parse_asset_string(id_name);
-
-                            asset_detail.insert(asset_name, coin);
-                            assets.insert(asset_id, asset_detail);
-                        }
-                        pallas_primitives::conway::Value::Multiasset(coins.to_owned(), assets)
-                    },
-                };
-
-                let datum_vec: Vec<u8>;
-
-                let datum_option = match &tx_out.datum {
-                    Some(d) => {
-                        let datum_bytes = hex::decode(d).unwrap();
-                        let datum_option = DatumOption::Data(CborWrap(
-                            pallas_codec::minicbor::decode(&datum_bytes).unwrap(),
-                        ));
-                        datum_vec = pallas_codec::minicbor::to_vec(datum_option).unwrap();
-
-                        let datum_option: KeepRaw<'_, DatumOption> =
-                            pallas_codec::minicbor::decode(&datum_vec).unwrap();
-
-                        Some(datum_option)
-                    },
-                    None => None,
-                };
-
-                let script_ref: Option<CborWrap<ScriptRef>> =
-                    tx_out.script.map(|script| CborWrap(script.into()));
-
-                let post_alonzo = pallas_primitives::conway::PostAlonzoTransactionOutput {
-                    address,
-                    value,
-                    datum_option,
-                    script_ref,
-                };
-
-                //let tx_out_cbor  = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
-                let tx_out_cbor = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
-                //tx_out_cbors.push(tx_out_cbor.clone());
-                let post_alonzo = pallas_codec::minicbor::decode::<
-                    pallas_codec::utils::KeepRaw<
-                        '_,
-                        pallas_primitives::conway::PostAlonzoTransactionOutput,
-                    >,
-                >(&tx_out_cbor)
-                .unwrap();
-                let tx_out =
-                    pallas_primitives::conway::TransactionOutput::<'_>::PostAlonzo(post_alonzo);
-                let multi_era_out = MultiEraOutput::<'_>::Conway(Box::new(Cow::Owned(tx_out)));
-
-                utxos.insert(TxoRef::from(&multi_era_in), EraCbor::from(multi_era_out));
-            }
-
-            match pallas_validate::phase2::evaluate_tx(
-                &multi_era_tx,
-                &protocol_params,
-                &utxos,
-                slot_config,
-            ) {
-                Ok(report) => Ok(report),
-                Err(e) => Err(BlockfrostError::custom_400(
-                    "Error evaluating transaction: ".to_string() + &e.to_string(),
-                )),
-            }
+            evaluate_tx_with_pp(tx_cbor_binary, slot_config, utxo_set, protocol_params)
         },
         Err(e) => Err(BlockfrostError::custom_400(
             "Error fetching protocol parameters: ".to_string() + &e.to_string(),
@@ -185,6 +84,190 @@ pub async fn evaluate_tx(
     }
 }
 
+pub fn evaluate_tx_with_pp(
+    tx_cbor_binary: &[u8],
+    slot_config: &SlotConfig,
+    utxo_set: Option<AdditionalUtxoSet>,
+    protocol_params: MultiEraProtocolParameters,
+) -> Result<EvalReport, BlockfrostError> {
+    /*
+     * Prepare transaction
+     */
+    let multi_era_tx = MultiEraTx::decode(tx_cbor_binary).unwrap();
+
+    //let multi_era_tx: MultiEraTx =  pallas_codec::minicbor::decode(tx_cbor_binary).unwrap();
+    /*
+     * make codec safe utxo for conway
+     * with inputs, script and datum option
+     */
+    let mut utxos: UtxoMap = UtxoMap::new();
+    for (tx_in, tx_out) in utxo_set.unwrap_or_default() {
+        let alonzo_tx_in: conway::TransactionInput = conway::TransactionInput {
+            transaction_id: pallas_primitives::Hash::<32>::from_str(&tx_in.tx_id)
+                .expect("Invalid tx_id in additional utxo set"),
+            index: tx_in.index,
+        };
+
+        let multi_era_in: MultiEraInput =
+            MultiEraInput::AlonzoCompatible(Box::new(Cow::Owned(alonzo_tx_in)));
+
+        /*
+         * Prepare transaction output
+         */
+
+        let address = create_address(&tx_out.address);
+
+        let value: pallas_primitives::conway::Value = convert_to_primitive_value(&tx_out.value);
+
+        let datum_vec = convert_to_datum_option(&tx_out.datum);
+        let datum_option = create_raw_datum_option(&datum_vec);
+
+        let script_ref: Option<CborWrap<ScriptRef>> =
+            tx_out.script.map(|script| CborWrap(script.into()));
+
+        let post_alonzo = pallas_primitives::conway::PostAlonzoTransactionOutput {
+            address,
+            value,
+            datum_option,
+            script_ref,
+        };
+
+        //let tx_out_cbor  = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
+        let tx_out_cbor = pallas_codec::minicbor::to_vec(post_alonzo).unwrap();
+        //tx_out_cbors.push(tx_out_cbor.clone());
+        let post_alonzo = pallas_codec::minicbor::decode::<
+            pallas_codec::utils::KeepRaw<
+                '_,
+                pallas_primitives::conway::PostAlonzoTransactionOutput,
+            >,
+        >(&tx_out_cbor)
+        .unwrap();
+        let tx_out = pallas_primitives::conway::TransactionOutput::<'_>::PostAlonzo(post_alonzo);
+        let multi_era_out = MultiEraOutput::<'_>::Conway(Box::new(Cow::Owned(tx_out)));
+
+        utxos.insert(TxoRef::from(&multi_era_in), EraCbor::from(multi_era_out));
+    }
+
+    match pallas_validate::phase2::evaluate_tx(&multi_era_tx, &protocol_params, &utxos, slot_config)
+    {
+        Ok(report) => Ok(report),
+        Err(e) => Err(BlockfrostError::custom_400(
+            "Error evaluating transaction: ".to_string() + &e.to_string(),
+        )),
+    }
+}
+
+pub fn create_address(addr: &str) -> Bytes {
+    Address::from_bech32(addr)
+        .unwrap_or_else(|_| Address::from_hex(addr).unwrap())
+        .to_vec()
+        .into()
+}
+
+pub fn convert_to_datum_option(datum: &Option<String>) -> Vec<u8> {
+    {
+        match datum {
+            Some(d) => {
+                println!("Datum: {}", d);
+                let datum_bytes = hex::decode(d).unwrap();
+                let datum_option = DatumOption::Data(CborWrap(
+                    pallas_codec::minicbor::decode(&datum_bytes).unwrap(),
+                ));
+                pallas_codec::minicbor::to_vec(datum_option).unwrap()
+            },
+            None => Vec::new(),
+        }
+    }
+}
+
+pub fn convert_to_datum_option_network(
+    datum: &Option<String>,
+) -> Option<pallas_network::miniprotocols::localstate::queries_v16::DatumOption> {
+    {
+        match datum {
+            Some(d) => {
+                println!("Datum: {}", d);
+                let datum_bytes = hex::decode(d).unwrap();
+                let datum_option =
+                    pallas_network::miniprotocols::localstate::queries_v16::DatumOption::Data(
+                        CborWrap(pallas_codec::minicbor::decode(&datum_bytes).unwrap()),
+                    );
+                Some(datum_option)
+            },
+            None => None,
+        }
+    }
+}
+
+pub fn create_raw_datum_option<'a>(datum_vec: &'a [u8]) -> Option<KeepRaw<'a, DatumOption<'a>>> {
+    if datum_vec.is_empty() {
+        None
+    } else {
+        let raw: KeepRaw<'a, DatumOption<'a>> = pallas_codec::minicbor::decode(datum_vec).unwrap();
+        Some(raw)
+    }
+}
+
+pub fn convert_to_primitive_value(value: &Value) -> pallas_primitives::conway::Value {
+    match &value {
+        Value {
+            coins,
+            assets: None,
+        } => pallas_primitives::conway::Value::Coin(*coins),
+        Value {
+            coins,
+            assets: Some(assets_map),
+        } => {
+            let mut assets = BTreeMap::new();
+            for (id_name, number) in assets_map {
+                let mut asset_detail = BTreeMap::new();
+                let coin: PositiveCoin = number
+                    .to_owned()
+                    .try_into()
+                    .expect("Invalid number for PositiveCoin in additional utxo output set");
+                let (asset_id, asset_name) = parse_asset_string(id_name);
+
+                asset_detail.insert(asset_name, coin);
+                assets.insert(asset_id, asset_detail);
+            }
+            pallas_primitives::conway::Value::Multiasset(coins.to_owned(), assets)
+        },
+    }
+}
+
+pub fn convert_to_network_value(value: &Value) -> queries_v16::Value {
+    match &value {
+        Value {
+            coins,
+            assets: None,
+        } => pallas_network::miniprotocols::localstate::queries_v16::Value::Coin(AnyUInt::U64(
+            *coins,
+        )),
+        Value {
+            coins,
+            assets: Some(assets_map),
+        } => {
+            let mut assets = vec![];
+            for (id_name, number) in assets_map {
+                let mut asset_detail = vec![];
+                let coin = AnyUInt::U64(*number);
+
+                let (asset_id, asset_name) = parse_asset_string(id_name);
+
+                asset_detail.push((asset_name, coin));
+                assets.push((
+                    asset_id,
+                    NonEmptyKeyValuePairs::from_vec(asset_detail).unwrap(),
+                ));
+            }
+            queries_v16::Value::Multiasset(
+                AnyUInt::U64(*coins),
+                NonEmptyKeyValuePairs::from_vec(assets).unwrap(),
+            )
+        },
+    }
+}
+
 fn parse_asset_string(str: &str) -> (PolicyId, AssetName) {
     let mut parts = str.split('.');
     let policy_id = parts.next().expect("Invalid asset string in utxo output");
diff --git a/src/cbor/external.rs b/src/cbor/external.rs
new file mode 100644
index 00000000..2c5db76f
--- /dev/null
+++ b/src/cbor/external.rs
@@ -0,0 +1,3 @@
+pub mod fallback_decoder;
+pub mod fallback_evaluator;
+pub mod testgen;
diff --git a/src/cbor/external/fallback_decoder.rs b/src/cbor/external/fallback_decoder.rs
new file mode 100644
index 00000000..b588b427
--- /dev/null
+++ b/src/cbor/external/fallback_decoder.rs
@@ -0,0 +1,102 @@
+use crate::AppError;
+use crate::cbor::external::testgen::{self, Testgen};
+
+#[derive(Clone)]
+pub struct FallbackDecoder {
+    testgen: Testgen,
+}
+impl FallbackDecoder {
+    pub fn spawn() -> Result<Self, AppError> {
+        let testgen = testgen::Testgen::spawn("deserialize-stream")
+            .map_err(|err| AppError::Server(format!("Failed to spawn FallbackDecoder: {err}")))?;
+
+        Ok(Self { testgen })
+    }
+
+    pub async fn decode(&self, input: &[u8]) -> Result<serde_json::Value, String> {
+        self.testgen.decode(input).await
+    }
+
+    /// 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.testgen.decode(&input).await;
+        let expected = serde_json::json!({
+          "contents": {
+            "contents": {
+              "contents": {
+                "era": "ShelleyBasedEraConway",
+                "error": [
+                  "ConwayCertsFailure (WithdrawalsNotInRewardsCERTS (fromList []))"
+                ],
+                "kind": "ShelleyTxValidationError"
+              },
+              "tag": "TxValidationErrorInCardanoMode"
+            },
+            "tag": "TxCmdTxSubmitValidationError"
+          },
+          "tag": "TxSubmitFail"
+        });
+
+        if result == Ok(expected) {
+            Ok(())
+        } else {
+            Err(format!(
+                "FallbackDecoder: startup_sanity_test failed: {result:?}"
+            ))
+        }
+    }
+
+    #[cfg(test)]
+    /// A single global [`FallbackDecoder`] that you can cheaply use in tests.
+    pub fn instance() -> Self {
+        GLOBAL_INSTANCE.clone()
+    }
+}
+
+#[cfg(test)]
+static GLOBAL_INSTANCE: std::sync::LazyLock<FallbackDecoder> =
+    std::sync::LazyLock::new(|| FallbackDecoder::spawn().expect("Failed to spawn FallbackDecoder"));
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(feature = "tarpaulin"))]
+    use super::*;
+    #[tokio::test]
+    //#[tracing_test::traced_test]
+    #[cfg(not(feature = "tarpaulin"))]
+    async fn test_fallback_decoder() {
+        let decoder = FallbackDecoder::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"
+                }
+            ))
+        );
+    }
+}
diff --git a/src/cbor/external/fallback_evaluator.rs b/src/cbor/external/fallback_evaluator.rs
new file mode 100644
index 00000000..18e43cc8
--- /dev/null
+++ b/src/cbor/external/fallback_evaluator.rs
@@ -0,0 +1,230 @@
+use std::str::FromStr;
+
+use pallas_codec::{
+    minicbor::to_vec,
+    utils::{AnyUInt, CborWrap},
+};
+
+use pallas_network::miniprotocols::{
+    localstate::queries_v16::{self, PostAlonsoTransactionOutput, TransactionOutput, TxIns, UTxO},
+    localtxsubmission::primitives::ScriptRef,
+};
+use pallas_primitives::{KeyValuePairs, TransactionInput, byron};
+use pallas_traverse::MultiEraTx;
+use serde::Serialize;
+
+use crate::{
+    AppError, BlockfrostError, NodePool,
+    api::utils::txs::evaluate::model::AdditionalUtxoSet,
+    cbor::{
+        evaluate::{convert_to_datum_option_network, convert_to_network_value, create_address},
+        external::testgen::{self, Testgen},
+    },
+    server::chain_config::{ChainConfigCache, SlotConfig},
+};
+
+#[derive(Clone)]
+pub struct FallbackEvaluator {
+    testgen: Testgen,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct InitPayload {
+    system_start: String,
+    protocol_params: String,
+    slot_config: SlotConfig,
+    era: u16,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct EvalPayload {
+    tx: String,
+    utxos: String,
+}
+
+/// Evaluates the given tx with utxos using the external testgen exe
+impl FallbackEvaluator {
+    /// Spawn testgen with specific command 'evaluate-stream'
+    pub async fn spawn(config: ChainConfigCache) -> Result<Self, AppError> {
+        let testgen = testgen::Testgen::spawn("evaluate-stream")
+            .map_err(|err| AppError::Server(format!("Failed to spawn FallbackEvaluator: {err}")))?;
+
+        let evaluator = Self { testgen };
+        evaluator.init(config).await?;
+
+        Ok(evaluator)
+    }
+
+    /// Sends repeatative data as the first communication so we don't need to send every time.
+    /// Also makes sure the child processes behaves as expected.
+    async fn init(&self, config: ChainConfigCache) -> Result<serde_json::Value, AppError> {
+        use pallas_codec::minicbor::to_vec;
+
+        println!("FallbackEvaluator preparing init payload");
+
+        let system_start = to_vec(config.genesis_config.system_start).map_err(|err| {
+            AppError::Server(format!(
+                "FallbackEvaluator: failed to serialize genesis config: {err}"
+            ))
+        })?;
+
+        let protocol_params = to_vec(config.protocol_params).map_err(|err| {
+            AppError::Server(format!(
+                "FallbackEvaluator: failed to serialize protocol params: {err}"
+            ))
+        })?;
+
+        let init_payload = InitPayload {
+            system_start: hex::encode(system_start),
+            protocol_params: hex::encode(protocol_params),
+            slot_config: config.slot_config,
+            era: config.era,
+        };
+
+        let payload = serde_json::to_string(&init_payload).map_err(|err| {
+            AppError::Server(format!(
+                "FallbackEvaluator: failed to serialize initial payload: {err}"
+            ))
+        })?;
+
+        let payload2 = serde_json::to_string(&init_payload).map_err(|err| {
+            AppError::Server(format!(
+                "FallbackEvaluator: failed to serialize initial payload: {err}"
+            ))
+        })?;
+
+        println!("FallbackEvaluator sending init payload: {}", payload2);
+
+        let result = (self.testgen.send(payload).await).map_err(|err| {
+            AppError::Server(format!("FallbackEvaluator: Failed to initialize: {err}"))
+        });
+
+        println!("FallbackEvaluator got init result: {:?}", result);
+
+        result
+    }
+
+    fn convert_alonzo_txin(txin: &TransactionInput) -> queries_v16::TransactionInput {
+        queries_v16::TransactionInput {
+            transaction_id: txin.transaction_id,
+            index: txin.index,
+        }
+    }
+
+    fn convert_byron_txin(txin: &byron::TxIn) -> queries_v16::TransactionInput {
+        match txin {
+            byron::TxIn::Variant0(CborWrap((tx, idx))) => queries_v16::TransactionInput {
+                transaction_id: *tx,
+                index: *idx as u64,
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    fn extract_inputs(tx: MultiEraTx) -> TxIns {
+        let txins = match tx {
+            MultiEraTx::AlonzoCompatible(x, _) => x
+                .transaction_body
+                .inputs
+                .iter()
+                .map(Self::convert_alonzo_txin)
+                .collect(),
+            MultiEraTx::Babbage(x) => x
+                .transaction_body
+                .inputs
+                .iter()
+                .map(Self::convert_alonzo_txin)
+                .collect(),
+            MultiEraTx::Byron(x) => x
+                .transaction
+                .inputs
+                .iter()
+                .map(Self::convert_byron_txin)
+                .collect(),
+            MultiEraTx::Conway(x) => x
+                .transaction_body
+                .inputs
+                .iter()
+                .map(Self::convert_alonzo_txin)
+                .collect(),
+            _ => unreachable!("unknown era transaction"),
+        };
+        txins
+    }
+
+    pub async fn evaluate_binary_tx(
+        &self,
+        node_pool: NodePool,
+        tx_cbor_binary: &[u8],
+        additional_utxos: Option<AdditionalUtxoSet>,
+    ) -> Result<serde_json::Value, BlockfrostError> {
+        let mut node = node_pool.get().await?;
+
+        /*
+         * Prepare txins
+         */
+        let multi_era_tx = MultiEraTx::decode(tx_cbor_binary).unwrap();
+        let txins = Self::extract_inputs(multi_era_tx);
+
+        let utxos_from_node = node.get_utxos_for_txins(txins).await?;
+
+        let incoming_user_utxos = additional_utxos.unwrap_or_default();
+
+        let user_utxos = incoming_user_utxos.iter().map(|(utxo, tout)| {
+            let inline_datum = convert_to_datum_option_network(&tout.datum);
+
+            let txin = UTxO {
+                transaction_id: pallas_crypto::hash::Hash::<32>::from_str(&utxo.tx_id).unwrap(),
+                index: AnyUInt::U64(utxo.index),
+            };
+
+            // A Cardano address (either legacy format or new format).
+            let address = create_address(&tout.address);
+
+            let script_ref: Option<CborWrap<ScriptRef>> = tout.script.as_ref().map(|script| {
+                let script_ref = ScriptRef::from(script.clone());
+                CborWrap(script_ref)
+            });
+
+            let value = convert_to_network_value(&tout.value);
+
+            let txout = TransactionOutput::Current(PostAlonsoTransactionOutput {
+                address,
+                script_ref,
+                amount: value,
+                inline_datum,
+            });
+
+            (txin, txout)
+        });
+
+        // Merge utxos from node and user
+        let utxos =
+            KeyValuePairs::from_iter(user_utxos.chain(utxos_from_node.to_vec().into_iter()));
+
+        let utxos_cbor = hex::encode(to_vec(&utxos).map_err(|err| {
+            BlockfrostError::internal_server_error(format!("Failed to serialize UTxOs: {err}"))
+        })?);
+
+        let payload = EvalPayload {
+            tx: hex::encode(tx_cbor_binary),
+            utxos: utxos_cbor,
+        };
+
+        let json = serde_json::to_string(&payload).map_err(|err| {
+            BlockfrostError::internal_server_error(format!("Failed to serialize payload: {err}"))
+        })?;
+
+        println!("FallbackEvaluator eval request: {:?}", json);
+
+        let response = self.testgen.send(json).await.map_err(|err| {
+            BlockfrostError::internal_server_error(format!("Failed to send payload: {err}"))
+        })?;
+
+        println!("FallbackEvaluator eval response: {}", response);
+
+        Ok(response)
+    }
+}
diff --git a/src/cbor/fallback_decoder.rs b/src/cbor/external/testgen.rs
similarity index 69%
rename from src/cbor/fallback_decoder.rs
rename to src/cbor/external/testgen.rs
index a9526127..39f53b29 100644
--- a/src/cbor/fallback_decoder.rs
+++ b/src/cbor/external/testgen.rs
@@ -11,19 +11,23 @@ use tokio::sync::{mpsc, oneshot};
 use tracing::{debug, error, info};
 
 #[derive(Clone)]
-pub struct FallbackDecoder {
-    sender: mpsc::Sender<FDRequest>,
-    current_child_pid: Arc<AtomicU32>,
+pub struct Testgen {
+    pub sender: mpsc::Sender<TestgenRequest>,
+    pub current_child_pid: Arc<AtomicU32>,
 }
 
-struct FDRequest {
-    cbor: Vec<u8>,
-    response_tx: oneshot::Sender<Result<serde_json::Value, String>>,
+pub struct TestgenRequest {
+    payload: String,
+    response: oneshot::Sender<Result<serde_json::Value, String>>,
+    // payload: HashMap<String, String>
 }
 
-impl FallbackDecoder {
+/// Testgen is an executable that we use to run some functionality that are readily/easily available
+/// in Haskell codebase like the ledger.
+/// The name is 'testgen' since it was initially implemented to generate test cases.
+impl Testgen {
     /// Starts a new child process.
-    pub fn spawn() -> Result<Self, AppError> {
+    pub fn spawn(variant: &str) -> Result<Self, AppError> {
         let testgen_hs_path = Self::find_testgen_hs().map_err(AppError::Server)?;
 
         info!(
@@ -33,14 +37,15 @@ impl FallbackDecoder {
 
         let current_child_pid = Arc::new(AtomicU32::new(u32::MAX));
         let current_child_pid_clone = current_child_pid.clone();
-        let (sender, mut receiver) = mpsc::channel::<FDRequest>(128);
+        let variant_clone = variant.to_string();
+        let (sender, mut receiver) = mpsc::channel::<TestgenRequest>(128);
 
         // Clone `testgen_hs_path` for the thread.
         let testgen_hs_path_for_thread = testgen_hs_path.clone();
 
         thread::spawn(move || {
             // For retries:
-            let mut last_unfulfilled_request: Option<FDRequest> = None;
+            let mut last_unfulfilled_request: Option<TestgenRequest> = None;
 
             loop {
                 let single_run = Self::spawn_child(
@@ -48,6 +53,7 @@ impl FallbackDecoder {
                     &mut receiver,
                     &mut last_unfulfilled_request,
                     &current_child_pid_clone,
+                    &variant_clone,
                 );
                 let restart_delay = std::time::Duration::from_secs(1);
                 error!(
@@ -64,14 +70,17 @@ impl FallbackDecoder {
         })
     }
 
-    /// Decodes a CBOR error using the child process.
+    /// Sends the payload to the child process.
     pub async fn decode(&self, cbor: &[u8]) -> Result<serde_json::Value, String> {
-        let (response_tx, response_rx) = oneshot::channel();
+        self.send(hex::encode(cbor)).await
+    }
+
+    /// Sends the payload to the child process.
+    pub async fn send(&self, payload: String) -> Result<serde_json::Value, String> {
+        let (response, response_rx) = oneshot::channel();
+
         self.sender
-            .send(FDRequest {
-                cbor: cbor.to_vec(),
-                response_tx,
-            })
+            .send(TestgenRequest { payload, response })
             .await
             .map_err(|err| format!("FallbackDecoder: failed to send request: {err:?}"))?;
 
@@ -143,36 +152,6 @@ impl FallbackDecoder {
         ))
     }
 
-    /// 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 (fromList []))"
-                ],
-                "kind": "ShelleyTxValidationError"
-              },
-              "tag": "TxValidationErrorInCardanoMode"
-            },
-            "tag": "TxCmdTxSubmitValidationError"
-          },
-          "tag": "TxSubmitFail"
-        });
-
-        if result == Ok(expected) {
-            Ok(())
-        } else {
-            Err(format!(
-                "FallbackDecoder: startup_sanity_test failed: {result:?}"
-            ))
-        }
-    }
-
     /// Returns the current child PID:
     pub fn child_pid(&self) -> Option<u32> {
         match self.current_child_pid.load(atomic::Ordering::Relaxed) {
@@ -181,20 +160,15 @@ impl FallbackDecoder {
         }
     }
 
-    #[cfg(test)]
-    /// A single global [`FallbackDecoder`] that you can cheaply use in tests.
-    pub fn instance() -> Self {
-        GLOBAL_INSTANCE.clone()
-    }
-
     fn spawn_child(
         testgen_hs_path: &str,
-        receiver: &mut mpsc::Receiver<FDRequest>,
-        last_unfulfilled_request: &mut Option<FDRequest>,
+        receiver: &mut mpsc::Receiver<TestgenRequest>,
+        last_unfulfilled_request: &mut Option<TestgenRequest>,
         current_child_pid: &Arc<AtomicU32>,
+        variant: &str,
     ) -> Result<(), String> {
         let mut child = proc::Command::new(testgen_hs_path)
-            .arg("deserialize-stream")
+            .arg(variant)
             .stdin(proc::Stdio::piped())
             .stdout(proc::Stdio::piped())
             .spawn()
@@ -218,8 +192,8 @@ impl FallbackDecoder {
 
     fn process_requests(
         child: &mut proc::Child,
-        receiver: &mut mpsc::Receiver<FDRequest>,
-        last_unfulfilled_request: &mut Option<FDRequest>,
+        receiver: &mut mpsc::Receiver<TestgenRequest>,
+        last_unfulfilled_request: &mut Option<TestgenRequest>,
     ) -> Result<(), String> {
         let stdin = child
             .stdin
@@ -237,11 +211,11 @@ impl FallbackDecoder {
             .map(|a| (a, true))
             .or_else(|| receiver.blocking_recv().map(|a| (a, false)))
         {
-            let cbor_hex = hex::encode(&request.cbor);
+            let payload = request.payload.clone();
             *last_unfulfilled_request = Some(request);
 
             let mut ask_and_receive = || -> Result<Result<serde_json::Value, String>, String> {
-                writeln!(stdin, "{cbor_hex}")
+                writeln!(stdin, "{payload}")
                     .map_err(|err| format!("couldn’t write to stdin: {err:?}"))?;
 
                 match stdout_lines.next() {
@@ -268,7 +242,7 @@ impl FallbackDecoder {
                 // unwrap is safe, the other side would have to drop for a
                 // panic – can’t happen, because we control it:
                 request
-                    .response_tx
+                    .response
                     .send(response)
                     .unwrap_or_else(|_| unreachable!());
             }
@@ -310,50 +284,3 @@ fn partition_result<A, E>(ae: Result<A, E>) -> (Result<A, ()>, Result<(), E>) {
         Ok(ok) => (Ok(ok), Ok(())),
     }
 }
-
-#[cfg(test)]
-static GLOBAL_INSTANCE: std::sync::LazyLock<FallbackDecoder> =
-    std::sync::LazyLock::new(|| FallbackDecoder::spawn().expect("Failed to spawn FallbackDecoder"));
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(feature = "tarpaulin"))]
-    use super::*;
-    #[tokio::test]
-    //#[tracing_test::traced_test]
-    #[cfg(not(feature = "tarpaulin"))]
-    async fn test_fallback_decoder() {
-        let decoder = FallbackDecoder::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.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"
-                }
-            ))
-        );
-    }
-}
diff --git a/src/cbor/tests.rs b/src/cbor/tests.rs
index 173b11d4..5dc9ee7b 100644
--- a/src/cbor/tests.rs
+++ b/src/cbor/tests.rs
@@ -1,5 +1,5 @@
 #[cfg(not(feature = "tarpaulin"))]
-use super::fallback_decoder::FallbackDecoder;
+use super::external::fallback_decoder::FallbackDecoder;
 #[cfg(not(feature = "tarpaulin"))]
 use num_cpus;
 
@@ -15,6 +15,9 @@ mod random_eval_tx;
 #[cfg(not(feature = "tarpaulin"))]
 mod specific;
 
+#[cfg(not(feature = "tarpaulin"))]
+mod test_data;
+
 #[derive(Deserialize, Debug)]
 #[serde(rename_all(deserialize = "camelCase"))]
 pub struct CborTestCase {
@@ -61,7 +64,7 @@ pub fn check_generated_cases<F>(
 {
     use std::io::{BufRead, BufReader};
 
-    let child_exe = super::fallback_decoder::FallbackDecoder::find_testgen_hs().unwrap();
+    let child_exe = super::external::testgen::Testgen::find_testgen_hs().unwrap();
 
     let mut child = Command::new(&child_exe)
         .arg("generate")
diff --git a/src/cbor/tests/random_eval_tx.rs b/src/cbor/tests/random_eval_tx.rs
index e87115c4..7d5c7911 100644
--- a/src/cbor/tests/random_eval_tx.rs
+++ b/src/cbor/tests/random_eval_tx.rs
@@ -1,8 +1,13 @@
+use crate::{
+    api::utils::txs::evaluate::model::TxEvalResultResponse, cbor::evaluate::evaluate_tx_with_pp,
+};
+
 use super::*;
 
 // -------------------------- random evaluation tests -------------------------- //
 
 #[test]
+#[ignore = "not implemented yet"]
 #[allow(non_snake_case)]
 fn proptest_eval_Tx_Conway_size_010() {
     proptest_with_params(CaseType::Tx_Conway, 100, 10, None)
@@ -11,6 +16,7 @@ fn proptest_eval_Tx_Conway_size_010() {
 // -------------------------- random UTxO decoder tests -------------------------- //
 
 #[test]
+#[ignore = "not implemented yet"]
 fn proptest_utxo_decoder() {
     check_generated_cases(CaseType::Tx_Conway, 500, 10, 5, None, |case| {
         let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
@@ -36,22 +42,43 @@ fn proptest_with_params(
     use crate::api::utils::txs::evaluate::model::AdditionalUtxoSet;
 
     check_generated_cases(case_type, num_cases, generator_size, 5, seed, |case| {
-        let tx_cbor = case.cbor.clone();
+        let tx_cbor_binary = hex::decode(case.cbor.clone()).unwrap();
         let json: TestCaseJson = serde_json::from_value(case.json).unwrap();
         let expected = json.execution_units;
         let utxo_cbor = json.utxo_set_cbor;
-        let utxo: AdditionalUtxoSet =
+        let utxo_set: AdditionalUtxoSet =
             utxo_decoder::decode_utxo(&hex::decode(&utxo_cbor).unwrap()).unwrap();
 
         // TODO: okay, so now we have `tx_cbor`, `AdditionalUtxoSet`, and the `expected` JSON.
         // TODO: it’s time to call `crate::cbor::evaluate_tx()`, but it needs a `cardano-node` 👀
+        let slot_config = pallas_validate::phase2::script_context::SlotConfig::default();
+        let protocol_params = test_data::get_preview_pp();
+
+        let pallas_report = evaluate_tx_with_pp(
+            &tx_cbor_binary,
+            &slot_config,
+            Some(utxo_set),
+            protocol_params,
+        );
+
+        let actual_str = match pallas_report {
+            Ok(result) => {
+                let wrapped_result: Vec<TxEvalResultResponse> =
+                    result.into_iter().map(|r| r.into()).collect::<Vec<_>>();
+
+                serde_json::to_string_pretty(&wrapped_result).unwrap()
+            },
+            Err(error) => serde_json::to_string_pretty(&error).unwrap(),
+        }
+        .replace("\n", "\n  ");
+
+        let expected_str = serde_json::to_string_pretty(&expected)
+            .unwrap()
+            .replace("\n", "\n  ");
 
-        Err(format!(
-            "Unimplemented:\n  Transaction: {tx_cbor}\n  Expected: {}\n  UTxO: {utxo:?}",
-            serde_json::to_string_pretty(&expected)
-                .unwrap()
-                .replace("\n", "\n  ")
-        ))
+        assert_eq!(actual_str, expected_str);
+
+        Ok(())
     })
 }
 
@@ -173,7 +200,7 @@ mod utxo_decoder {
         let addr_bytes = addr_bytes.ok_or_else(|| anyhow!("TxOut missing address"))?;
         let value = value.ok_or_else(|| anyhow!("TxOut missing value"))?;
 
-        let hrp = if addr_bytes.first().map_or(false, |b| b & 0b0001_0000 == 0) {
+        let hrp = if addr_bytes.first().is_some_and(|b| b & 0b0001_0000 == 0) {
             "addr"
         } else {
             "addr_test"
@@ -198,7 +225,7 @@ mod utxo_decoder {
         }
 
         let addr_bytes = d.bytes()?;
-        let hrp = if addr_bytes.first().map_or(false, |b| b & 0b0001_0000 == 0) {
+        let hrp = if addr_bytes.first().is_some_and(|b| b & 0b0001_0000 == 0) {
             "addr"
         } else {
             "addr_test"
@@ -389,7 +416,7 @@ mod utxo_decoder {
 
                 _ => {
                     let subs = gather_subscripts((len - 1) as usize, &mut d, bytes)?;
-                    return Ok(ScriptNative::Any(subs));
+                    Ok(ScriptNative::Any(subs))
                 },
             },
 
@@ -445,7 +472,7 @@ mod utxo_decoder {
                 }
 
                 let n = last_int.ok_or_else(|| anyhow!("N-of payload missing threshold"))? as u32;
-                return Ok(ScriptNative::NOf(n, subs));
+                Ok(ScriptNative::NOf(n, subs))
             },
 
             4 | 5 => {
@@ -461,11 +488,11 @@ mod utxo_decoder {
                     },
                     other => bail!("slot must be integer or single-item array, got {:?}", other),
                 };
-                return Ok(if tag == 4 {
+                Ok(if tag == 4 {
                     ScriptNative::StartsAt(slot)
                 } else {
                     ScriptNative::ExpiresAt(slot)
-                });
+                })
             },
 
             _ => bail!("unknown or malformed native script tag {tag}"),
diff --git a/src/cbor/tests/test_data.rs b/src/cbor/tests/test_data.rs
new file mode 100644
index 00000000..b51d3b0b
--- /dev/null
+++ b/src/cbor/tests/test_data.rs
@@ -0,0 +1,185 @@
+use pallas_primitives::{
+    ExUnitPrices, ExUnits, RationalNumber,
+    conway::{DRepVotingThresholds, PoolVotingThresholds},
+};
+use pallas_traverse::update::ConwayCostModels;
+use pallas_validate::utils::{ConwayProtParams, MultiEraProtocolParameters};
+
+pub fn get_preview_pp() -> MultiEraProtocolParameters {
+    MultiEraProtocolParameters::Conway(ConwayProtParams {
+        system_start: "2022-10-25T00:00:00+00:00".parse().unwrap(),
+        epoch_length: 86400,
+        slot_length: 1_000_000,
+        minfee_a: 44,
+        minfee_b: 155_381,
+        max_block_body_size: 90_112,
+        max_transaction_size: 16_384,
+        max_block_header_size: 1_100,
+        key_deposit: 2_000_000,
+        pool_deposit: 500_000_000,
+        desired_number_of_stake_pools: 500,
+        protocol_version: (7, 0),
+        min_pool_cost: 170_000_000,
+        ada_per_utxo_byte: 4_310,
+        cost_models_for_script_languages: ConwayCostModels {
+            plutus_v1: Some(vec![
+                100788, 420, 1, 1, 1000, 173, 0, 1, 1000, 59957, 4, 1, 11183, 32, 201305, 8356, 4,
+                16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 100, 100,
+                16000, 100, 94375, 32, 132994, 32, 61462, 4, 72010, 178, 0, 1, 22151, 32, 91189,
+                769, 4, 2, 85848, 228465, 122, 0, 1, 1, 1000, 42921, 4, 2, 24548, 29498, 38, 1,
+                898148, 27279, 1, 51775, 558, 1, 39184, 1000, 60594, 1, 141895, 32, 83150, 32,
+                15299, 32, 76049, 1, 13169, 4, 22100, 10, 28999, 74, 1, 28999, 74, 1, 43285, 552,
+                1, 44749, 541, 1, 33852, 32, 68246, 32, 72362, 32, 7243, 32, 7391, 32, 11546, 32,
+                85848, 228465, 122, 0, 1, 1, 90434, 519, 0, 1, 74433, 32, 85848, 228465, 122, 0, 1,
+                1, 85848, 228465, 122, 0, 1, 1, 270652, 22588, 4, 1457325, 64566, 4, 20467, 1, 4,
+                0, 141992, 32, 100788, 420, 1, 1, 81663, 32, 59498, 32, 20142, 32, 24588, 32,
+                20744, 32, 25933, 32, 24623, 32, 53384111, 14333, 10,
+            ]),
+            plutus_v2: Some(vec![
+                100788, 420, 1, 1, 1000, 173, 0, 1, 1000, 59957, 4, 1, 11183, 32, 201305, 8356, 4,
+                16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 100, 100,
+                16000, 100, 94375, 32, 132994, 32, 61462, 4, 72010, 178, 0, 1, 22151, 32, 91189,
+                769, 4, 2, 85848, 228465, 122, 0, 1, 1, 1000, 42921, 4, 2, 24548, 29498, 38, 1,
+                898148, 27279, 1, 51775, 558, 1, 39184, 1000, 60594, 1, 141895, 32, 83150, 32,
+                15299, 32, 76049, 1, 13169, 4, 22100, 10, 28999, 74, 1, 28999, 74, 1, 43285, 552,
+                1, 44749, 541, 1, 33852, 32, 68246, 32, 72362, 32, 7243, 32, 7391, 32, 11546, 32,
+                85848, 228465, 122, 0, 1, 1, 90434, 519, 0, 1, 74433, 32, 85848, 228465, 122, 0, 1,
+                1, 85848, 228465, 122, 0, 1, 1, 955506, 213312, 0, 2, 270652, 22588, 4, 1457325,
+                64566, 4, 20467, 1, 4, 0, 141992, 32, 100788, 420, 1, 1, 81663, 32, 59498, 32,
+                20142, 32, 24588, 32, 20744, 32, 25933, 32, 24623, 32, 43053543, 10, 53384111,
+                14333, 10, 43574283, 26308, 10,
+            ]),
+            plutus_v3: Some(vec![
+                100788, 420, 1, 1, 1000, 173, 0, 1, 1000, 59957, 4, 1, 11183, 32, 201305, 8356, 4,
+                16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 16000, 100, 100, 100,
+                16000, 100, 94375, 32, 132994, 32, 61462, 4, 72010, 178, 0, 1, 22151, 32, 91189,
+                769, 4, 2, 85848, 123203, 7305, -900, 1716, 549, 57, 85848, 0, 1, 1, 1000, 42921,
+                4, 2, 24548, 29498, 38, 1, 898148, 27279, 1, 51775, 558, 1, 39184, 1000, 60594, 1,
+                141895, 32, 83150, 32, 15299, 32, 76049, 1, 13169, 4, 22100, 10, 28999, 74, 1,
+                28999, 74, 1, 43285, 552, 1, 44749, 541, 1, 33852, 32, 68246, 32, 72362, 32, 7243,
+                32, 7391, 32, 11546, 32, 85848, 123203, 7305, -900, 1716, 549, 57, 85848, 0, 1,
+                90434, 519, 0, 1, 74433, 32, 85848, 123203, 7305, -900, 1716, 549, 57, 85848, 0, 1,
+                1, 85848, 123203, 7305, -900, 1716, 549, 57, 85848, 0, 1, 955506, 213312, 0, 2,
+                270652, 22588, 4, 1457325, 64566, 4, 20467, 1, 4, 0, 141992, 32, 100788, 420, 1, 1,
+                81663, 32, 59498, 32, 20142, 32, 24588, 32, 20744, 32, 25933, 32, 24623, 32,
+                43053543, 10, 53384111, 14333, 10, 43574283, 26308, 10, 16000, 100, 16000, 100,
+                962335, 18, 2780678, 6, 442008, 1, 52538055, 3756, 18, 267929, 18, 76433006, 8868,
+                18, 52948122, 18, 1995836, 36, 3227919, 12, 901022, 1, 166917843, 4307, 36, 284546,
+                36, 158221314, 26549, 36, 74698472, 36, 333849714, 1, 254006273, 72, 2174038, 72,
+                2261318, 64571, 4, 207616, 8310, 4, 1293828, 28716, 63, 0, 1, 1006041, 43623, 251,
+                0, 1, 100181, 726, 719, 0, 1, 100181, 726, 719, 0, 1, 100181, 726, 719, 0, 1,
+                107878, 680, 0, 1, 95336, 1, 281145, 18848, 0, 1, 180194, 159, 1, 1, 158519, 8942,
+                0, 1, 159378, 8813, 0, 1, 107490, 3298, 1, 106057, 655, 1, 1964219, 24520, 3,
+            ]),
+            unknown: Default::default(),
+        },
+        execution_costs: ExUnitPrices {
+            mem_price: RationalNumber {
+                numerator: 577,
+                denominator: 10_000,
+            },
+            step_price: RationalNumber {
+                numerator: 721,
+                denominator: 10_000_000,
+            },
+        },
+        max_tx_ex_units: ExUnits {
+            mem: 14_000_000,
+            steps: 10_000_000_000,
+        },
+        max_block_ex_units: ExUnits {
+            mem: 62_000_000,
+            steps: 20_000_000_000,
+        },
+        max_value_size: 5_000,
+        collateral_percentage: 150,
+        max_collateral_inputs: 3,
+        expansion_rate: RationalNumber {
+            numerator: 3,
+            denominator: 1_000,
+        },
+        treasury_growth_rate: RationalNumber {
+            numerator: 1,
+            denominator: 5,
+        },
+        maximum_epoch: 18,
+        pool_pledge_influence: RationalNumber {
+            numerator: 3,
+            denominator: 10,
+        },
+        pool_voting_thresholds: PoolVotingThresholds {
+            motion_no_confidence: RationalNumber {
+                numerator: 51,
+                denominator: 100,
+            },
+            committee_normal: RationalNumber {
+                numerator: 51,
+                denominator: 100,
+            },
+            committee_no_confidence: RationalNumber {
+                numerator: 51,
+                denominator: 100,
+            },
+            hard_fork_initiation: RationalNumber {
+                numerator: 51,
+                denominator: 100,
+            },
+            security_voting_threshold: RationalNumber {
+                numerator: 51,
+                denominator: 100,
+            },
+        },
+        drep_voting_thresholds: DRepVotingThresholds {
+            motion_no_confidence: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+            committee_normal: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+            committee_no_confidence: RationalNumber {
+                numerator: 3,
+                denominator: 5,
+            },
+            update_constitution: RationalNumber {
+                numerator: 3,
+                denominator: 4,
+            },
+            hard_fork_initiation: RationalNumber {
+                numerator: 3,
+                denominator: 5,
+            },
+            pp_network_group: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+            pp_economic_group: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+            pp_technical_group: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+            pp_governance_group: RationalNumber {
+                numerator: 3,
+                denominator: 4,
+            },
+            treasury_withdrawal: RationalNumber {
+                numerator: 67,
+                denominator: 100,
+            },
+        },
+        min_committee_size: 0,
+        committee_term_limit: 365,
+        governance_action_validity_period: 30,
+        governance_action_deposit: 100_000_000_000,
+        drep_deposit: 500_000_000,
+        drep_inactivity_period: 31,
+        minfee_refscript_cost_per_byte: RationalNumber {
+            numerator: 15,
+            denominator: 1,
+        },
+    })
+}
diff --git a/src/node.rs b/src/node.rs
index 50fe4ed3..973848c0 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -4,3 +4,4 @@ pub mod pool;
 pub mod pool_manager;
 pub mod sync_progress;
 pub mod transactions;
+pub mod utxo;
diff --git a/src/node/utxo.rs b/src/node/utxo.rs
new file mode 100644
index 00000000..573e1335
--- /dev/null
+++ b/src/node/utxo.rs
@@ -0,0 +1,23 @@
+use pallas_network::miniprotocols::localstate::{
+    self,
+    queries_v16::{TxIns, UTxOByTxin},
+};
+
+use super::connection::NodeClient;
+
+use crate::BlockfrostError;
+
+impl NodeClient {
+    pub async fn get_utxos_for_txins(&mut self, ins: TxIns) -> Result<UTxOByTxin, BlockfrostError> {
+        self.with_statequery(|generic_client: &mut localstate::GenericClient| {
+            Box::pin(async {
+                let era = localstate::queries_v16::get_current_era(generic_client).await?;
+
+                let utxos: UTxOByTxin =
+                    localstate::queries_v16::get_utxo_by_txin(generic_client, era, ins).await?;
+                Ok(utxos)
+            })
+        })
+        .await
+    }
+}
diff --git a/src/server.rs b/src/server.rs
index 93a96756..97e28c18 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,9 +1,11 @@
+pub mod chain_config;
 pub mod logging;
 pub mod metrics;
 pub mod routes;
 pub mod state;
 
 use crate::{
+    cbor::external::fallback_evaluator,
     config::Config,
     errors::{AppError, BlockfrostError},
     health_monitor,
@@ -57,6 +59,14 @@ pub async fn build(
     // Set up optional Icebreakers API (solitary option in CLI)
     let icebreakers_api = IcebreakersAPI::new(&config, api_prefix.clone()).await?;
 
+    // Initialize chain configurations
+    let chain_config_cache: chain_config::ChainConfigCache =
+        chain_config::ChainConfigCache::init_caches(node_conn_pool.clone()).await?;
+
+    // Initialize the Haskell-based tx evaluator
+    let fallback_evaluator =
+        fallback_evaluator::FallbackEvaluator::spawn(chain_config_cache).await?;
+
     // API routes that are always under / (and also under the UUID prefix, if we use it)
     let regular_api_routes = get_regular_api_routes(!config.no_metrics);
     let hidden_api_routes = get_hidden_api_routes(!config.no_metrics);
@@ -68,6 +78,7 @@ pub async fn build(
     let app_state = AppState {
         config: config.clone(),
         genesis,
+        //    chain_config: Arc::new(chain_config_cache)
     };
 
     // Add layers
@@ -76,6 +87,7 @@ pub async fn build(
             .with_state(app_state.clone())
             .layer(Extension(health_monitor.clone()))
             .layer(Extension(node_conn_pool.clone()))
+            .layer(Extension(fallback_evaluator))
             .layer(from_fn(error_middleware))
             .fallback(BlockfrostError::not_found_with_uri);
 
diff --git a/src/server/chain_config.rs b/src/server/chain_config.rs
new file mode 100644
index 00000000..b6cf8e4b
--- /dev/null
+++ b/src/server/chain_config.rs
@@ -0,0 +1,59 @@
+use pallas_network::miniprotocols::localstate::queries_v16::{CurrentProtocolParam, GenesisConfig};
+use serde::Serialize;
+
+use crate::{AppError, NodePool};
+
+/// This structure is used to share server-wide cachables
+pub struct ChainConfigCache {
+    pub genesis_config: GenesisConfig,
+    pub protocol_params: CurrentProtocolParam,
+    pub slot_config: SlotConfig,
+    pub era: u16,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SlotConfig {
+    pub slot_length: u64,
+    pub zero_slot: u64,
+    pub zero_time: u64,
+    pub epoch_length: u64,
+}
+
+impl Default for SlotConfig {
+    fn default() -> Self {
+        Self {
+            slot_length: 1000,
+            zero_slot: 4492800,
+            zero_time: 1596059091000,
+            epoch_length: 432000,
+        }
+    }
+}
+
+impl ChainConfigCache {
+    /// init various caches
+    pub async fn init_caches(node_pool: NodePool) -> Result<Self, AppError> {
+        let (genesis_config, protocol_params) = Self::init_genesis_config(node_pool).await?;
+
+        Ok(Self {
+            genesis_config,
+            protocol_params,
+            slot_config: SlotConfig::default(),
+            era: 6, //conway
+        })
+    }
+
+    async fn init_genesis_config(
+        node_pool: NodePool,
+    ) -> Result<(GenesisConfig, CurrentProtocolParam), AppError> {
+        let mut node: deadpool::managed::Object<crate::node::pool_manager::NodePoolManager> =
+            node_pool.get().await?;
+        match node.genesis_config_and_pp().await {
+            Ok((genesis_config, protocol_params)) => Ok((genesis_config, protocol_params)),
+            Err(e) => Err(AppError::Server(format!(
+                "Could not fetching genesis and protocol parameters. Is the Cardano node running? {e}"
+            ))),
+        }
+    }
+}
diff --git a/src/server/state.rs b/src/server/state.rs
index be3942b1..544aafa6 100644
--- a/src/server/state.rs
+++ b/src/server/state.rs
@@ -8,6 +8,7 @@ use std::sync::Arc;
 pub struct AppState {
     pub config: Arc<Config>,
     pub genesis: Arc<Vec<(Network, GenesisContent)>>,
+    //   pub chain_config: Arc<ChainConfigCache>,
 }
 
 pub type AppStateExt = State<AppState>;
diff --git a/tests/api/utils/txs/evaluate/root.rs b/tests/api/utils/txs/evaluate/root.rs
index 0b4828e1..e38f00ef 100644
--- a/tests/api/utils/txs/evaluate/root.rs
+++ b/tests/api/utils/txs/evaluate/root.rs
@@ -1,18 +1,100 @@
 mod tests {
+    use axum::body::to_bytes;
     use tower::ServiceExt;
 
-    use crate::common::{get_blockfrost_client, initialize_app};
-    use crate::tx_builder::build_tx;
+    use crate::common::initialize_app;
 
     use axum::{body::Body, http::Request};
     use reqwest::Method;
 
+    ///
+    /// Currently not working since we are not handling desirializing the tx for old eras on Haskell side.
+    /// This test is identical to the Blockfrost test:
+    /// https://github.com/blockfrost/blockfrost-tests/blob/7a847bc41b8153844a2643d817559367cc4ffd4d/src/fixtures/preview/utils/txs-evaluate.ts#L5
+    ///
     #[tokio::test]
-    async fn success() {
-        // prepare the transaction
-        let blockfrost_client = get_blockfrost_client();
-        let tx = build_tx(&blockfrost_client).await.unwrap();
+    #[ignore = "not implemented yet"]
+    async fn test_fail_incompatible_era() {
+        let tx_hex = "83a300818258200ac82ea5bc0967a17d4a60e2474b01df72440673429ff89b2802d3bd2a38ec3e01018282583900e2fbc47df26fcd065c074c451e792599ea8fc159f76163ca4c2b520b58adbef896164ee7456ccb4eaa965a87a602b0e3b2825d7b4ee789b01a000f4240825839003c77cd7f3c07b3b0ba72044848592d2e5687569ad25b93a926392f5e83892080b40900e146e1c68f12ef6811773bd8740196cd211f3211de1af9b0595d021a0002c5bda10081825820da818bbf3a082945884681d062147ca7dc3111d87fab415268749124a3ed1d31584059ca300a7d38abf454482a57281acdbbaab740b868978131f36117a224e6ba2be5248da0205296d7a8211506d6430a2873c201831e326e5db68ac9e1403e520ef6";
+        // init our app
+        let app = initialize_app().await;
+
+        // prepare the request
+        let request = Request::builder()
+            .method(Method::POST)
+            .uri("/utils/tx/evaluate")
+            .header("Content-Type", "application/cbor")
+            .body(Body::from(tx_hex))
+            .unwrap();
+
+        // send the request and get the response
+        let response = app
+            .oneshot(request)
+            .await
+            .expect("Request to /utils/tx/evaluate failed");
+        assert!(
+            response.status().is_success(),
+            "Response was not successful"
+        );
+
+        // Convert the response body to bytes
+        let body_bytes = to_bytes(response.into_body(), usize::MAX)
+            .await
+            .expect("Failed to read response body");
+
+        let body_str = String::from_utf8_lossy(&body_bytes);
+
+        assert_eq!(
+            body_str,
+            "[{\"EvaluationFailure\":{\"IncompatibleEra\":\"Mary\"}}]"
+        );
+    }
+
+    /// Currently not working, we need to mimic Haskell error on the Rust part.
+    /// This test is identical to the Blockfrost test:
+    /// https://github.com/blockfrost/blockfrost-tests/blob/7a847bc41b8153844a2643d817559367cc4ffd4d/src/fixtures/preview/utils/txs-evaluate.ts#L20
+    ///
+    #[tokio::test]
+    #[ignore = "not implemented yet"]
+    async fn test_fail_ill_formed_tx() {
+        let tx_hex = "83a300818258200ac82ea5bc0967a17d4a60e2474b01df72440673429ff89b2802d3bd2a38ec3e01018282583900e2fbc47df26fcd065c074c451e792599ea8fc159f76163ca4c2b520b58adbef896164ee7456ccb4eaa965a87a602b0e3b2825d7b4ee789b01a000f4240825839003c77cd7f3c07b3b0ba72044848592d2e5687569ad25b93a926392f5e83892080b40900e146e1c68f12ef6811773bd8740196cd211f3211de1af9b0595d021a0002c5bda10081825820da818bbf3a082945884681d062147ca7dc3111d87fab415268749124a3ed1d31584059ca300a7d38abf454482a57281acdbbaab740b868978131f36117a224e6ba2be5248da0205296d7a8211506d6430a2873c201831e326e5db68ac9e1403e520ef6";
+        // init our app
+        let app = initialize_app().await;
+
+        // prepare the request
+        let request = Request::builder()
+            .method(Method::POST)
+            .uri("/utils/tx/evaluate")
+            .header("Content-Type", "application/cbor")
+            .body(Body::from(tx_hex))
+            .unwrap();
 
+        // send the request and get the response
+        let response = app
+            .oneshot(request)
+            .await
+            .expect("Request to /utils/tx/evaluate failed");
+        assert!(
+            response.status().is_success(),
+            "Response was not successful"
+        );
+
+        // Convert the response body to bytes
+        let body_bytes = to_bytes(response.into_body(), usize::MAX)
+            .await
+            .expect("Failed to read response body");
+
+        let body_str = String::from_utf8_lossy(&body_bytes);
+
+        assert_eq!(
+            body_str,
+            "[Invalid request: Deserialisation failure while decoding serialised transaction. CBOR failed with error: DeserialiseFailure 0 \"expected tag\"."
+        );
+    }
+
+    #[tokio::test]
+    async fn test_success() {
+        let tx_hex = "84A300818258204E9A66B7E310F004893EEF615E11F8AE6C3328CF2BFDB32F6E40063636D42D7C00018182581D70C40F9129C2684046EB02325B96CA2899A6FA6478C1DDE9B5C53206A51A00D59F800200A10581840000D8799F4D48656C6C6F2C20576F726C6421FF820000F5F6";
         // init our app
         let app = initialize_app().await;
 
@@ -21,7 +103,7 @@ mod tests {
             .method(Method::POST)
             .uri("/utils/tx/evaluate")
             .header("Content-Type", "application/cbor")
-            .body(Body::from(tx.to_hex()))
+            .body(Body::from(tx_hex))
             .unwrap();
 
         // send the request and get the response
@@ -29,7 +111,22 @@ mod tests {
             .oneshot(request)
             .await
             .expect("Request to /utils/tx/evaluate failed");
+        assert!(
+            response.status().is_success(),
+            "Response was not successful"
+        );
+
+        // Convert the response body to bytes
+        let body_bytes = to_bytes(response.into_body(), usize::MAX)
+            .await
+            .expect("Failed to read response body");
+
+        // Convert the bytes to a string and print
+        let body_str = String::from_utf8_lossy(&body_bytes);
 
-        assert_eq!(200, response.status());
+        assert_eq!(
+            body_str,
+            "[{\"budget\":{\"cpu\":3776833,\"memory\":15694},\"validator\":\"spend:0\"}]"
+        );
     }
 }
diff --git a/tests/api/utils/txs/evaluate/utxos.rs b/tests/api/utils/txs/evaluate/utxos.rs
index 54703c54..6dd48bee 100644
--- a/tests/api/utils/txs/evaluate/utxos.rs
+++ b/tests/api/utils/txs/evaluate/utxos.rs
@@ -10,27 +10,75 @@ mod tests {
     };
     use reqwest::Method;
 
+    ///
+    /// This test is identical to the Blockfrost test:
+    /// https://github.com/blockfrost/blockfrost-tests/blob/dc33312126e9d7c49836d7605ab72224a337bc91/src/fixtures/preview/utils/txs-evaluate-utxos.ts#L5
+    /// https://github.com/blockfrost/blockfrost-tests/blob/dc33312126e9d7c49836d7605ab72224a337bc91/src/fixtures/preview/utils/txs-evaluate-utxos.ts#L22
+    ///
     #[tokio::test]
-    async fn success() {
+    async fn success_cbor_only() {
         // init our app
         let app = initialize_app().await;
 
         let input = json!({
-            "cbor": "84a800d9010282825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab01825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab000181825839005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba1a9e38e8b8021a0002c0b30b58201124502b69ef6917c02db98f8026871e95a70fcc864eb8146bfd44237612b4670dd9010281825820b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab0110825839005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba1a9841a75e111a0004210d12d90102818258205a3b16ae983c3623b6f516a1a1bcafc124ddd7bebf8406f541c27f24a97d8d8c00a200d90102818258202a60dcffe8ba15307556dbf8d7df142cb9eb15d601251d400d523689d575b8385840843e477f1885303639acf78b1faf47e2c6c81930ef7570c5e843a038ec8042cd3784d89ababc1d803ecd25972ebd3a50da71dd90a9182dbfdbfd8b94a002560305a182000082d8799f4568656c6c6fff82194d101a005ee1c6f5f6",
-            "additionalUtxoSet": [
-                  [
-                    {"index":0,"txId":"b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab"},
-                    {"address":"70faae60072c45d121b6e58ae35c624693ee3dad9ea8ed765eb6f76f9f","value":{"coins":100270605}}
-                  ],
+            "cbor": "84A300818258204E9A66B7E310F004893EEF615E11F8AE6C3328CF2BFDB32F6E40063636D42D7C00018182581D70C40F9129C2684046EB02325B96CA2899A6FA6478C1DDE9B5C53206A51A00D59F800200A10581840000D8799F4D48656C6C6F2C20576F726C6421FF820000F5F6",
+        });
+
+        // prepare the request
+        let request = Request::builder()
+            .method(Method::POST)
+            .uri("/utils/tx/evaluate/utxos")
+            .header("Content-Type", "application/json")
+            .body(Body::from(input.to_string()))
+            .unwrap();
+
+        // send the request and get the response
+        let response = app
+            .oneshot(request)
+            .await
+            .expect("Request to /utils/tx/evaluate failed");
+
+        assert!(response.status().is_success(), "Response should success");
+
+        // Convert the response body to bytes
+        let body_bytes = to_bytes(response.into_body(), usize::MAX)
+            .await
+            .expect("Failed to read response body");
+
+        // Convert the bytes to a string and print
+        let body_str = String::from_utf8_lossy(&body_bytes);
+
+        assert_eq!(
+            body_str,
+            r#"[{"budget":{"cpu":3776833,"memory":15694},"validator":"spend:0"}]"#
+        );
+    }
+
+    /// This test is identical to the Blockfrost test:
+    /// https://github.com/blockfrost/blockfrost-tests/blob/7a847bc41b8153844a2643d817559367cc4ffd4d/src/fixtures/preview/utils/txs-evaluate.ts#L5
+    ///
+    #[tokio::test]
+    #[ignore = "not implemented yet"]
+    async fn fail_missing_input() {
+        // init our app
+        let app = initialize_app().await;
+
+        let input = json!({
+            "cbor": "".to_string() +
+            "84A60082825820000000000000000000000000000000000000000000000000" +
+        "0000000000000000182A8258207D67D80BC5B3BADCAF02375E428A39AEA398" +
+        "DD0438F26899A1B265C6AC87EB6B000D81825820DB7DBF9EAA6094982ED4B9" +
+        "B735CE275345F348194A7E8E9200FEC7D1CAD008EB010181825839004A294F" +
+        "1EF53B30CDBF7CAF17798422A90227224F9FBF037FCF6C47A5BC2EC1952D11" +
+        "89886FE018214EED45F83AB04171C41F373D530CA7A61A3BB94E8002000E80" +
+        "0B58206DF8859EC92C3FF6BC0E2964793789E44E4C5ABBCC9FF6F2387B94F4" +
+        "C2020E6EA303814E4D01000033222220051200120011048180058184000018" +
+        "2A820000F5F6",
+        "additionalUtxoSet": [
                   [
-                    {"index":0,"txId":"5a3b16ae983c3623b6f516a1a1bcafc124ddd7bebf8406f541c27f24a97d8d8c"},
-                    {"address":"70faae60072c45d121b6e58ae35c624693ee3dad9ea8ed765eb6f76f9f","script":{"plutus:v3":"58a701010032323232323225333002323232323253330073370e900118041baa0011323322533300a3370e900018059baa00513232533300f30110021533300c3370e900018069baa00313371e6eb8c040c038dd50039bae3010300e37546020601c6ea800c5858dd7180780098061baa00516300c001300c300d001300937540022c6014601600660120046010004601000260086ea8004526136565734aae7555cf2ab9f5742ae89"},"value":{"coins":1624870}}
+                    {"index":42,"txId":"0000000000000000000000000000000000000000000000000000000000000000"},
+                    {"address":"addr_test1wpnlxv2xv9a9ucvnvzqakwepzl9ltx7jzgm53av2e9ncv4sysemm8","value":{"coins":200000}, "datumHash": "45b0cfc220ceec5b7c1c62c4d4193d38e4eba48e8815729ce75f9c0ab0e4c1c0"}
                   ],
-                  [
-                    {"index":1,"txId":"b0a649f2b1fa7d0553d7eb3815fe1d36e893f7a18322be661991be7777f104ab"},
-                    {"address":"005c5c318d01f729e205c95eb1b02d623dd10e78ea58f72d0c13f892b2e8904edc699e2f0ce7b72be7cec991df651a222e2ae9244eb5975cba","value":{"coins":2554439518u64}}
-                    ]
-
             ]
         });
 
@@ -48,10 +96,7 @@ mod tests {
             .await
             .expect("Request to /utils/tx/evaluate failed");
 
-        assert!(
-            response.status().is_success(),
-            "Response was not successful"
-        );
+        assert!(!response.status().is_success(), "Response should fail");
 
         // Convert the response body to bytes
         let body_bytes = to_bytes(response.into_body(), usize::MAX)
@@ -61,6 +106,9 @@ mod tests {
         // Convert the bytes to a string and print
         let body_str = String::from_utf8_lossy(&body_bytes);
 
-        assert_eq!(body_str, "[{\"spend:0\":{\"memory\":958,\"cpu\":2348473}}]");
+        assert_eq!(
+            body_str,
+            "{\"error\":\"Bad Request\",\"message\":\"Error evaluating transaction: resolved Input not found\",\"status_code\":400}"
+        );
     }
 }