diff --git a/Cargo.lock b/Cargo.lock
index 7392b8b47..ebe450dd3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1325,7 +1325,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1336,7 +1336,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3005,7 +3005,7 @@ dependencies = [
 [[package]]
 name = "bitvm"
 version = "0.1.0"
-source = "git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2#e369b2a59d86dad2bdc52daeb5fc6b890e9dc812"
+source = "git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2#bab46c2336ad98513bcb8cbaff21b5506a4dcd9a"
 dependencies = [
  "ark-bn254",
  "ark-crypto-primitives",
@@ -3050,6 +3050,7 @@ dependencies = [
  "bitvm 0.1.0 (git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2)",
  "chacha20poly1305",
  "clap",
+ "esplora-client",
  "garbled-snark-verifier",
  "goat",
  "hex",
@@ -3058,6 +3059,8 @@ dependencies = [
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rayon",
+ "reqwest 0.11.27",
+ "reqwest 0.12.28",
  "secp256k1 0.29.1",
  "serde",
  "serde-big-array",
@@ -3065,6 +3068,7 @@ dependencies = [
  "sha2 0.10.9",
  "soldering-host",
  "strum 0.26.3",
+ "tokio",
  "tracing",
  "uuid 1.23.0",
  "verifiable-circuit-babe",
@@ -4827,7 +4831,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5740,7 +5744,7 @@ dependencies = [
 [[package]]
 name = "goat"
 version = "0.1.0"
-source = "git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2#e369b2a59d86dad2bdc52daeb5fc6b890e9dc812"
+source = "git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2#bab46c2336ad98513bcb8cbaff21b5506a4dcd9a"
 dependencies = [
  "ark-bn254",
  "ark-crypto-primitives",
@@ -5756,6 +5760,7 @@ dependencies = [
  "bitcoin-script",
  "bitcoin-scriptexec",
  "bitvm 0.1.0 (git+https://github.com/GOATNetwork/BitVM.git?branch=gc-v2)",
+ "blake3",
  "clap",
  "colored",
  "hex",
@@ -8188,7 +8193,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11315,7 +11320,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -11418,7 +11423,7 @@ dependencies = [
  "security-framework 3.7.0",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -12175,7 +12180,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -12863,7 +12868,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -14283,7 +14288,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 54b874f45..4fc54ca9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,6 @@ members = [
     "crates/header-chain",
     "crates/commit-chain",
     "crates/state-chain",
-    #"crates/mara-slipstream-client",
     "crates/bitcoin-light-client-circuit",
     "crates/verifier",
     "circuits/header-chain-proof/host",
diff --git a/crates/bitvm-gc/Cargo.toml b/crates/bitvm-gc/Cargo.toml
index d6e9e3795..50ae4e378 100644
--- a/crates/bitvm-gc/Cargo.toml
+++ b/crates/bitvm-gc/Cargo.toml
@@ -37,7 +37,11 @@ strum = { workspace = true, features = ["derive"] }
 [dev-dependencies]
 ark-crypto-primitives = { workspace = true }
 ark-ec = { workspace = true }
+esplora-client = { workspace = true }
 rand_chacha = { workspace = true }
+reqwest = { workspace = true }
+reqwest-0-11 = { package = "reqwest", version = "0.11.27", default-features = false, features = ["json", "rustls-tls"] }
+tokio = { workspace = true, features = ["macros", "time"] }
 
 [features]
 default = []
diff --git a/crates/bitvm-gc/src/verifier/api.rs b/crates/bitvm-gc/src/verifier/api.rs
index c9b4b7c06..53deee6d2 100644
--- a/crates/bitvm-gc/src/verifier/api.rs
+++ b/crates/bitvm-gc/src/verifier/api.rs
@@ -362,3 +362,107 @@ pub fn disprove_timelock(network: Network) -> u32 {
 pub fn disprove_timelock_with_config(network: Network, timelock_config: &TimelockConfig) -> u32 {
     disprove_timelock_blocks(network, timelock_config)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bitcoin::{
+        OutPoint, TxOut, XOnlyPublicKey,
+        secp256k1::{Keypair, SECP256K1, SecretKey},
+    };
+    use goat::{
+        connectors::{
+            base::TaprootConnector,
+            connector_d::{CONNECTOR_D_PUBIN_DISPROVE_LEAF_INDEX, ConnectorD},
+        },
+        scripts::{generate_opreturn_script, p2a_output},
+        transactions::base::{Input, pubin_disprove_input_amount},
+    };
+
+    #[test]
+    fn pubin_disprove_with_witness_is_standard_sized() {
+        let operator_secret = SecretKey::from_slice(&[1; 32]).expect("valid operator secret");
+        let committee_secret = SecretKey::from_slice(&[2; 32]).expect("valid committee secret");
+        let operator_keypair = Keypair::from_secret_key(SECP256K1, &operator_secret);
+        let committee_keypair = Keypair::from_secret_key(SECP256K1, &committee_secret);
+        let operator_key =
+            XOnlyPublicKey::from(bitcoin::PublicKey::from(operator_keypair.public_key()));
+        let committee_key =
+            XOnlyPublicKey::from(bitcoin::PublicKey::from(committee_keypair.public_key()));
+
+        let guest_secret = Wots96::generate_secret_key();
+        let guest_public_key = Wots96::generate_public_key(&guest_secret);
+        let assert_secret = Wots96::generate_secret_key();
+        let assert_public_key = Wots96::generate_public_key(&assert_secret);
+        let expected_constant = [0x22; 32];
+        let mut guest_pubin = [0u8; 96];
+        guest_pubin[..32].fill(0x11);
+        guest_pubin[32..64].fill(0x23);
+        guest_pubin[64..].fill(0xff);
+        let operator_assert_pubin = [0u8; 96];
+
+        let connector_d = ConnectorD::new(
+            Network::Testnet4,
+            &operator_key,
+            &committee_key,
+            &guest_public_key,
+            &assert_public_key,
+            &expected_constant,
+            &vec![],
+            &default_timelock_config(Network::Testnet4),
+        );
+        let assert_witness =
+            Wots96::sign_to_raw_witness(&assert_secret, &operator_assert_pubin).to_vec();
+        let guest_witness = Wots96::sign_to_raw_witness(&guest_secret, &guest_pubin).to_vec();
+        assert!(
+            validate_pubin(
+                guest_witness.clone(),
+                assert_witness.clone(),
+                vec![],
+                connector_d.generate_taproot_leaf_script(CONNECTOR_D_PUBIN_DISPROVE_LEAF_INDEX),
+            )
+            .is_some(),
+            "locally constructed pubin-disprove witness must satisfy Connector-D",
+        );
+        let mut witness = assert_witness;
+        witness.extend(guest_witness);
+        let input = pubin_disprove(
+            &connector_d,
+            &Input {
+                outpoint: OutPoint::null(),
+                amount: Amount::from_sat(pubin_disprove_input_amount()),
+            },
+            witness,
+        )
+        .expect("build pubin-disprove input");
+        let tx = Transaction {
+            version: bitcoin::transaction::Version(2),
+            lock_time: bitcoin::absolute::LockTime::ZERO,
+            input: vec![input],
+            output: vec![
+                p2a_output(),
+                TxOut {
+                    value: Amount::ZERO,
+                    script_pubkey: generate_opreturn_script(b"pubin-disprove".to_vec()),
+                },
+            ],
+        };
+
+        let base_size = tx.base_size();
+        let witness_size = tx.input[0].witness.size();
+        let total_size = tx.total_size();
+        println!(
+            "pubin-disprove tx sizes: base_size={base_size}, witness_size={witness_size}, total_size={total_size}"
+        );
+        assert_eq!(
+            total_size,
+            base_size + witness_size + 2,
+            "pubin-disprove total size must include the SegWit marker/flag and script witness: total={total_size}, base={base_size}, witness={witness_size}",
+        );
+        assert!(
+            tx.weight() <= Transaction::MAX_STANDARD_WEIGHT,
+            "pubin-disprove exceeds Bitcoin Core's standard transaction limit: weight={}, total_size={total_size}",
+            tx.weight().to_wu(),
+        );
+    }
+}
diff --git a/crates/bitvm-gc/tests/regtest.rs b/crates/bitvm-gc/tests/regtest.rs
new file mode 100644
index 000000000..57b804155
--- /dev/null
+++ b/crates/bitvm-gc/tests/regtest.rs
@@ -0,0 +1,1242 @@
+use anyhow::{Context, Result, anyhow, bail, ensure};
+use ark_bn254::{Bn254, Fr, G1Affine, G2Affine};
+use ark_ec::AffineRepr;
+use ark_groth16::Proof;
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use bitcoin::hashes::{Hash, hash160};
+use bitcoin::key::Keypair;
+use bitcoin::secp256k1::{SECP256K1, SecretKey};
+use bitcoin::{
+    Address, Amount, EcdsaSighashType, Network, OutPoint, PublicKey, ScriptBuf, Sequence,
+    Transaction, TxIn, TxOut, Txid, XOnlyPublicKey, absolute, transaction,
+};
+use bitcoin_script::script;
+use bitvm_gc::babe_adapter::{
+    BABE_M_CC, BabeProverState, CACSetupPackage, TxAssertWitness, assert_wots_message,
+    build_assert_witness, build_setup_package, derive_finalized_indices, extract_gc_circuit_data,
+    open_and_solder, recover_operator_proof_from_assert_witness, verify_setup,
+};
+use bitvm_gc::committee::{
+    agg_and_push_pegin_confirm_sigs, committee_pre_sign, generate_nonce_from_seed, key_aggregation,
+    nonce_aggregation, nonces_aggregation, push_committee_pre_signatures, sign_pegin_confirm,
+    signature_aggregation, verify_graph_committee_pre_signatures, verify_nonce_signatures,
+};
+use bitvm_gc::keys::{CommitteeMasterKey, OperatorMasterKey};
+use bitvm_gc::operator::{
+    generate_bitvm_graph, operator_pre_sign, operator_sign_assert, operator_sign_challenge_ack,
+    operator_sign_commit_pubin, operator_sign_kickoff, operator_sign_prekickoff_input_0,
+    operator_sign_take1, operator_sign_take2, operator_sign_watchtower_challenge_init,
+    operator_sign_watchtower_challenge_timeout, operator_sign_wrongly_challenged,
+    verify_graph_operator_pre_signatures,
+};
+use bitvm_gc::timelocks::{
+    connector_f_timelock_blocks, default_timelock_config, disprove_timelock_blocks,
+    operator_ack_timelock_blocks, operator_commit_timelock_blocks, take1_timelock_blocks,
+    take2_timelock_blocks, watchtower_challenge_timelock_blocks,
+};
+use bitvm_gc::types::{
+    BitvmGcCircuitData, BitvmGcGraph, BitvmGcGraphParameters, BitvmGcInstanceParameters,
+    PrekickoffParameters, UserInfo,
+};
+use bitvm_gc::verifier::{
+    build_disprove_tx, build_pubin_disprove_txin, build_verifier_assert_tx, export_challenge_tx,
+    validate_pubin_disprove,
+};
+use bitvm_gc::watchtower::{build_watchtower_challenge_tx, estimate_watchtower_challenge_vbytes};
+use esplora_client::AsyncClient as EsploraClient;
+use goat::assert_scripts::{INPUT_WIRE_NUM, Label, WireHash, label_hash};
+use goat::connectors::base::TaprootConnector;
+use goat::connectors::kickoff_connectors::{
+    ForceSkipConnector, KickoffConnector, PrekickoffConnector,
+};
+use goat::scripts::{generate_opreturn_script, p2a_output};
+use goat::transactions::base::{DUST_AMOUNT, Input};
+use goat::transactions::pre_signed::PreSignedTransaction;
+use goat::transactions::prekickoff::PrekickoffTransaction;
+use goat::transactions::signing::populate_p2wsh_witness;
+use reqwest::Client;
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use serde_json::{Value, json};
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+use std::time::{Duration, Instant};
+use tokio::time::sleep;
+use uuid::Uuid;
+
+const REGTEST_ESPLORA_URL: &str = "http://127.0.0.1:3002";
+const REGTEST_RPC_URL: &str = "http://127.0.0.1:18443/wallet/alice";
+const FIXTURE_VERSION: u32 = 1;
+const FIXTURE_FILE: &str = "bitvm-gc-regtest-proof-gc-v1.bin";
+const DEFAULT_FEE_SATS: u64 = 1_000;
+const PREKICKOFF_AMOUNT_SATS: u64 = 500_000;
+const PEGIN_AMOUNT_SATS: u64 = 100_000_000;
+const PAYER_AMOUNT_SATS: u64 = 5_000_000;
+const FEE_RATE_SAT_PER_VBYTE: u64 = 2;
+const CONFIRM_TIMEOUT: Duration = Duration::from_secs(60);
+
+static MOCK_FIXTURE: OnceLock<std::result::Result<MockProofGcFixture, String>> = OnceLock::new();
+
+#[derive(Serialize, Deserialize)]
+struct MockProofGcFixture {
+    version: u32,
+    setup_package: CACSetupPackage,
+    opened: Vec<(usize, u64)>,
+    prover_state: BabeProverState,
+    gc_data: BitvmGcCircuitData,
+    proof_bytes: Vec<u8>,
+}
+
+struct TestKeys {
+    user: Keypair,
+    operator: Keypair,
+    challenger: Keypair,
+    committee: Vec<Keypair>,
+    verifier: Keypair,
+    watchtowers: Vec<Keypair>,
+}
+
+struct RegtestRpc {
+    client: Client,
+    url: String,
+    user: String,
+    password: String,
+}
+
+struct RegtestGraph {
+    graph: BitvmGcGraph,
+    keys: TestKeys,
+    assert_witness: TxAssertWitness,
+    challenge_labels: Vec<Label>,
+    final_msg: Vec<u8>,
+}
+
+impl RegtestRpc {
+    fn from_env() -> Result<Self> {
+        Ok(Self {
+            client: Client::builder().no_proxy().build().expect("build Bitcoin RPC client"),
+            url: std::env::var("BITVM_E2E_BITCOIN_RPC_URL")
+                .unwrap_or_else(|_| REGTEST_RPC_URL.to_string()),
+            user: std::env::var("BITVM_E2E_BITCOIN_RPC_USER")
+                .context("BITVM_E2E_BITCOIN_RPC_USER must be set for regtest E2E tests")?,
+            password: std::env::var("BITVM_E2E_BITCOIN_RPC_PASSWORD")
+                .context("BITVM_E2E_BITCOIN_RPC_PASSWORD must be set for regtest E2E tests")?,
+        })
+    }
+
+    async fn call<T: DeserializeOwned>(&self, method: &str, params: Value) -> Result<T> {
+        let response = self
+            .client
+            .post(&self.url)
+            .basic_auth(&self.user, Some(&self.password))
+            .json(&json!({
+                "jsonrpc": "1.0",
+                "id": "bitvm-gc-e2e",
+                "method": method,
+                "params": params,
+            }))
+            .send()
+            .await
+            .with_context(|| format!("call Bitcoin RPC method {method}"))?
+            .error_for_status()
+            .with_context(|| format!("Bitcoin RPC method {method} returned HTTP error"))?;
+        let body: Value = response.json().await?;
+        if !body["error"].is_null() {
+            bail!("Bitcoin RPC method {method} failed: {}", body["error"]);
+        }
+        serde_json::from_value(body["result"].clone())
+            .with_context(|| format!("decode Bitcoin RPC method {method} result"))
+    }
+
+    async fn send_to_address(&self, address: &Address, amount: Amount) -> Result<Txid> {
+        let txid: String =
+            self.call("sendtoaddress", json!([address.to_string(), amount.to_btc()])).await?;
+        txid.parse().context("Bitcoin RPC returned invalid funding txid")
+    }
+
+    async fn prepare_wallet(&self) -> Result<()> {
+        let passphrase = std::env::var("BITVM_E2E_WALLET_PASSPHRASE")
+            .context("BITVM_E2E_WALLET_PASSPHRASE must be set for regtest E2E tests")?;
+        if let Err(error) = self.call::<Value>("walletpassphrase", json!([passphrase, 3_600])).await
+        {
+            let message = error.to_string();
+            if !message.contains("unencrypted wallet") && !message.contains("not encrypted") {
+                return Err(error).context("unlock regtest wallet");
+            }
+        }
+
+        let balance: f64 = self.call("getbalance", json!([])).await?;
+        if balance >= 5.0 {
+            return Ok(());
+        }
+
+        let mining_address: String = self.call("getnewaddress", json!([])).await?;
+        let _: Vec<String> = self.call("generatetoaddress", json!([101, mining_address])).await?;
+        Ok(())
+    }
+
+    async fn mine_blocks(&self, count: u32, address: &Address) -> Result<()> {
+        if count == 0 {
+            return Ok(());
+        }
+        let _: Vec<String> =
+            self.call("generatetoaddress", json!([count, address.to_string()])).await?;
+        Ok(())
+    }
+}
+
+fn fixture_path() -> PathBuf {
+    if let Some(path) = std::env::var_os("BITVM_E2E_FIXTURE_DIR") {
+        return PathBuf::from(path).join(FIXTURE_FILE);
+    }
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .and_then(Path::parent)
+        .expect("bitvm-gc crate must be inside workspace/crates")
+        .join("target/e2e-fixtures")
+        .join(FIXTURE_FILE)
+}
+
+fn keypair(seed: &str) -> Result<Keypair> {
+    let digest = Sha256::digest(seed.as_bytes());
+    let secret_key = SecretKey::from_slice(&digest)?;
+    Ok(Keypair::from_secret_key(SECP256K1, &secret_key))
+}
+
+fn test_keys() -> Result<TestKeys> {
+    Ok(TestKeys {
+        user: keypair("bitvm-gc-e2e-user")?,
+        operator: keypair("bitvm-gc-e2e-operator")?,
+        challenger: keypair("bitvm-gc-e2e-challenger")?,
+        committee: vec![keypair("bitvm-gc-e2e-committee-0")?, keypair("bitvm-gc-e2e-committee-1")?],
+        verifier: keypair("bitvm-gc-e2e-verifier")?,
+        watchtowers: vec![
+            keypair("bitvm-gc-e2e-watchtower-0")?,
+            keypair("bitvm-gc-e2e-watchtower-1")?,
+        ],
+    })
+}
+
+fn generate_fixture() -> Result<MockProofGcFixture> {
+    let keys = test_keys()?;
+    let setup_package = build_setup_package(BABE_M_CC + 1)?;
+    let finalized_indices = derive_finalized_indices(&setup_package, BABE_M_CC)?;
+    let (opened, finalized, soldering) = open_and_solder(&setup_package, &finalized_indices)?;
+    verify_setup(&setup_package, &opened, &finalized, &soldering)?;
+
+    let epk = &setup_package.commits[finalized[0].index].epk;
+    let h_msgs =
+        finalized.iter().map(|item| setup_package.commits[item.index].h_msg).collect::<Vec<_>>();
+    let gc_data =
+        extract_gc_circuit_data(PublicKey::from(keys.verifier.public_key()), epk, &h_msgs)?;
+    let prover_state =
+        BabeProverState { package: setup_package.clone(), finalized, soldering, h_msgs };
+
+    let proof = Proof::<Bn254> {
+        a: G1Affine::generator(),
+        b: G2Affine::generator(),
+        c: G1Affine::generator(),
+    };
+    let mut proof_bytes = Vec::new();
+    proof.serialize_compressed(&mut proof_bytes)?;
+
+    Ok(MockProofGcFixture {
+        version: FIXTURE_VERSION,
+        setup_package,
+        opened,
+        prover_state,
+        gc_data,
+        proof_bytes,
+    })
+}
+
+fn validate_fixture(fixture: &MockProofGcFixture) -> Result<()> {
+    ensure!(fixture.version == FIXTURE_VERSION, "fixture version mismatch");
+    verify_setup(
+        &fixture.setup_package,
+        &fixture.opened,
+        &fixture.prover_state.finalized,
+        &fixture.prover_state.soldering,
+    )?;
+    ensure!(
+        fixture.prover_state.package == fixture.setup_package,
+        "fixture prover state uses another setup package"
+    );
+
+    let first =
+        fixture.prover_state.finalized.first().context("fixture has no finalized GC instance")?;
+    let expected_gc = extract_gc_circuit_data(
+        PublicKey::from(test_keys()?.verifier.public_key()),
+        &fixture.setup_package.commits[first.index].epk,
+        &fixture.prover_state.h_msgs,
+    )?;
+    ensure!(expected_gc == fixture.gc_data, "fixture GC data is inconsistent");
+    let _: Proof<Bn254> = Proof::deserialize_compressed(fixture.proof_bytes.as_slice())?;
+    Ok(())
+}
+
+fn load_or_generate_fixture() -> Result<MockProofGcFixture> {
+    let path = fixture_path();
+    if let Ok(bytes) = fs::read(&path)
+        && let Ok(fixture) = bincode::deserialize::<MockProofGcFixture>(&bytes)
+        && validate_fixture(&fixture).is_ok()
+    {
+        return Ok(fixture);
+    }
+
+    let fixture = generate_fixture()?;
+    validate_fixture(&fixture)?;
+    let parent = path.parent().context("fixture path has no parent")?;
+    fs::create_dir_all(parent)?;
+    fs::write(&path, bincode::serialize(&fixture)?)
+        .with_context(|| format!("write fixture {}", path.display()))?;
+    Ok(fixture)
+}
+
+fn fixture() -> Result<&'static MockProofGcFixture> {
+    match MOCK_FIXTURE.get_or_init(|| load_or_generate_fixture().map_err(|error| error.to_string()))
+    {
+        Ok(fixture) => Ok(fixture),
+        Err(error) => Err(anyhow!(error.clone())),
+    }
+}
+
+fn mock_proof(fixture: &MockProofGcFixture) -> Result<Proof<Bn254>> {
+    Proof::deserialize_compressed(fixture.proof_bytes.as_slice()).map_err(Into::into)
+}
+
+fn challenge_label(wire_index: usize, value: bool) -> Label {
+    let mut hasher = Sha256::new();
+    hasher.update(b"bitvm-gc-regtest-challenge-label");
+    hasher.update(wire_index.to_le_bytes());
+    hasher.update([u8::from(value)]);
+    hasher.finalize()[..16].to_vec()
+}
+
+fn synthetic_challenge_data(
+    verifier_pubkey: PublicKey,
+    message: &[u8; 96],
+) -> (BitvmGcCircuitData, Vec<Label>, Vec<u8>) {
+    let true_labels =
+        (0..INPUT_WIRE_NUM).map(|wire_index| challenge_label(wire_index, true)).collect::<Vec<_>>();
+    let false_labels = (0..INPUT_WIRE_NUM)
+        .map(|wire_index| challenge_label(wire_index, false))
+        .collect::<Vec<_>>();
+    let wire_hashes: [WireHash; INPUT_WIRE_NUM] = std::array::from_fn(|wire_index| WireHash {
+        true_label_hash: label_hash(&true_labels[wire_index]),
+        false_label_hash: label_hash(&false_labels[wire_index]),
+    });
+    let labels = (0..INPUT_WIRE_NUM)
+        .map(|wire_index| {
+            let bit = (message[wire_index / 8] >> (wire_index % 8)) & 1;
+            if bit == 1 {
+                true_labels[wire_index].clone()
+            } else {
+                false_labels[wire_index].clone()
+            }
+        })
+        .collect();
+    let final_msg = b"bitvm-gc-regtest-final-message".to_vec();
+    (
+        BitvmGcCircuitData {
+            verifier_pubkey,
+            final_msg_hashlocks: vec![label_hash(&final_msg)],
+            wire_hashes,
+        },
+        labels,
+        final_msg,
+    )
+}
+
+fn node_script(pubkey: &PublicKey) -> ScriptBuf {
+    script! {
+        { *pubkey }
+        OP_CHECKSIG
+    }
+    .compile()
+}
+
+fn node_address(network: Network, keypair: &Keypair) -> Address {
+    Address::p2wsh(&node_script(&PublicKey::from(keypair.public_key())), network)
+}
+
+fn node_sign(tx: &mut Transaction, input_index: usize, input_value: Amount, keypair: &Keypair) {
+    let pubkey = PublicKey::from(keypair.public_key());
+    populate_p2wsh_witness(
+        tx,
+        input_index,
+        EcdsaSighashType::All,
+        &node_script(&pubkey),
+        input_value,
+        &vec![keypair],
+    );
+}
+
+fn esplora_client() -> Result<EsploraClient> {
+    let url =
+        std::env::var("BITVM_E2E_ESPLORA_URL").unwrap_or_else(|_| REGTEST_ESPLORA_URL.to_string());
+    let client = reqwest_0_11::Client::builder()
+        .no_proxy()
+        .build()
+        .context("build regtest Esplora HTTP client")?;
+    Ok(EsploraClient::from_client(url, client))
+}
+
+async fn wait_esplora_height(esplora: &EsploraClient, expected: u32) -> Result<()> {
+    let started = Instant::now();
+    loop {
+        if esplora.get_height().await.is_ok_and(|height| height >= expected) {
+            return Ok(());
+        }
+        if started.elapsed() >= CONFIRM_TIMEOUT {
+            bail!("Esplora did not reach block height {expected} within {CONFIRM_TIMEOUT:?}");
+        }
+        sleep(Duration::from_millis(500)).await;
+    }
+}
+
+async fn wait_tx_confirm(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    txid: Txid,
+) -> Result<u32> {
+    rpc.mine_blocks(1, mining_address).await?;
+    let started = Instant::now();
+    loop {
+        if let Ok(status) = esplora.get_tx_status(&txid).await
+            && let Some(height) = status.block_height
+        {
+            return Ok(height);
+        }
+        if started.elapsed() >= CONFIRM_TIMEOUT {
+            bail!("transaction {txid} was not confirmed within {CONFIRM_TIMEOUT:?}");
+        }
+        sleep(Duration::from_millis(500)).await;
+    }
+}
+
+async fn broadcast_and_confirm(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    label: &str,
+    tx: &Transaction,
+) -> Result<u32> {
+    let txid = tx.compute_txid();
+    println!("broadcasting {label}: {txid}");
+    esplora.broadcast(tx).await.with_context(|| format!("broadcast {label} {txid}"))?;
+    let height = wait_tx_confirm(esplora, rpc, mining_address, txid).await?;
+    println!("{label} confirmed at height {height}: {txid}");
+    Ok(height)
+}
+
+async fn fund_address(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    address: &Address,
+    amount: Amount,
+) -> Result<OutPoint> {
+    let txid = rpc.send_to_address(address, amount).await?;
+    wait_tx_confirm(esplora, rpc, mining_address, txid).await?;
+    let tx = esplora
+        .get_tx(&txid)
+        .await?
+        .with_context(|| format!("funding transaction {txid} is missing from Esplora"))?;
+    let vout = tx
+        .output
+        .iter()
+        .position(|output| output.script_pubkey == address.script_pubkey())
+        .with_context(|| format!("funding transaction {txid} does not pay {address}"))?;
+    Ok(OutPoint { txid, vout: vout.try_into()? })
+}
+
+async fn wait_timelock(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    start_height: u32,
+    blocks: u32,
+) -> Result<()> {
+    let expected = start_height.saturating_add(blocks).saturating_add(1);
+    let current = esplora.get_height().await?;
+    rpc.mine_blocks(expected.saturating_sub(current), mining_address).await?;
+    wait_esplora_height(esplora, expected).await
+}
+
+async fn add_payer_input(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    payer: &Keypair,
+    mut tx: Transaction,
+    committed_input_amount: Amount,
+) -> Result<Transaction> {
+    let payer_amount = Amount::from_sat(PAYER_AMOUNT_SATS);
+    let payer_address = node_address(Network::Regtest, payer);
+    let payer_outpoint =
+        fund_address(esplora, rpc, mining_address, &payer_address, payer_amount).await?;
+    tx.input.push(TxIn {
+        previous_output: payer_outpoint,
+        script_sig: ScriptBuf::new(),
+        sequence: Sequence::MAX,
+        witness: bitcoin::Witness::new(),
+    });
+
+    let output_amount: Amount = tx.output.iter().map(|output| output.value).sum();
+    let total_input_amount = committed_input_amount + payer_amount;
+    ensure!(
+        total_input_amount >= output_amount + Amount::from_sat(DUST_AMOUNT),
+        "payer input cannot cover transaction outputs and change"
+    );
+    tx.output.push(TxOut {
+        value: total_input_amount - output_amount,
+        script_pubkey: payer_address.script_pubkey(),
+    });
+    let payer_index = tx.input.len() - 1;
+    node_sign(&mut tx, payer_index, payer_amount, payer);
+
+    let fee =
+        Amount::from_sat((tx.vsize() as u64 * FEE_RATE_SAT_PER_VBYTE).max(DEFAULT_FEE_SATS * 2));
+    ensure!(
+        total_input_amount >= output_amount + fee + Amount::from_sat(DUST_AMOUNT),
+        "payer input cannot cover transaction outputs, fee, and change"
+    );
+    tx.output.last_mut().expect("change output was added").value =
+        total_input_amount - output_amount - fee;
+    tx.input[payer_index].witness.clear();
+    node_sign(&mut tx, payer_index, payer_amount, payer);
+    Ok(tx)
+}
+
+fn committee_pre_sign_graph(graph: &mut BitvmGcGraph, keys: &TestKeys) -> Result<()> {
+    let watchtower_num = graph.parameters.watchtower_pubkeys.len();
+    let verifier_num = graph.parameters.gc_data.len();
+    let mut pub_nonces = Vec::with_capacity(keys.committee.len());
+    let mut sec_nonces = Vec::with_capacity(keys.committee.len());
+
+    for (index, keypair) in keys.committee.iter().enumerate() {
+        let (member_pub_nonces, member_sec_nonces, nonce_signatures) = generate_nonce_from_seed(
+            format!("bitvm-gc-regtest-committee-{index}"),
+            graph.parameters.graph_nonce as usize,
+            *keypair,
+            watchtower_num,
+            verifier_num,
+        );
+        ensure!(
+            verify_nonce_signatures(
+                &XOnlyPublicKey::from(PublicKey::from(keypair.public_key())),
+                &member_pub_nonces,
+                &nonce_signatures,
+                watchtower_num,
+                verifier_num,
+            )?,
+            "committee member {index} generated invalid nonce signatures"
+        );
+        pub_nonces.push(member_pub_nonces);
+        sec_nonces.push(member_sec_nonces);
+    }
+
+    let agg_nonces = nonces_aggregation(&pub_nonces)?;
+    let partial_signatures = keys
+        .committee
+        .iter()
+        .zip(sec_nonces)
+        .map(|(keypair, sec_nonce)| {
+            committee_pre_sign(*keypair, sec_nonce, agg_nonces.clone(), graph)
+        })
+        .collect::<Result<Vec<_>>>()?;
+    let signatures = signature_aggregation(&partial_signatures, &agg_nonces, graph)?;
+    push_committee_pre_signatures(graph, &signatures)?;
+    verify_graph_committee_pre_signatures(graph)
+}
+
+fn committee_sign_pegin(graph: &BitvmGcGraph, keys: &TestKeys) -> Result<Transaction> {
+    let parameters_hash = graph.parameters.instance_parameters.parameters_hash()?;
+    let instance_id = graph.parameters.instance_parameters.instance_id;
+    let mut pub_nonces = Vec::with_capacity(keys.committee.len());
+    let mut sec_nonces = Vec::with_capacity(keys.committee.len());
+    for keypair in &keys.committee {
+        let (sec_nonce, pub_nonce, _) = CommitteeMasterKey::new(*keypair)
+            .nonce_for_instance_job_with_keypair(instance_id, parameters_hash, *keypair);
+        pub_nonces.push(pub_nonce);
+        sec_nonces.push(sec_nonce);
+    }
+    let agg_nonce = nonce_aggregation(&pub_nonces);
+    let partial_signatures = keys
+        .committee
+        .iter()
+        .zip(sec_nonces)
+        .map(|(keypair, sec_nonce)| {
+            sign_pegin_confirm(graph, *keypair, sec_nonce, agg_nonce.clone())
+        })
+        .collect::<Result<Vec<_>>>()?;
+    agg_and_push_pegin_confirm_sigs(graph, partial_signatures, &agg_nonce)
+}
+
+async fn build_regtest_graph_with_watchtowers(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    watchtower_count: usize,
+) -> Result<RegtestGraph> {
+    rpc.prepare_wallet().await?;
+    let fixture = fixture()?;
+    let keys = test_keys()?;
+    ensure!(
+        (1..=keys.watchtowers.len()).contains(&watchtower_count),
+        "watchtower count must be between 1 and {}",
+        keys.watchtowers.len()
+    );
+    let network = Network::Regtest;
+    let mining_address = node_address(network, &keys.challenger);
+    let instance_id = Uuid::new_v4();
+    let graph_id = Uuid::new_v4();
+    let operator_master_key = OperatorMasterKey::new(keys.operator);
+    let operator_pubkey = PublicKey::from(keys.operator.public_key());
+    let operator_xonly = XOnlyPublicKey::from(operator_pubkey);
+    let committee_pubkeys =
+        keys.committee.iter().map(|key| PublicKey::from(key.public_key())).collect::<Vec<_>>();
+    let committee_agg_pubkey = key_aggregation(&committee_pubkeys);
+    let fee = Amount::from_sat(DEFAULT_FEE_SATS);
+    let pegin_amount = Amount::from_sat(PEGIN_AMOUNT_SATS);
+    let deposit_input_amount = pegin_amount + fee * 2;
+    let user_address = node_address(network, &keys.user);
+    let deposit_outpoint =
+        fund_address(esplora, rpc, &mining_address, &user_address, deposit_input_amount).await?;
+
+    let instance_parameters = BitvmGcInstanceParameters {
+        network,
+        instance_id,
+        user_info: UserInfo {
+            depositor_evm_address: [0x11; 20],
+            txn_fees: [fee.to_sat(); 3],
+            inputs: vec![Input { outpoint: deposit_outpoint, amount: deposit_input_amount }],
+            user_xonly_pubkey: keys.user.x_only_public_key().0,
+            user_change_address: user_address.clone(),
+            user_refund_address: user_address,
+        },
+        pegin_amount,
+        committee_pubkeys,
+        committee_agg_pubkey,
+    };
+
+    let mut pegin_deposit = instance_parameters.build_pegin_tx()?.0;
+    node_sign(pegin_deposit.tx_mut(), 0, deposit_input_amount, &keys.user);
+    broadcast_and_confirm(esplora, rpc, &mining_address, "pegin-deposit", pegin_deposit.tx())
+        .await?;
+
+    let prekickoff_connector = PrekickoffConnector::new(network, &operator_xonly);
+    let force_skip_connector = ForceSkipConnector::new(network, &operator_xonly);
+    let kickoff_connector = KickoffConnector::new(network, &operator_xonly);
+    let prekickoff_amount = Amount::from_sat(PREKICKOFF_AMOUNT_SATS);
+    let prekickoff_outpoint = fund_address(
+        esplora,
+        rpc,
+        &mining_address,
+        &prekickoff_connector.generate_taproot_address(),
+        prekickoff_amount,
+    )
+    .await?;
+    let cur_prekickoff = PrekickoffTransaction::new_for_validation(
+        &prekickoff_connector,
+        &force_skip_connector,
+        &kickoff_connector,
+        &prekickoff_connector,
+        Input { outpoint: prekickoff_outpoint, amount: prekickoff_amount },
+        vec![],
+        vec![],
+        fee.to_sat(),
+        watchtower_count,
+        1,
+    )
+    .map_err(|error| anyhow!("build current pre-kickoff: {error}"))?;
+
+    let (_, operator_assert_wots_pubkey) =
+        operator_master_key.assert_wots_keypair_for_graph(graph_id);
+    let (_, operator_commit_pubin_wots_pubkey) =
+        operator_master_key.commit_pubin_wots_keypair_for_graph(graph_id);
+    let proof = mock_proof(fixture)?;
+    let (assert_secret_key, _) = operator_master_key.assert_wots_keypair_for_graph(graph_id);
+    let assert_witness = build_assert_witness(&proof, &assert_secret_key, Fr::from(42_u64))?;
+    let recovered = recover_operator_proof_from_assert_witness(&assert_witness)?;
+    ensure!(recovered == proof, "mock proof did not round-trip through the assert witness");
+    let assert_message = assert_wots_message(&assert_witness)?;
+    let (gc_data, challenge_labels, final_msg) =
+        synthetic_challenge_data(PublicKey::from(keys.verifier.public_key()), &assert_message);
+    let watchtower_pubkeys = keys
+        .watchtowers
+        .iter()
+        .take(watchtower_count)
+        .map(|key| key.x_only_public_key().0)
+        .collect();
+    let watchtower_ack_hashlocks = (0..watchtower_count)
+        .map(|index| {
+            hash160::Hash::hash(&operator_master_key.preimage_for_graph(graph_id, index))
+                .to_byte_array()
+        })
+        .collect();
+    let parameters = BitvmGcGraphParameters {
+        instance_parameters,
+        prekickoff_parameters: PrekickoffParameters {
+            cur_prekickoff_txn: cur_prekickoff,
+            replenish_fee_inputs: vec![],
+            replenish_fee_prev_outs: vec![],
+            fee_amount: fee.to_sat(),
+        },
+        timelock_config: default_timelock_config(network),
+        graph_id,
+        graph_nonce: 0,
+        challenge_amount: Amount::from_sat(20_000),
+        operator_pubkey,
+        operator_assert_wots_pubkey,
+        operator_commit_pubin_wots_pubkey,
+        operator_receive_address: node_address(network, &keys.operator),
+        watchtower_pubkeys,
+        watchtower_ack_hashlocks,
+        pubin_disprove_constant: [0x81; 32],
+        gc_data: vec![gc_data],
+    };
+    let mut graph = generate_bitvm_graph(parameters)?;
+
+    let prekickoff = operator_sign_prekickoff_input_0(keys.operator, &mut graph)?;
+    broadcast_and_confirm(esplora, rpc, &mining_address, "pre-kickoff", &prekickoff).await?;
+
+    operator_pre_sign(keys.operator, &mut graph)?;
+    verify_graph_operator_pre_signatures(&graph)?;
+    committee_pre_sign_graph(&mut graph, &keys)?;
+
+    let pegin_confirm = committee_sign_pegin(&graph, &keys)?;
+    broadcast_and_confirm(esplora, rpc, &mining_address, "pegin-confirm", &pegin_confirm).await?;
+
+    Ok(RegtestGraph { graph, keys, assert_witness, challenge_labels, final_msg })
+}
+
+async fn build_regtest_graph(esplora: &EsploraClient, rpc: &RegtestRpc) -> Result<RegtestGraph> {
+    build_regtest_graph_with_watchtowers(esplora, rpc, 1).await
+}
+
+async fn enter_watchtower_phase(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    graph: &mut BitvmGcGraph,
+    keys: &TestKeys,
+) -> Result<u32> {
+    let kickoff = operator_sign_kickoff(keys.operator, graph)?;
+    broadcast_and_confirm(esplora, rpc, mining_address, "kickoff", &kickoff).await?;
+
+    let (challenge, _) = export_challenge_tx(graph)?;
+    let challenge = add_payer_input(
+        esplora,
+        rpc,
+        mining_address,
+        &keys.challenger,
+        challenge,
+        graph.challenge.prev_outs()[0].value,
+    )
+    .await?;
+    broadcast_and_confirm(esplora, rpc, mining_address, "challenge", &challenge).await?;
+
+    let watchtower_challenge_init = operator_sign_watchtower_challenge_init(keys.operator, graph)?;
+    broadcast_and_confirm(
+        esplora,
+        rpc,
+        mining_address,
+        "watchtower-challenge-init",
+        &watchtower_challenge_init,
+    )
+    .await
+}
+
+async fn build_watchtower_challenge(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    graph: &BitvmGcGraph,
+    keys: &TestKeys,
+    watchtower_index: usize,
+) -> Result<Transaction> {
+    let watchtower = keys
+        .watchtowers
+        .get(watchtower_index)
+        .with_context(|| format!("missing watchtower key {watchtower_index}"))?;
+    let payer_amount = Amount::from_sat(PAYER_AMOUNT_SATS);
+    let payer_address = node_address(Network::Regtest, watchtower);
+    let payer_outpoint =
+        fund_address(esplora, rpc, mining_address, &payer_address, payer_amount).await?;
+    let commitment = format!("watchtower-{watchtower_index}-challenge").into_bytes();
+    let fee = Amount::from_sat(
+        (estimate_watchtower_challenge_vbytes(commitment.len()) as u64 * FEE_RATE_SAT_PER_VBYTE)
+            .max(DEFAULT_FEE_SATS),
+    );
+    let mut tx = build_watchtower_challenge_tx(
+        graph,
+        watchtower,
+        watchtower_index,
+        &commitment,
+        vec![Input { outpoint: payer_outpoint, amount: payer_amount }],
+        &payer_address,
+        fee,
+    )?;
+    node_sign(&mut tx, 1, payer_amount, watchtower);
+    Ok(tx)
+}
+
+async fn build_operator_ack(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    graph: &BitvmGcGraph,
+    keys: &TestKeys,
+    watchtower_index: usize,
+) -> Result<Transaction> {
+    let preimage = OperatorMasterKey::new(keys.operator)
+        .preimage_for_graph(graph.parameters.graph_id, watchtower_index);
+    let input = operator_sign_challenge_ack(graph, watchtower_index, &preimage)?;
+    let input_amount = graph
+        .watchtower_challenge_init
+        .ack_connector_input(watchtower_index)
+        .map_err(|error| anyhow!("get ACK connector input {watchtower_index}: {error}"))?
+        .amount;
+    add_payer_input(
+        esplora,
+        rpc,
+        mining_address,
+        &keys.operator,
+        Transaction {
+            version: transaction::Version(2),
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![input],
+            output: vec![p2a_output()],
+        },
+        input_amount,
+    )
+    .await
+}
+
+async fn build_operator_commit_pubin(
+    esplora: &EsploraClient,
+    rpc: &RegtestRpc,
+    mining_address: &Address,
+    graph: &BitvmGcGraph,
+    keys: &TestKeys,
+    pubin: &[u8; 96],
+) -> Result<Transaction> {
+    let operator_master_key = OperatorMasterKey::new(keys.operator);
+    let (commit_pubin_secret_key, _) =
+        operator_master_key.commit_pubin_wots_keypair_for_graph(graph.parameters.graph_id);
+    let input = operator_sign_commit_pubin(graph, &commit_pubin_secret_key, pubin)?;
+    let input_amount = graph
+        .watchtower_challenge_init
+        .connector_e_input()
+        .map_err(|error| anyhow!("get connector-e input: {error}"))?
+        .amount;
+    add_payer_input(
+        esplora,
+        rpc,
+        mining_address,
+        &keys.operator,
+        Transaction {
+            version: transaction::Version(2),
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![input],
+            output: vec![TxOut {
+                value: Amount::ZERO,
+                script_pubkey: generate_opreturn_script(vec![]),
+            }],
+        },
+        input_amount,
+    )
+    .await
+}
+
+fn build_operator_assert(
+    graph: &mut BitvmGcGraph,
+    keys: &TestKeys,
+    assert_witness: &TxAssertWitness,
+) -> Result<Transaction> {
+    let operator_master_key = OperatorMasterKey::new(keys.operator);
+    let (assert_secret_key, _) =
+        operator_master_key.assert_wots_keypair_for_graph(graph.parameters.graph_id);
+    let proof_message = assert_wots_message(assert_witness)?;
+    operator_sign_assert(
+        graph,
+        &assert_secret_key,
+        &proof_message,
+        &assert_witness.pi2,
+        &assert_witness.pi3,
+    )
+}
+
+fn build_verifier_assert(
+    graph: &BitvmGcGraph,
+    operator_assert_input: TxIn,
+    labels: Vec<Label>,
+) -> Result<Transaction> {
+    let labels: [Label; INPUT_WIRE_NUM] = labels.try_into().map_err(|labels: Vec<Label>| {
+        anyhow!("challenge label count is {}; expected {INPUT_WIRE_NUM}", labels.len())
+    })?;
+    build_verifier_assert_tx(graph, operator_assert_input, 0, labels)
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_take1_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, .. } = build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+
+    let kickoff = operator_sign_kickoff(keys.operator, &mut graph)?;
+    let kickoff_height =
+        broadcast_and_confirm(&esplora, &rpc, &mining_address, "kickoff", &kickoff).await?;
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        kickoff_height,
+        take1_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+
+    let take1 = operator_sign_take1(keys.operator, &mut graph)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "take1", &take1).await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_take2_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, assert_witness, .. } =
+        build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+
+    let kickoff = operator_sign_kickoff(keys.operator, &mut graph)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "kickoff", &kickoff).await?;
+
+    let (challenge, _) = export_challenge_tx(&graph)?;
+    let challenge_input_amount = graph.challenge.prev_outs()[0].value;
+    let challenge = add_payer_input(
+        &esplora,
+        &rpc,
+        &mining_address,
+        &keys.challenger,
+        challenge,
+        challenge_input_amount,
+    )
+    .await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "challenge", &challenge).await?;
+
+    let watchtower_challenge_init =
+        operator_sign_watchtower_challenge_init(keys.operator, &mut graph)?;
+    let watchtower_height = broadcast_and_confirm(
+        &esplora,
+        &rpc,
+        &mining_address,
+        "watchtower-challenge-init",
+        &watchtower_challenge_init,
+    )
+    .await?;
+
+    let operator_master_key = OperatorMasterKey::new(keys.operator);
+    let (commit_pubin_secret_key, _) =
+        operator_master_key.commit_pubin_wots_keypair_for_graph(graph.parameters.graph_id);
+    let pubin_commitment = assert_wots_message(&assert_witness)?;
+    let commit_pubin_input =
+        operator_sign_commit_pubin(&graph, &commit_pubin_secret_key, &pubin_commitment)?;
+    let commit_pubin_amount = graph
+        .watchtower_challenge_init
+        .connector_e_input()
+        .map_err(|error| anyhow!("get connector-e input: {error}"))?
+        .amount;
+    let commit_pubin = add_payer_input(
+        &esplora,
+        &rpc,
+        &mining_address,
+        &keys.operator,
+        Transaction {
+            version: transaction::Version(2),
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![commit_pubin_input],
+            output: vec![TxOut {
+                value: Amount::ZERO,
+                script_pubkey: generate_opreturn_script(vec![]),
+            }],
+        },
+        commit_pubin_amount,
+    )
+    .await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-commit-pubin", &commit_pubin)
+        .await?;
+
+    let (assert_secret_key, _) =
+        operator_master_key.assert_wots_keypair_for_graph(graph.parameters.graph_id);
+    let proof_message = assert_wots_message(&assert_witness)?;
+    let operator_assert = operator_sign_assert(
+        &mut graph,
+        &assert_secret_key,
+        &proof_message,
+        &assert_witness.pi2,
+        &assert_witness.pi3,
+    )?;
+    let assert_height =
+        broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-assert", &operator_assert)
+            .await?;
+
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        assert_height,
+        take2_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        watchtower_height,
+        connector_f_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+
+    let take2 = operator_sign_take2(keys.operator, &mut graph)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "take2", &take2).await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_watchtower_ack_and_timeout_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, .. } =
+        build_regtest_graph_with_watchtowers(&esplora, &rpc, 2).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    let watchtower_init_height =
+        enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    let challenge =
+        build_watchtower_challenge(&esplora, &rpc, &mining_address, &graph, &keys, 0).await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "watchtower-0-challenge", &challenge)
+        .await?;
+    let ack = build_operator_ack(&esplora, &rpc, &mining_address, &graph, &keys, 0).await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-ack-0", &ack).await?;
+
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        watchtower_init_height,
+        watchtower_challenge_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+    let timeout = operator_sign_watchtower_challenge_timeout(keys.operator, &mut graph, 1)?;
+    broadcast_and_confirm(
+        &esplora,
+        &rpc,
+        &mining_address,
+        "watchtower-1-challenge-timeout",
+        &timeout,
+    )
+    .await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_operator_challenge_nack_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, .. } = build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    let watchtower_init_height =
+        enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    let challenge =
+        build_watchtower_challenge(&esplora, &rpc, &mining_address, &graph, &keys, 0).await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "watchtower-challenge", &challenge)
+        .await?;
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        watchtower_init_height,
+        operator_ack_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+    let nack = graph.operator_challenge_nacks[0].tx().clone();
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-challenge-nack", &nack)
+        .await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_operator_commit_timeout_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, .. } = build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    let watchtower_init_height =
+        enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        watchtower_init_height,
+        operator_commit_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+    let timeout = graph.operator_commit_timeout.tx().clone();
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-commit-timeout", &timeout)
+        .await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_pubin_disprove_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, assert_witness, .. } =
+        build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    let mut inconsistent_pubin = [0_u8; 96];
+    inconsistent_pubin[..32].fill(0x55);
+    inconsistent_pubin[32..64].copy_from_slice(&graph.parameters.pubin_disprove_constant);
+    let commit = build_operator_commit_pubin(
+        &esplora,
+        &rpc,
+        &mining_address,
+        &graph,
+        &keys,
+        &inconsistent_pubin,
+    )
+    .await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-commit-pubin", &commit)
+        .await?;
+
+    let operator_assert = build_operator_assert(&mut graph, &keys, &assert_witness)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-assert", &operator_assert)
+        .await?;
+    let (witness, _) =
+        validate_pubin_disprove(&graph, &commit.input[0], &operator_assert.input[0], &[])?
+            .context("inconsistent pubin was not disprovable")?;
+    let input = build_pubin_disprove_txin(&graph, witness)?;
+    let input_amount = graph
+        .operator_assert
+        .connector_d_input()
+        .map_err(|error| anyhow!("get connector-d input: {error}"))?
+        .amount;
+    let pubin_disprove = add_payer_input(
+        &esplora,
+        &rpc,
+        &mining_address,
+        &keys.verifier,
+        Transaction {
+            version: transaction::Version(2),
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![input],
+            output: vec![p2a_output()],
+        },
+        input_amount,
+    )
+    .await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "pubin-disprove", &pubin_disprove)
+        .await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_verifier_disprove_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, assert_witness, challenge_labels, .. } =
+        build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    let pubin = assert_wots_message(&assert_witness)?;
+    let commit =
+        build_operator_commit_pubin(&esplora, &rpc, &mining_address, &graph, &keys, &pubin).await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-commit-pubin", &commit)
+        .await?;
+    let operator_assert = build_operator_assert(&mut graph, &keys, &assert_witness)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-assert", &operator_assert)
+        .await?;
+
+    let verifier_assert =
+        build_verifier_assert(&graph, operator_assert.input[0].clone(), challenge_labels)?;
+    let verifier_assert_height =
+        broadcast_and_confirm(&esplora, &rpc, &mining_address, "verifier-assert", &verifier_assert)
+            .await?;
+    wait_timelock(
+        &esplora,
+        &rpc,
+        &mining_address,
+        verifier_assert_height,
+        disprove_timelock_blocks(Network::Regtest, &graph.parameters.timelock_config),
+    )
+    .await?;
+    let disprove = build_disprove_tx(&graph, 0, None)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "disprove", &disprove).await?;
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires local regtest Bitcoin Core and Esplora"]
+async fn regtest_wrongly_challenged_flow() -> Result<()> {
+    let esplora = esplora_client()?;
+    let rpc = RegtestRpc::from_env()?;
+    let RegtestGraph { mut graph, keys, assert_witness, challenge_labels, final_msg } =
+        build_regtest_graph(&esplora, &rpc).await?;
+    let mining_address = node_address(Network::Regtest, &keys.challenger);
+    enter_watchtower_phase(&esplora, &rpc, &mining_address, &mut graph, &keys).await?;
+
+    let pubin = assert_wots_message(&assert_witness)?;
+    let commit =
+        build_operator_commit_pubin(&esplora, &rpc, &mining_address, &graph, &keys, &pubin).await?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-commit-pubin", &commit)
+        .await?;
+    let operator_assert = build_operator_assert(&mut graph, &keys, &assert_witness)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "operator-assert", &operator_assert)
+        .await?;
+    let verifier_assert =
+        build_verifier_assert(&graph, operator_assert.input[0].clone(), challenge_labels)?;
+    broadcast_and_confirm(&esplora, &rpc, &mining_address, "verifier-assert", &verifier_assert)
+        .await?;
+
+    let (input, input_amount) = operator_sign_wrongly_challenged(&graph, 0, &final_msg)?;
+    let wrongly_challenged = add_payer_input(
+        &esplora,
+        &rpc,
+        &mining_address,
+        &keys.operator,
+        Transaction {
+            version: transaction::Version(2),
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![input],
+            output: vec![p2a_output()],
+        },
+        input_amount,
+    )
+    .await?;
+    broadcast_and_confirm(
+        &esplora,
+        &rpc,
+        &mining_address,
+        "wrongly-challenged",
+        &wrongly_challenged,
+    )
+    .await?;
+    Ok(())
+}
diff --git a/crates/client/src/goat_chain/chain_adaptor.rs b/crates/client/src/goat_chain/chain_adaptor.rs
index 3984b9be8..5a5d335a5 100644
--- a/crates/client/src/goat_chain/chain_adaptor.rs
+++ b/crates/client/src/goat_chain/chain_adaptor.rs
@@ -16,6 +16,7 @@ pub trait ChainAdaptor: Send + Sync {
     fn get_default_signer_address(&self) -> Address;
     async fn get_finalized_block_number(&self) -> anyhow::Result<i64>;
     async fn get_latest_block_number(&self) -> anyhow::Result<i64>;
+    async fn native_balance(&self, address: &[u8; 20]) -> anyhow::Result<U256>;
     async fn get_tx_receipt(&self, tx_hash: &str) -> anyhow::Result<Option<TransactionReceipt>>;
     async fn debug_trace_tx(
         &self,
diff --git a/crates/client/src/goat_chain/evmchain.rs b/crates/client/src/goat_chain/evmchain.rs
index 230542bc2..58293e76a 100644
--- a/crates/client/src/goat_chain/evmchain.rs
+++ b/crates/client/src/goat_chain/evmchain.rs
@@ -40,6 +40,10 @@ impl EvmChain {
         self.adaptor.get_latest_block_number().await
     }
 
+    pub async fn native_balance(&self, address: &[u8; 20]) -> anyhow::Result<U256> {
+        self.adaptor.native_balance(address).await
+    }
+
     pub async fn gateway_get_response_window_blocks(&self) -> anyhow::Result<u64> {
         self.adaptor.gateway_get_response_window_blocks().await
     }
diff --git a/crates/client/src/goat_chain/goat_adaptor.rs b/crates/client/src/goat_chain/goat_adaptor.rs
index 888808406..b4347ea7b 100644
--- a/crates/client/src/goat_chain/goat_adaptor.rs
+++ b/crates/client/src/goat_chain/goat_adaptor.rs
@@ -937,6 +937,10 @@ impl ChainAdaptor for GoatAdaptor {
         }
     }
 
+    async fn native_balance(&self, address: &[u8; 20]) -> anyhow::Result<U256> {
+        Ok(self.provider.get_balance(Address::from_slice(address)).await?)
+    }
+
     async fn get_tx_receipt(&self, tx_hash: &str) -> anyhow::Result<Option<TransactionReceipt>> {
         Ok(self.provider.get_transaction_receipt(TxHash::from_str(tx_hash)?).await?)
     }
diff --git a/crates/client/src/goat_chain/mock_goat_adaptor.rs b/crates/client/src/goat_chain/mock_goat_adaptor.rs
index e29a50ebc..4e4f62fe7 100644
--- a/crates/client/src/goat_chain/mock_goat_adaptor.rs
+++ b/crates/client/src/goat_chain/mock_goat_adaptor.rs
@@ -78,6 +78,10 @@ impl ChainAdaptor for MockAdaptor {
         }
     }
 
+    async fn native_balance(&self, _address: &[u8; 20]) -> anyhow::Result<U256> {
+        Ok(U256::ZERO)
+    }
+
     async fn get_tx_receipt(&self, tx_hash: &str) -> anyhow::Result<Option<TransactionReceipt>> {
         info!("call get_tx_receipt");
         Ok(if let Ok(tx_receipt) = self.tx_receipts.lock() {
diff --git a/crates/client/src/goat_chain/mod.rs b/crates/client/src/goat_chain/mod.rs
index c2a812f7c..5f1de66d0 100644
--- a/crates/client/src/goat_chain/mod.rs
+++ b/crates/client/src/goat_chain/mod.rs
@@ -129,6 +129,10 @@ impl GOATClient {
         self.chain_service.get_latest_block_number().await
     }
 
+    pub async fn native_balance(&self, address: &[u8; 20]) -> anyhow::Result<U256> {
+        self.chain_service.native_balance(address).await
+    }
+
     pub async fn gateway_get_response_window_blocks(&self) -> anyhow::Result<u64> {
         self.chain_service.gateway_get_response_window_blocks().await
     }
diff --git a/crates/store/src/localdb.rs b/crates/store/src/localdb.rs
index f08cc2992..f0b6ef3a3 100644
--- a/crates/store/src/localdb.rs
+++ b/crates/store/src/localdb.rs
@@ -1,7 +1,8 @@
 use crate::utils::{QueryBuilder, QueryParam, create_place_holders};
 use crate::{
-    BridgeOutGlobalStats, GoatTxRecord, Graph, GraphBtcTxVoutMonitor, GraphRawData, GraphStatus,
-    GraphStatusSource, GraphStatusTransitionOutcome, Instance, LongRunningTaskProof, Message, Node,
+    BridgeOutGlobalStats, EventWatchMetricsSnapshot, GoatTxRecord, Graph, GraphBtcTxVoutMonitor,
+    GraphRawData, GraphStatus, GraphStatusSource, GraphStatusTransitionOutcome, Instance,
+    LongRunningTaskProof, Message, MetricsStateCount, Node, NodeAlertMetricsSnapshot,
     NodesOverview, OperatorProof, PeginGraphProcessData, PeginInstanceProcessData,
     PendingGraphInit, SequencerSetHashChange, SequencerSetScanState, SerializableTxid,
     WatchContract, WatchtowerProof,
@@ -10,7 +11,7 @@ use crate::{
 use indexmap::IndexMap;
 use sqlx::migrate::Migrator;
 use sqlx::pool::PoolConnection;
-use sqlx::sqlite::SqliteRow;
+use sqlx::sqlite::{SqliteConnectOptions, SqliteJournalMode, SqliteRow};
 use sqlx::types::Uuid;
 use sqlx::{Row, Sqlite, SqliteConnection, SqlitePool, Transaction, migrate::MigrateDatabase};
 use std::str::FromStr;
@@ -82,7 +83,13 @@ impl LocalDB {
             tracing::info!("Database already exists");
         }
 
-        let conn = SqlitePool::connect(path).await.unwrap();
+        let mut options = SqliteConnectOptions::from_str(path).unwrap().create_if_missing(true);
+        if !is_mem {
+            // File-backed nodes run event watchers, P2P handlers, and maintenance tasks
+            // concurrently. WAL allows their readers to proceed while a short write commits.
+            options = options.journal_mode(SqliteJournalMode::Wal);
+        }
+        let conn = SqlitePool::connect_with(options).await.unwrap();
         Self { path: path.to_string(), is_mem, conn }
     }
 
@@ -854,6 +861,145 @@ impl<'a> StorageProcessor<'a> {
         }
     }
 
+    /// Returns grouped instance, graph, and message state counts for Node metrics.
+    pub async fn node_metrics_state_counts(&mut self) -> anyhow::Result<Vec<MetricsStateCount>> {
+        let counts = sqlx::query_as::<_, MetricsStateCount>(
+            r#"
+            SELECT
+                CASE WHEN is_bridge_in THEN 'instance_bridge_in' ELSE 'instance_bridge_out' END AS category,
+                status AS state,
+                COUNT(*) AS count,
+                MIN(created_at) AS oldest_created_at,
+                NULL AS last_success_at
+            FROM instance
+            GROUP BY is_bridge_in, status
+            UNION ALL
+            SELECT
+                'graph' AS category,
+                status AS state,
+                COUNT(*) AS count,
+                MIN(created_at) AS oldest_created_at,
+                NULL AS last_success_at
+            FROM graph
+            GROUP BY status
+            UNION ALL
+            SELECT
+                'message' AS category,
+                state,
+                COUNT(*) AS count,
+                MIN(created_at) AS oldest_created_at,
+                NULL AS last_success_at
+            FROM message
+            GROUP BY state
+            ORDER BY category, state
+            "#,
+        )
+        .fetch_all(self.conn())
+        .await?;
+        Ok(counts)
+    }
+
+    /// Returns local aggregate values for flow-stall and operator-liquidity alerts.
+    pub async fn node_alert_metrics_snapshot(
+        &mut self,
+        local_peer_id: &str,
+    ) -> anyhow::Result<NodeAlertMetricsSnapshot> {
+        let snapshot = sqlx::query_as::<_, NodeAlertMetricsSnapshot>(
+            r#"
+            SELECT
+                MIN(CASE
+                    WHEN is_bridge_in = 1
+                     AND status NOT IN (
+                        'RelayerL2Minted', 'PresignedFailed', 'RelayerL2MintedFailed',
+                        'Timeout', 'UserCanceled', 'NoEnoughCommitteesAnswered', 'UserDiscarded',
+                        'Failed', 'Success', 'Canceled'
+                     )
+                    THEN status_updated_at
+                END) AS pegin_oldest_active_status_updated_at,
+                MIN(CASE
+                    WHEN is_bridge_in = 1 AND status = 'UserInited'
+                    THEN status_updated_at
+                END) AS pegin_oldest_committee_wait_status_updated_at,
+                MIN(CASE
+                    WHEN is_bridge_in = 0 AND status NOT IN ('Claim', 'Timeout', 'Refund')
+                    THEN status_updated_at
+                END) AS pegout_oldest_active_status_updated_at,
+                (
+                    SELECT available_peg_btc
+                    FROM node
+                    WHERE peer_id = ? AND actor = 'Operator'
+                    LIMIT 1
+                ) AS operator_available_pegbtc
+            FROM instance
+            "#,
+        )
+        .bind(local_peer_id)
+        .fetch_one(self.conn())
+        .await?;
+        Ok(snapshot)
+    }
+
+    /// Returns aggregate local progress for the configured event watchers.
+    pub async fn event_watch_metrics_snapshot(
+        &mut self,
+        finalized_height: i64,
+    ) -> anyhow::Result<EventWatchMetricsSnapshot> {
+        Ok(sqlx::query_as::<_, EventWatchMetricsSnapshot>(
+            r#"
+            SELECT
+                COALESCE(MAX(MAX(? - from_height + 1, 0)), 0) AS lag_blocks,
+                COUNT(*) AS watcher_count,
+                COALESCE(SUM(CASE WHEN status IN ('UnSync', 'Syncing') THEN 1 ELSE 0 END), 0)
+                    AS syncing_count,
+                COALESCE(SUM(CASE WHEN status = 'Failed' THEN 1 ELSE 0 END), 0)
+                    AS failed_count
+            FROM watch_contract
+            WHERE from_height != 0
+            "#,
+        )
+        .bind(finalized_height)
+        .fetch_one(self.conn())
+        .await?)
+    }
+
+    /// Returns grouped proof task counts, ages, and latest success times for Proof Builder metrics.
+    pub async fn proof_metrics_state_counts(&mut self) -> anyhow::Result<Vec<MetricsStateCount>> {
+        let counts = sqlx::query_as::<_, MetricsStateCount>(
+            r#"
+            SELECT
+                chain_name AS category,
+                CAST(proof_state AS TEXT) AS state,
+                COUNT(*) AS count,
+                MIN(CASE WHEN proof_state IN (0, 1) THEN created_at END) AS oldest_created_at,
+                MAX(CASE WHEN proof_state = 2 THEN updated_at END) AS last_success_at
+            FROM long_running_task_proof
+            GROUP BY chain_name, proof_state
+            UNION ALL
+            SELECT
+                'operator' AS category,
+                CAST(proof_state AS TEXT) AS state,
+                COUNT(*) AS count,
+                MIN(CASE WHEN proof_state IN (0, 1) THEN created_at END) AS oldest_created_at,
+                MAX(CASE WHEN proof_state = 2 THEN updated_at END) AS last_success_at
+            FROM operator_proof
+            GROUP BY proof_state
+            UNION ALL
+            SELECT
+                'watchtower' AS category,
+                CAST(proof_state AS TEXT) AS state,
+                COUNT(*) AS count,
+                MIN(CASE WHEN proof_state IN (0, 1) THEN created_at END) AS oldest_created_at,
+                MAX(CASE WHEN proof_state = 2 THEN updated_at END) AS last_success_at
+            FROM watchtower_proof
+            GROUP BY proof_state
+            ORDER BY category, state
+            "#,
+        )
+        .fetch_all(self.conn())
+        .await?;
+        Ok(counts)
+    }
+
     /// Insert or update an instance
     ///
     /// Performs an INSERT OR REPLACE operation on the instance table.
@@ -3509,6 +3655,116 @@ mod tests {
         create_local_db("sqlite::memory:").await
     }
 
+    #[tokio::test]
+    async fn test_node_metrics_state_counts() {
+        let db = setup_db().await;
+        let mut s = db.acquire().await.unwrap();
+
+        sqlx::query(
+            "INSERT INTO instance (instance_id, is_bridge_in, status, created_at, updated_at) VALUES ('in-1', 1, 'Pending', 20, 20), ('in-2', 1, 'Pending', 10, 10), ('out-1', 0, 'Completed', 30, 30)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+        sqlx::query(
+            "INSERT INTO graph (graph_id, instance_id, status, created_at, updated_at) VALUES ('graph-1', 'in-1', 'Created', 40, 40), ('graph-2', 'in-2', 'Created', 25, 25)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+        sqlx::query(
+            "INSERT INTO message (message_id, business_id, actor, msg_type, content, state, created_at, updated_at) VALUES ('message-1', 'in-1', 'operator', 'test', X'00', 'Pending', 15, 15)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+
+        let counts = s.node_metrics_state_counts().await.unwrap();
+        assert_eq!(
+            counts.iter().find(|count| {
+                count.category == "instance_bridge_in" && count.state == "Pending"
+            }),
+            Some(&MetricsStateCount {
+                category: "instance_bridge_in".to_string(),
+                state: "Pending".to_string(),
+                count: 2,
+                oldest_created_at: Some(10),
+                last_success_at: None,
+            })
+        );
+        assert_eq!(
+            counts
+                .iter()
+                .find(|count| count.category == "graph" && count.state == "Created")
+                .unwrap()
+                .oldest_created_at,
+            Some(25)
+        );
+        assert_eq!(
+            counts
+                .iter()
+                .find(|count| count.category == "message" && count.state == "Pending")
+                .unwrap()
+                .count,
+            1
+        );
+    }
+
+    #[tokio::test]
+    async fn test_proof_metrics_state_counts() {
+        let db = setup_db().await;
+        let mut s = db.acquire().await.unwrap();
+
+        sqlx::query("DELETE FROM long_running_task_proof").execute(s.conn()).await.unwrap();
+
+        sqlx::query(
+            "INSERT INTO long_running_task_proof (block_start, block_end, chain_name, proof_state, created_at, updated_at) VALUES (0, 1, 'header-chain', 2, 40, 90), (1, 2, 'header-chain', 2, 20, 100), (2, 3, 'header-chain', 0, 10, 10)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+        sqlx::query(
+            "INSERT INTO operator_proof (instance_id, graph_id, execution_layer_block_number, operator_committed_blockhash, proof_state, created_at, updated_at) VALUES ('instance', 'graph', 0, 'hash', 2, 50, 80)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+        sqlx::query(
+            "INSERT INTO watchtower_proof (instance_id, graph_id, public_key, challenge_txid, challenge_init_txid, execution_layer_block_number, proof_state, created_at, updated_at) VALUES ('instance', 'graph', 'key', 'challenge', 'init', 0, 1, 60, 70)",
+        )
+        .execute(s.conn())
+        .await
+        .unwrap();
+
+        let counts = s.proof_metrics_state_counts().await.unwrap();
+        assert_eq!(
+            counts.iter().find(|count| count.category == "header-chain" && count.state == "2"),
+            Some(&MetricsStateCount {
+                category: "header-chain".to_string(),
+                state: "2".to_string(),
+                count: 2,
+                oldest_created_at: None,
+                last_success_at: Some(100),
+            })
+        );
+        assert_eq!(
+            counts
+                .iter()
+                .find(|count| count.category == "operator" && count.state == "2")
+                .unwrap()
+                .last_success_at,
+            Some(80)
+        );
+        assert_eq!(
+            counts
+                .iter()
+                .find(|count| count.category == "watchtower" && count.state == "1")
+                .unwrap()
+                .last_success_at,
+            None
+        );
+    }
+
     #[tokio::test]
     async fn test_upsert_and_find_latest_hash_change() {
         let db = setup_db().await;
diff --git a/crates/store/src/schema.rs b/crates/store/src/schema.rs
index baf08ef75..f9d990c5f 100644
--- a/crates/store/src/schema.rs
+++ b/crates/store/src/schema.rs
@@ -524,6 +524,34 @@ pub struct Message {
     pub created_at: i64,
 }
 
+#[derive(Clone, Debug, FromRow, PartialEq, Eq)]
+pub struct MetricsStateCount {
+    pub category: String,
+    pub state: String,
+    pub count: i64,
+    pub oldest_created_at: Option<i64>,
+    pub last_success_at: Option<i64>,
+}
+
+/// Aggregate, local-only values used for alerting. These values intentionally
+/// contain no business identifiers so they can be exported as Prometheus gauges.
+#[derive(Clone, FromRow, Debug, Default)]
+pub struct NodeAlertMetricsSnapshot {
+    pub pegin_oldest_active_status_updated_at: Option<i64>,
+    pub pegin_oldest_committee_wait_status_updated_at: Option<i64>,
+    pub pegout_oldest_active_status_updated_at: Option<i64>,
+    pub operator_available_pegbtc: Option<String>,
+}
+
+/// Aggregate event watcher progress used to expose a bounded health state.
+#[derive(Clone, FromRow, Debug, Default)]
+pub struct EventWatchMetricsSnapshot {
+    pub lag_blocks: i64,
+    pub watcher_count: i64,
+    pub syncing_count: i64,
+    pub failed_count: i64,
+}
+
 #[derive(Clone, FromRow, Debug, Serialize, Deserialize, Default)]
 pub struct PeginInstanceProcessData {
     pub instance_id: Uuid,
diff --git a/node/README.md b/node/README.md
index 4c897dc36..c5dbef5f5 100644
--- a/node/README.md
+++ b/node/README.md
@@ -872,7 +872,6 @@ real graph raw data in the database.
 | `ENABLE_RELAYER` | No | Enable relayer mode for Committee nodes | `false` |
 | `ENABLE_BABE_SETUP_STATE_CLEANUP` | No | Enable scheduled BABE setup state cleanup for Operator/Verifier nodes | `false` |
 | `BTC_CHAIN_URL` | No | Bitcoin Esplora API endpoint | Public Esplora |
-| `MARA_SLIPSTREAM_API_URL` | No | MARA slipstream API base URL (used for non-standard tx broadcast) | mainnet: `https://slipstream.mara.com/api`; testnet4: `https://teststream.mara.com/api` |
 | `GOAT_PROOF_BUILD_URL` | No | Proof Builder RPC endpoint | - |
 | `NODE_NAME` | No | Node display name | `ZKM` |
 | `OPERATOR_NODE_SERVICE_FEE` | No | Operator service fee rate | `0.001` |
diff --git a/node/src/action.rs b/node/src/action.rs
index bf0c13ee0..9bf50fabc 100644
--- a/node/src/action.rs
+++ b/node/src/action.rs
@@ -4,6 +4,7 @@
 
 use crate::env::get_local_node_info;
 use crate::handle::{HandlerContext, dispatch as handle_dispatch};
+use crate::metrics_service::MetricsState;
 use crate::middleware::AllBehaviours;
 use crate::rpc_service::current_time_secs;
 use crate::utils::*;
@@ -35,6 +36,7 @@ pub struct GOATMessage {
 }
 
 const GOAT_MESSAGE_BIN_PREFIX: &[u8] = b"GOATBIN1";
+const TRANSIENT_PEGIN_RETRY_DELAY_SECS: usize = 30;
 
 #[derive(Serialize, Deserialize, Clone)]
 pub enum GOATMessageContent {
@@ -127,6 +129,58 @@ impl GOATMessageContent {
             Self::Tick => "Tick",
         }
     }
+
+    fn pegin_retry_business_id(&self) -> Option<Uuid> {
+        match self {
+            Self::PeginRequest(message) => Some(message.instance_id),
+            Self::ConfirmInstance(message) => Some(message.instance_id),
+            Self::CreateGraph(message) => Some(message.graph_id),
+            Self::InitGraph(message) => Some(message.graph_id),
+            Self::GenCircuits(message) => Some(message.graph_id),
+            Self::CutCircuits(message) => Some(message.graph_id),
+            Self::SolderingProofReady(message) => Some(message.graph_id),
+            Self::VerifierGraphParamsEndorsement(message) => Some(message.graph_id),
+            Self::NonceGeneration(message) => Some(message.graph_id),
+            Self::CommitteePresign(message) => Some(message.graph_id),
+            Self::EndorseGraph(message) => Some(message.graph_id),
+            Self::GraphFinalize(message) => Some(message.graph_id),
+            Self::PeginConfirmNonce(message) => Some(message.instance_id),
+            Self::PeginConfirmPartialSig(message) => Some(message.instance_id),
+            Self::PostReady(message) => Some(message.instance_id),
+            _ => None,
+        }
+    }
+}
+
+fn is_retryable_sqlite_error(error: &anyhow::Error) -> bool {
+    error.chain().any(|cause| {
+        let message = cause.to_string().to_ascii_lowercase();
+        message.contains("database is locked")
+            || message.contains("database is busy")
+            || message.contains("sqlite_busy")
+    })
+}
+
+fn is_pegin_message_type(message_type: &str) -> bool {
+    matches!(
+        message_type,
+        "PeginRequest"
+            | "ConfirmInstance"
+            | "CreateGraph"
+            | "InitGraph"
+            | "GenCircuits"
+            | "CutCircuits"
+            | "SolderingProof"
+            | "SolderingProofReady"
+            | "VerifierGraphParamsEndorsement"
+            | "NonceGeneration"
+            | "CommitteePresign"
+            | "EndorseGraph"
+            | "GraphFinalize"
+            | "PeginConfirmNonce"
+            | "PeginConfirmPartialSig"
+            | "PostReady"
+    )
 }
 
 /// Pegin
@@ -436,6 +490,7 @@ pub async fn handle_self_p2p_msg(
     from_peer_id: PeerId,
     id: MessageId,
     message: &[u8],
+    metrics_state: &MetricsState,
 ) -> Result<()> {
     if id != GOATMessage::default_message_id() {
         tracing::warn!(
@@ -480,6 +535,8 @@ pub async fn handle_self_p2p_msg(
             from_peer_id,
             id.clone(),
             &message.content,
+            metrics_state,
+            false,
         )
         .await
         {
@@ -519,7 +576,14 @@ pub async fn handle_self_p2p_msg(
                 }
             }
             Err(err) => {
-                let lock_time = 600;
+                let lock_time: i64 = if is_retryable_sqlite_error(&err)
+                    && is_pegin_message_type(&message.msg_type)
+                {
+                    TRANSIENT_PEGIN_RETRY_DELAY_SECS as i64
+                } else {
+                    600
+                };
+                metrics_state.record_message_retry();
                 tracing::warn!(
                     event = "local_message_queue",
                     outcome = "deferred",
@@ -563,13 +627,29 @@ pub async fn recv_and_dispatch(
     from_peer_id: PeerId,
     id: MessageId,
     message: &[u8],
+    metrics_state: &MetricsState,
+    is_p2p_receive: bool,
 ) -> Result<()> {
-    if id != GOATMessage::default_message_id() {
+    let is_local_queue_message = id == GOATMessage::default_message_id();
+    if !is_local_queue_message {
         update_node_timestamp(local_db, &from_peer_id.to_string()).await?;
     }
     // Determine whether the message comes from this node itself to optionally skip validations
     let is_self_peer = get_local_node_info().peer_id == from_peer_id.to_string();
-    let message = GOATMessage::deserialize_message(message).await?;
+    let message = match GOATMessage::deserialize_message(message).await {
+        Ok(message) => {
+            if is_p2p_receive {
+                metrics_state.record_p2p_receive(true);
+            }
+            message
+        }
+        Err(error) => {
+            if is_p2p_receive {
+                metrics_state.record_p2p_receive(false);
+            }
+            return Err(error);
+        }
+    };
     let message_type = message.content.event_type();
     let role = actor.to_string();
     let from_peer_id_string = from_peer_id.to_string();
@@ -581,12 +661,48 @@ pub async fn recv_and_dispatch(
         goat_client,
         http_client,
         soldering_builder,
+        metrics_state,
         actor,
         from_peer_id,
         id,
         is_self_peer,
     };
-    let result = handle_dispatch(&mut handler_ctx, message.content()).await;
+    let result = match handle_dispatch(&mut handler_ctx, message.content()).await {
+        Err(error) if !is_local_queue_message && is_retryable_sqlite_error(&error) => {
+            if let Some(business_id) = message.content.pegin_retry_business_id() {
+                match push_local_unhandled_messages(
+                    local_db,
+                    business_id,
+                    &message,
+                    TRANSIENT_PEGIN_RETRY_DELAY_SECS,
+                )
+                .await
+                {
+                    Ok(()) => {
+                        tracing::warn!(
+                            event = "pegin_message_retry",
+                            outcome = "deferred",
+                            role = %role,
+                            message_type,
+                            business_id = %business_id,
+                            retry_after_secs = TRANSIENT_PEGIN_RETRY_DELAY_SECS,
+                            error = %error,
+                            "deferred pegin message after a transient SQLite failure"
+                        );
+                        Ok(())
+                    }
+                    Err(queue_error) => Err(error.context(format!(
+                        "failed to enqueue transient pegin message retry: {queue_error}"
+                    ))),
+                }
+            } else {
+                Err(error)
+            }
+        }
+        result => result,
+    };
+    metrics_state
+        .record_message_dispatch(message_type, if result.is_ok() { "success" } else { "failed" });
     match &result {
         Ok(()) => tracing::info!(
             event = "message_dispatch_result",
@@ -691,9 +807,25 @@ pub async fn send_to_peer(
     let message_type = message.content.event_type();
     let topic = crate::middleware::get_topic_name(&target_actor);
     let gossipsub_topic = gossipsub::IdentTopic::new(topic);
-    let serialized = message.serialize_message().await?;
+    let serialized = match message.serialize_message().await {
+        Ok(serialized) => serialized,
+        Err(error) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_p2p_publish(false);
+            }
+            return Err(error);
+        }
+    };
+    if serialized.len() > crate::middleware::behaviour::MAX_GOSSIPSUB_TRANSMIT_SIZE
+        && let Some(metrics_state) = crate::metrics_service::node_metrics_state()
+    {
+        metrics_state.record_p2p_oversized_message();
+    }
     match swarm.behaviour_mut().gossipsub.publish(gossipsub_topic, serialized) {
         Ok(message_id) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_p2p_publish(true);
+            }
             tracing::info!(
                 event = "p2p_message_publish",
                 outcome = "published",
@@ -705,6 +837,9 @@ pub async fn send_to_peer(
             Ok(message_id)
         }
         Err(err) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_p2p_publish(false);
+            }
             tracing::warn!(
                 event = "p2p_message_publish",
                 outcome = "failed",
@@ -738,7 +873,13 @@ pub async fn push_local_unhandled_messages(
         0,
         delay_secs as i64,
     )
-    .await
+    .await?;
+    if delay_secs > 0
+        && let Some(metrics_state) = crate::metrics_service::node_metrics_state()
+    {
+        metrics_state.record_message_retry();
+    }
+    Ok(())
 }
 
 /// Helper: try to get graph. If missing, send SyncGraphRequest and defer current handling.
diff --git a/node/src/bin/mock_rpc.rs b/node/src/bin/mock_rpc.rs
index e004d3613..105066264 100644
--- a/node/src/bin/mock_rpc.rs
+++ b/node/src/bin/mock_rpc.rs
@@ -15,6 +15,7 @@ use bitvm_noded::env::{
     ENV_BITCOIN_NETWORK, ENV_BITVM_SECRET, ENV_GOAT_ADDRESS, ENV_GOAT_GATEWAY_CONTRACT_ADDRESS,
     ENV_GOAT_NETWORK, ENV_GOAT_SWAP_CONTRACT_ADDRESS,
 };
+use bitvm_noded::metrics_service::MetricsState;
 use bitvm_noded::rpc_service::{self, AppState, current_time_secs};
 use bitvm_noded::utils::{generate_local_key, get_rand_btc_address_p2wpkh, get_rand_goat_address};
 use clap::Parser;
@@ -396,8 +397,13 @@ async fn main() -> Result<()> {
         seed_mock_data(&local_db, &peer_id, opts.actor.clone()).await.context("seed mock data")?;
 
     let registry = Arc::new(Mutex::new(Registry::default()));
-    let app_state =
-        AppState::create_arc_mock_app_state(local_db, opts.actor, peer_id, registry).await?;
+    let app_state = AppState::create_arc_mock_app_state(
+        local_db,
+        opts.actor,
+        peer_id,
+        MetricsState::new(registry),
+    )
+    .await?;
     let cancellation_token = CancellationToken::new();
     let shutdown_token = cancellation_token.clone();
     tokio::spawn(async move {
diff --git a/node/src/env.rs b/node/src/env.rs
index 072c7161a..fdf70c913 100644
--- a/node/src/env.rs
+++ b/node/src/env.rs
@@ -36,10 +36,6 @@ pub const ENV_ENABLE_RELAYER: &str = "ENABLE_RELAYER";
 pub const ENV_ENABLE_UPDATE_SPV_CONTRACT: &str = "ENABLE_UPDATE_SPV_CONTRACT";
 pub const ENV_ENABLE_BABE_SETUP_STATE_CLEANUP: &str = "ENABLE_BABE_SETUP_STATE_CLEANUP";
 pub const ENV_BTC_BLOCK_CONFIRMS: &str = "BTC_BLOCK_CONFIRMS";
-pub const ENV_MARA_SLIPSTREAM_API_URL: &str = "MARA_SLIPSTREAM_API_URL";
-pub const DEFAULT_MARA_SLIPSTREAM_MAINNET_API_URL: &str = "https://slipstream.mara.com/api";
-pub const DEFAULT_MARA_SLIPSTREAM_TESTNET4_API_URL: &str = "https://teststream.mara.com/api";
-
 pub const ENV_GOAT_PRIVATE_KEY: &str = "GOAT_PRIVATE_KEY";
 
 pub const ENV_GOAT_GATEWAY_EVENT_THE_GRAPH_URL: &str = "GOAT_GATEWAY_EVENT_THE_GRAPH_URL";
@@ -392,19 +388,6 @@ pub fn get_btc_url_from_env() -> Option<String> {
     std::env::var(ENV_BTC_CHAIN_URL).ok()
 }
 
-pub fn get_mara_slipstream_api_base_url(network: Network) -> String {
-    if let Ok(url) = std::env::var(ENV_MARA_SLIPSTREAM_API_URL)
-        && !url.trim().is_empty()
-    {
-        return url;
-    }
-
-    match network {
-        Network::Bitcoin => DEFAULT_MARA_SLIPSTREAM_MAINNET_API_URL.to_string(),
-        _ => DEFAULT_MARA_SLIPSTREAM_TESTNET4_API_URL.to_string(),
-    }
-}
-
 pub fn get_sequencer_set_monitor_start_cosmos_block_from_env() -> Option<u64> {
     std::env::var(ENV_SEQUENCER_SET_MONITOR_START_COSMOS_BLOCK)
         .ok()
diff --git a/node/src/handle.rs b/node/src/handle.rs
index 492f7b12a..042029e98 100644
--- a/node/src/handle.rs
+++ b/node/src/handle.rs
@@ -4,6 +4,7 @@ use crate::env::{
     get_soldering_proof_payload_store_path, is_relayer,
 };
 use crate::error::SpecialError;
+use crate::metrics_service::MetricsState;
 use crate::middleware::AllBehaviours;
 use crate::scheduled_tasks::graph_maintenance_tasks::ChallengeSubStatus;
 use crate::soldering_payload_store::{
@@ -50,6 +51,7 @@ pub struct HandlerContext<'a> {
     pub goat_client: &'a GOATClient,
     pub http_client: &'a HttpAsyncClient,
     pub soldering_builder: &'a Option<Arc<BabeBundleBuilder>>,
+    pub metrics_state: &'a MetricsState,
     pub actor: Actor,
     pub from_peer_id: PeerId,
     pub id: MessageId,
@@ -70,20 +72,6 @@ fn is_io_not_found_error(err: &anyhow::Error) -> bool {
     })
 }
 
-fn load_committee_instance_keypair(
-    committee_master_key: &CommitteeMasterKey,
-    instance_id: Uuid,
-) -> Result<bitcoin::key::Keypair> {
-    let envelope_path = committee_instance_keys_envelope_path(instance_id);
-    committee_master_key.load_instance_keypair(instance_id, &envelope_path).with_context(|| {
-        format!(
-            "load committee instance keypair failed for {} at {}",
-            instance_id,
-            envelope_path.display()
-        )
-    })
-}
-
 fn load_or_create_committee_instance_keypair(
     committee_master_key: &CommitteeMasterKey,
     instance_id: Uuid,
@@ -449,6 +437,7 @@ pub async fn dispatch(ctx: &mut HandlerContext<'_>, content: &GOATMessageContent
                 received_committee_pubkey,
                 pub_nonce,
                 nonce_sig,
+                content,
             )
             .await
         }
@@ -1803,7 +1792,10 @@ async fn handle_soldering_proof_ready_operator(
         payload_path = %payload_path,
         "read soldering proof payload from store, start processing"
     );
-    handle_soldering_proof_payload_operator(ctx, &soldering_proof_ready, &payload).await
+    let result =
+        handle_soldering_proof_payload_operator(ctx, &soldering_proof_ready, &payload).await;
+    ctx.metrics_state.record_pegin_graph_setup(result.is_ok());
+    result
 }
 
 fn decode_soldering_proof_payload(
@@ -1932,6 +1924,16 @@ async fn handle_compact_soldering_proof_operator(
     .await
     .context("real BABE setup verification task failed")??;
 
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "soldering_verified",
+        verifier_index,
+        verifier_pubkey = %verifier_pubkey,
+        finalized_instances = finalized.len(),
+        payload_hash = %hex::encode(soldering_proof_ready.payload_hash),
+        "verified verifier soldering proof"
+    );
+
     if finalized.len() != BABE_M_CC {
         bail!("each verifier must contribute exactly {BABE_M_CC} finalized BABE instances");
     }
@@ -1948,10 +1950,50 @@ async fn handle_compact_soldering_proof_operator(
         soldering_proof_ready.clone(),
     )?
     else {
-        save_babe_setup_state(ctx.local_db, instance_id, graph_id, &state)?;
+        let completed_slots = operator_state
+            .candidates
+            .iter()
+            .filter(|candidate| candidate.gc_data.is_some())
+            .count();
+        let expected_slots = operator_state.candidates.len();
+        if let Err(error) = save_babe_setup_state(ctx.local_db, instance_id, graph_id, &state) {
+            tracing::error!(
+                event = "operator_graph_creation",
+                outcome = "failed",
+                stage = "babe_state_persist",
+                verifier_index,
+                error = %error,
+                "failed to persist incomplete operator BABE setup state"
+            );
+            return Err(error).context("persist incomplete operator BABE setup state");
+        }
+        tracing::info!(
+            event = "operator_graph_creation",
+            outcome = "waiting_for_soldering",
+            verifier_index,
+            completed_slots,
+            expected_slots,
+            "persisted verifier soldering proof; waiting for remaining graph slots"
+        );
         return Ok(());
     };
-    save_babe_setup_state(ctx.local_db, instance_id, graph_id, &state)?;
+    if let Err(error) = save_babe_setup_state(ctx.local_db, instance_id, graph_id, &state) {
+        tracing::error!(
+            event = "operator_graph_creation",
+            outcome = "failed",
+            stage = "babe_state_persist",
+            verifier_index,
+            error = %error,
+            "failed to persist complete operator BABE setup state"
+        );
+        return Err(error).context("persist complete operator BABE setup state");
+    }
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "all_soldering_collected",
+        verifier_slots = bitvm_gc_circuit_datas.len(),
+        "all verifier soldering proofs are ready to build the graph"
+    );
 
     let instance_params = get_instance_parameters(ctx.local_db, instance_id)
         .await?
@@ -1991,14 +2033,107 @@ async fn handle_compact_soldering_proof_operator(
     operator_pre_sign(operator_master_key.master_keypair(), &mut graph)?;
 
     let graph = graph.to_simplified()?;
-    store_operator_presigned_graph(ctx.local_db, &graph).await?;
+    let definition_hash = hex::encode(graph.parameters_hash()?);
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "started",
+        stage = "definition_store",
+        graph_nonce,
+        definition_hash = %definition_hash,
+        "storing operator-pre-signed graph definition"
+    );
+    if let Err(error) = store_operator_presigned_graph(ctx.local_db, &graph).await {
+        tracing::error!(
+            event = "operator_graph_creation",
+            outcome = "failed",
+            stage = "definition_store",
+            graph_nonce,
+            definition_hash = %definition_hash,
+            error = %error,
+            "failed to store operator-pre-signed graph definition"
+        );
+        return Err(error).context("store operator-pre-signed graph definition");
+    }
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "committed",
+        stage = "definition_store",
+        graph_nonce,
+        definition_hash = %definition_hash,
+        "stored operator-pre-signed graph definition"
+    );
 
-    let mut storage = ctx.local_db.acquire().await?;
-    storage.delete_pending_graph_init(&instance_id, &local_operator_pubkey.to_string()).await?;
+    let mut storage = match ctx.local_db.acquire().await {
+        Ok(storage) => storage,
+        Err(error) => {
+            tracing::error!(
+                event = "operator_graph_creation",
+                outcome = "failed",
+                stage = "pending_session_delete",
+                graph_nonce,
+                definition_hash = %definition_hash,
+                error = %error,
+                "failed to acquire database connection to delete pending graph session"
+            );
+            return Err(error)
+                .context("acquire database connection to delete pending graph session");
+        }
+    };
+    let deleted_pending_sessions = match storage
+        .delete_pending_graph_init(&instance_id, &local_operator_pubkey.to_string())
+        .await
+    {
+        Ok(rows) => rows,
+        Err(error) => {
+            tracing::error!(
+                event = "operator_graph_creation",
+                outcome = "failed",
+                stage = "pending_session_delete",
+                graph_nonce,
+                definition_hash = %definition_hash,
+                error = %error,
+                "failed to delete pending graph session after definition persistence"
+            );
+            return Err(error).context("delete pending graph session after definition persistence");
+        }
+    };
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "completed",
+        stage = "pending_session_delete",
+        graph_nonce,
+        definition_hash = %definition_hash,
+        deleted_pending_sessions,
+        "deleted pending graph session after definition persistence"
+    );
 
     let message_content =
         GOATMessageContent::CreateGraph(CreateGraph { instance_id, graph_id, graph_nonce, graph });
-    send_to_peer(ctx.swarm, GOATMessage::new(Actor::All, message_content)).await?;
+    let message_id =
+        match send_to_peer(ctx.swarm, GOATMessage::new(Actor::All, message_content)).await {
+            Ok(message_id) => message_id,
+            Err(error) => {
+                tracing::error!(
+                    event = "operator_graph_creation",
+                    outcome = "failed",
+                    stage = "create_graph_publish",
+                    graph_nonce,
+                    definition_hash = %definition_hash,
+                    error = %error,
+                    "failed to publish CreateGraph"
+                );
+                return Err(error).context("publish CreateGraph");
+            }
+        };
+    tracing::info!(
+        event = "operator_graph_creation",
+        outcome = "published",
+        stage = "create_graph_publish",
+        graph_nonce,
+        definition_hash = %definition_hash,
+        message_id = ?message_id,
+        "published CreateGraph to the local gossipsub mesh"
+    );
 
     Ok(())
 }
@@ -2149,15 +2284,16 @@ async fn try_start_graph_committee_setup(
         );
         return Ok(());
     }
-    if let Err(e) = todo_funcs::validate_init_graph(
+    let validation = todo_funcs::validate_init_graph(
         ctx.local_db,
         ctx.btc_client,
         ctx.goat_client,
         graph,
         &verifier_endorsements,
     )
-    .await
-    {
+    .await;
+    ctx.metrics_state.record_graph_validation(validation.is_ok());
+    if let Err(e) = validation {
         if should_ignore_invalid_graph(&e, instance_id, graph_id, "CreateGraph", None) {
             return Ok(());
         }
@@ -2349,10 +2485,11 @@ async fn handle_create_graph_committee(
     }
 
     // 1. check graph data & operator stake without verifier params endorsements; those may arrive later.
-    if let Err(e) =
+    let validation =
         todo_funcs::validate_init_graph_base(ctx.local_db, ctx.btc_client, ctx.goat_client, graph)
-            .await
-    {
+            .await;
+    ctx.metrics_state.record_graph_validation(validation.is_ok());
+    if let Err(e) = validation {
         if should_ignore_invalid_graph(&e, instance_id, graph_id, "CreateGraph", None) {
             return Ok(());
         }
@@ -3026,15 +3163,16 @@ async fn handle_graph_finalize_committee(
 
     // received from Operator
     // 1. check graph data
-    if let Err(e) = todo_funcs::validate_finalized_graph(
+    let validation = todo_funcs::validate_finalized_graph(
         ctx.btc_client,
         ctx.goat_client,
         graph,
         endorse_sigs,
         params_endorse_sigs,
     )
-    .await
-    {
+    .await;
+    ctx.metrics_state.record_graph_validation(validation.is_ok());
+    if let Err(e) = validation {
         if should_ignore_invalid_graph(
             &e,
             instance_id,
@@ -3100,7 +3238,6 @@ async fn handle_graph_finalize_committee(
                 pub_nonce: pub_nonce.clone(),
                 nonce_sig,
             });
-            send_to_peer(ctx.swarm, GOATMessage::new(Actor::Committee, message_content)).await?;
             store_committee_pub_nonce_for_instance(
                 ctx.local_db,
                 instance_id,
@@ -3108,6 +3245,7 @@ async fn handle_graph_finalize_committee(
                 pub_nonce,
             )
             .await?;
+            send_to_peer(ctx.swarm, GOATMessage::new(Actor::Committee, message_content)).await?;
         }
     }
     // 4. (Relayer) try to call Gateway.postGraphData
@@ -3157,15 +3295,16 @@ async fn handle_graph_finalize_default(
 
     // received from Operator
     // 1. check graph data
-    if let Err(e) = todo_funcs::validate_finalized_graph(
+    let validation = todo_funcs::validate_finalized_graph(
         ctx.btc_client,
         ctx.goat_client,
         graph,
         endorse_sigs,
         params_endorse_sigs,
     )
-    .await
-    {
+    .await;
+    ctx.metrics_state.record_graph_validation(validation.is_ok());
+    if let Err(e) = validation {
         if should_ignore_invalid_graph(
             &e,
             instance_id,
@@ -3201,6 +3340,7 @@ async fn handle_pegin_confirm_nonce_committee(
     received_committee_pubkey: &PublicKey,
     pub_nonce: &musig2::PubNonce,
     nonce_sig: &secp256k1::schnorr::Signature,
+    content: &GOATMessageContent,
 ) -> Result<()> {
     // received from Committee members
     if !ensure_self_or_valid_committee(
@@ -3231,6 +3371,9 @@ async fn handle_pegin_confirm_nonce_committee(
         pub_nonce.clone(),
     )
     .await?;
+    if ctx.id == GOATMessage::default_message_id() {
+        send_to_peer(ctx.swarm, GOATMessage::new(Actor::Committee, content.clone())).await?;
+    }
     // 3. if received enough pub_nonces, generate partial signature & broadcast PeginConfirmPartialSig
     let committee_pubkeys = ctx.goat_client.gateway_get_committee_pubkeys(&instance_id).await?;
     let pub_nonces = get_committee_pub_nonces_for_instance(ctx.local_db, instance_id).await?;
@@ -3311,7 +3454,9 @@ async fn handle_pegin_confirm_nonce_committee(
                     })?;
                 let connector_z = instance_params.connector_z();
                 pegin_confirm.push_input_0_signature(&connector_z, full_sig);
-                broadcast_tx(ctx.btc_client, pegin_confirm.tx()).await?;
+                let result = broadcast_tx(ctx.btc_client, pegin_confirm.tx()).await;
+                ctx.metrics_state.record_pegin_confirm(result.is_ok());
+                result?;
             }
         }
     }
@@ -3416,8 +3561,9 @@ async fn handle_pegin_confirm_partial_sig_committee(
             return Ok(());
         }
         Err(e) => {
+            push_local_unhandled_messages(ctx.local_db, instance_id, &message, 30).await?;
             tracing::warn!(
-                "Ignore PeginConfirmPartialSig for {instance_id} from {}: failed to verify endorsement signature: {e}",
+                "Retry PeginConfirmPartialSig later for {instance_id} from {}: failed to verify endorsement signature: {e}",
                 received_committee_pubkey
             );
             return Ok(());
@@ -3438,6 +3584,9 @@ async fn handle_pegin_confirm_partial_sig_committee(
         endorse_sig.to_owned(),
     )
     .await?;
+    if ctx.id == GOATMessage::default_message_id() {
+        send_to_peer(ctx.swarm, GOATMessage::new(Actor::Committee, content.clone())).await?;
+    }
     // 3. (Relayer) if received enough partial signatures, aggregate the sigs
     if is_relayer() {
         let pub_nonces = get_committee_pub_nonces_for_instance(ctx.local_db, instance_id).await?;
@@ -3466,7 +3615,9 @@ async fn handle_pegin_confirm_partial_sig_committee(
                 })?;
             let connector_z = instance_params.connector_z();
             pegin_confirm.push_input_0_signature(&connector_z, full_sig);
-            broadcast_tx(ctx.btc_client, pegin_confirm.tx()).await?;
+            let result = broadcast_tx(ctx.btc_client, pegin_confirm.tx()).await;
+            ctx.metrics_state.record_pegin_confirm(result.is_ok());
+            result?;
         }
     }
     Ok(())
@@ -3493,8 +3644,20 @@ async fn handle_post_ready(ctx: &mut HandlerContext<'_>, instance_id: Uuid) -> R
         let pegin_tx = match ctx.btc_client.get_tx(&pegin_txid).await? {
             Some(tx) => tx,
             None => {
+                let delay_secs = todo_funcs::avg_block_time_secs(ctx.btc_client.network());
+                let message = GOATMessage::new(
+                    ctx.actor.clone(),
+                    GOATMessageContent::PostReady(PostReady { instance_id }),
+                );
+                push_local_unhandled_messages(
+                    ctx.local_db,
+                    instance_id,
+                    &message,
+                    delay_secs as usize,
+                )
+                .await?;
                 tracing::warn!(
-                    "Ignore PostReady for {instance_id}: Pegin-Confirm transaction not found on Bitcoin: {pegin_txid}"
+                    "Retry postPeginData later for {instance_id}: Pegin-Confirm transaction not found on Bitcoin: {pegin_txid}"
                 );
                 return Ok(());
             }
@@ -3505,8 +3668,15 @@ async fn handle_post_ready(ctx: &mut HandlerContext<'_>, instance_id: Uuid) -> R
             .map(|(_, es)| es)
             .collect::<Vec<_>>();
         if endorse_sigs.len() != committee_pubkeys.len() {
+            let delay_secs = todo_funcs::avg_block_time_secs(ctx.btc_client.network());
+            let message = GOATMessage::new(
+                ctx.actor.clone(),
+                GOATMessageContent::PostReady(PostReady { instance_id }),
+            );
+            push_local_unhandled_messages(ctx.local_db, instance_id, &message, delay_secs as usize)
+                .await?;
             tracing::warn!(
-                "Ignore PostReady for {instance_id}: not enough endorse sigs for pegin confirm tx: {}",
+                "Retry postPeginData later for {instance_id}: not enough endorse sigs for pegin confirm tx: {}",
                 endorse_sigs.len()
             );
             return Ok(());
@@ -3547,14 +3717,18 @@ async fn handle_post_ready(ctx: &mut HandlerContext<'_>, instance_id: Uuid) -> R
             );
             return Ok(());
         }
-        ctx.goat_client
+        let result = ctx
+            .goat_client
             .gateway_post_pegin_data(ctx.btc_client, &instance_id, &pegin_tx, &endorse_sigs)
-            .await?;
+            .await;
+        ctx.metrics_state.record_pegin_post(result.is_ok());
+        result?;
     } else {
         // already posted
     }
     // 2. (Relayer)call Gateway.postGraphData on GoatChain
     let graph_ids = get_graph_ids_for_instance(ctx.local_db, instance_id).await?;
+    let mut missing_graph_endorsements = false;
     for graph_id in &graph_ids {
         let graph_data = ctx.goat_client.gateway_get_graph_data(graph_id).await?;
         if graph_data.operator_pubkey != [0u8; 32] {
@@ -3568,8 +3742,9 @@ async fn handle_post_ready(ctx: &mut HandlerContext<'_>, instance_id: Uuid) -> R
                 .map(|(_, _, sig)| sig)
                 .collect::<Vec<_>>();
         if endorsement_sigs.len() != committee_pubkeys.len() {
+            missing_graph_endorsements = true;
             tracing::warn!(
-                "Ignore postGraphData for {instance_id}:{graph_id}: not enough endorse sigs for graph: {}",
+                "Defer postGraphData for {instance_id}:{graph_id}: not enough endorse sigs for graph: {}",
                 endorsement_sigs.len()
             );
             continue;
@@ -3583,6 +3758,18 @@ async fn handle_post_ready(ctx: &mut HandlerContext<'_>, instance_id: Uuid) -> R
             .gateway_post_graph_data(&instance_id, graph_id, &graph_data, &endorsement_sigs)
             .await?;
     }
+    if missing_graph_endorsements {
+        let delay_secs = todo_funcs::avg_block_time_secs(ctx.btc_client.network());
+        let message = GOATMessage::new(
+            ctx.actor.clone(),
+            GOATMessageContent::PostReady(PostReady { instance_id }),
+        );
+        push_local_unhandled_messages(ctx.local_db, instance_id, &message, delay_secs as usize)
+            .await?;
+        tracing::info!(
+            "Retry postGraphData later for {instance_id}: waiting for committee graph endorsements"
+        );
+    }
     Ok(())
 }
 
@@ -4841,7 +5028,8 @@ async fn handle_assert_sent_verifier(
             };
             match validate_pubin_disprove(&graph, commit_pubin_txin, assert_txin, &ack_txins) {
                 Ok(Some((witness_data, _))) => {
-                    // build pubin disprove Tx
+                    // PubinDisprove is not pre-signed, so fund it directly rather
+                    // than relying on CPFP.
                     let pubin_disprove_tx_total_input_amount = graph
                         .operator_assert
                         .connector_d_input()
@@ -4852,12 +5040,26 @@ async fn handle_assert_sent_verifier(
                         version: bitcoin::transaction::Version(2),
                         lock_time: bitcoin::absolute::LockTime::ZERO,
                         input: vec![pubin_disprove_txin],
-                        output: vec![goat::scripts::p2a_output()],
+                        output: vec![
+                            goat::scripts::p2a_output(),
+                            // Keep the transaction above Bitcoin Core's minimum
+                            // non-witness relay size.
+                            bitcoin::TxOut {
+                                value: Amount::ZERO,
+                                script_pubkey: goat::scripts::generate_opreturn_script(
+                                    PUBIN_DISPROVE_OP_RETURN_DATA.to_vec(),
+                                ),
+                            },
+                        ],
                     };
-                    broadcast_tx_with_cpfp(
+                    let verifier_keypair =
+                        VerifierMasterKey::new(get_bitvm_key()?).master_keypair();
+                    build_sign_and_broadcast_tx(
                         ctx.btc_client,
-                        pubin_disprove_tx,
+                        verifier_keypair,
+                        pubin_disprove_tx.input,
                         pubin_disprove_tx_total_input_amount,
+                        pubin_disprove_tx.output,
                     )
                     .await?;
                     return Ok(());
@@ -4915,6 +5117,8 @@ async fn handle_assert_sent_verifier(
     Ok(())
 }
 
+const PUBIN_DISPROVE_OP_RETURN_DATA: &[u8] = b"pubin-disprove";
+
 pub async fn broadcast_verifier_challenge_assert_tx(
     local_db: &LocalDB,
     btc_client: &BTCClient,
@@ -5356,7 +5560,8 @@ async fn handle_disprove_sent_committee(
         );
         return Ok(());
     }
-    ctx.goat_client
+    let result = ctx
+        .goat_client
         .gateway_finish_withdraw_disproved(
             ctx.btc_client,
             &graph_id,
@@ -5365,7 +5570,9 @@ async fn handle_disprove_sent_committee(
             challenge_start_tx.as_ref(),
             &challenge_finish_tx,
         )
-        .await?;
+        .await;
+    ctx.metrics_state.record_withdraw_finalize(result.is_ok());
+    result?;
     Ok(())
 }
 
@@ -5803,13 +6010,14 @@ async fn handle_sync_graph(
             "Failed to validate graph_id on GoatChain for SyncGraph {instance_id}:{graph_id}: {e}"
         )
     })?;
-    if let Err(e) = todo_funcs::validate_graph_instance_parameters(
+    let validation = todo_funcs::validate_graph_instance_parameters(
         ctx.btc_client,
         ctx.goat_client,
         &graph.parameters.instance_parameters,
     )
-    .await
-    {
+    .await;
+    ctx.metrics_state.record_graph_validation(validation.is_ok());
+    if let Err(e) = validation {
         tracing::warn!(
             "Ignore SyncGraph for {instance_id}:{graph_id}: invalid instance parameters: {e}"
         );
@@ -6177,4 +6385,29 @@ mod tests {
             tx.base_size()
         );
     }
+
+    #[test]
+    fn pubin_disprove_outputs_exceed_minimum_non_witness_size() {
+        // Bitcoin Core rejects standard transactions smaller than 65 non-witness bytes.
+        let tx = bitcoin::Transaction {
+            version: bitcoin::transaction::Version(2),
+            lock_time: bitcoin::absolute::LockTime::ZERO,
+            input: vec![bitcoin::TxIn::default()],
+            output: vec![
+                goat::scripts::p2a_output(),
+                bitcoin::TxOut {
+                    value: Amount::ZERO,
+                    script_pubkey: goat::scripts::generate_opreturn_script(
+                        PUBIN_DISPROVE_OP_RETURN_DATA.to_vec(),
+                    ),
+                },
+            ],
+        };
+
+        assert!(
+            tx.base_size() >= 65,
+            "pubin-disprove transaction is {} non-witness bytes",
+            tx.base_size()
+        );
+    }
 }
diff --git a/node/src/main.rs b/node/src/main.rs
index 1166376e1..baf336593 100644
--- a/node/src/main.rs
+++ b/node/src/main.rs
@@ -25,6 +25,7 @@ use bitvm_noded::{
 };
 
 use anyhow::Result;
+use bitvm_noded::metrics_service::{MetricsState, set_node_metrics_state};
 use bitvm_noded::middleware::swarm::{BitvmNetworkManager, BitvmSwarmConfig};
 use bitvm_noded::p2p_msg_handler::BitvmNodeProcessor;
 use client::http_client::async_client::HttpAsyncClient;
@@ -177,6 +178,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
     );
     let _node_span_guard = node_span.enter();
     let local_db = store::create_local_db(&opt.db_path).await;
+    let metric_registry = Arc::new(Mutex::new(metric_registry));
+    let metrics_state = MetricsState::new(metric_registry);
+    set_node_metrics_state(metrics_state.clone());
     let handler = BitvmNodeProcessor {
         local_db: local_db.clone(),
         btc_client: BTCClient::new(get_network(), get_btc_url_from_env().as_deref()),
@@ -184,6 +188,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         http_client: HttpAsyncClient::new(None),
         soldering_builder: matches!(actor, Actor::Verifier | Actor::Operator)
             .then(|| Arc::new(BabeBundleBuilder::new())),
+        metrics_state: metrics_state.clone(),
     };
 
     tracing::info!(
@@ -206,7 +211,6 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let local_db_clone4 = local_db.clone();
     let opt_rpc_addr = opt.rpc_addr.clone();
     let peer_id_string_clone = peer_id_string.clone();
-    let metric_registry_clone = Arc::new(Mutex::new(metric_registry));
 
     tracing::debug!("RPC service listening on {}", &opt.rpc_addr);
     if actor == Actor::Operator {
@@ -215,10 +219,12 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // validate node info
     check_node_info().await;
     save_local_info(&local_db).await;
+    metrics_state.mark_startup_ready();
 
     // Spawn RPC service task with cancellation support
     let cancel_token_clone = cancellation_token.clone();
     let rpc_task_span = node_span.clone();
+    let rpc_metrics = metrics_state.clone();
     task_handles.push(tokio::spawn(
         async move {
             match rpc_service::serve(
@@ -226,7 +232,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 local_db_clone1,
                 actor_clone1,
                 peer_id_string_clone,
-                metric_registry_clone,
+                rpc_metrics,
                 cancel_token_clone,
             )
             .await
@@ -252,6 +258,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // if actor == Actor::Committee || actor == Actor::Operator {
     let cancel_token_clone = cancellation_token.clone();
     let event_watcher_task_span = node_span.clone();
+    let event_watcher_metrics = metrics_state.clone();
     task_handles.push(tokio::spawn(
         async move {
             let goat_init_config = goat_config_from_env().await;
@@ -267,6 +274,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 5,
                 cancel_token_clone,
                 goat_init_config,
+                event_watcher_metrics,
             )
             .await
             {
@@ -319,6 +327,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let cancel_token_clone = cancellation_token.clone();
     let maintenance_task_span = node_span.clone();
+    let maintenance_metrics = metrics_state.clone();
     task_handles.push(tokio::spawn(
         async move {
             let goat_client =
@@ -332,6 +341,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 goat_client,
                 10,
                 cancel_token_clone,
+                maintenance_metrics,
             )
             .await
             {
diff --git a/node/src/metrics_service.rs b/node/src/metrics_service.rs
index 3daf4ea4c..f23fc75fd 100644
--- a/node/src/metrics_service.rs
+++ b/node/src/metrics_service.rs
@@ -1,143 +1,948 @@
-use std::{
-    net::SocketAddr,
-    sync::{Arc, Mutex},
-};
+use std::str::FromStr;
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Duration;
 
-use crate::rpc_service::AppState;
+use crate::rpc_service::{AppState, current_time_secs};
+use alloy::primitives::U256;
+use axum::extract::{MatchedPath, Request, State};
+use axum::http::{HeaderMap, StatusCode};
 use axum::middleware::Next;
-use axum::{
-    Router, extract::Request, extract::State, http::StatusCode, response::IntoResponse,
-    routing::get,
-};
-use http::HeaderMap;
+use axum::response::{IntoResponse, Response};
 use libp2p_metrics::Registry;
 use prometheus_client::encoding::text::encode;
 use prometheus_client::metrics::counter::Counter;
 use prometheus_client::metrics::family::Family;
+use prometheus_client::metrics::gauge::Gauge;
 use prometheus_client::metrics::histogram::{Histogram, exponential_buckets};
-use tokio::net::TcpListener;
+use store::{GraphStatus, InstanceBridgeInStatus, InstanceBridgeOutStatus, MessageState};
 use tokio::time::Instant;
 
 const METRICS_CONTENT_TYPE: &str = "application/openmetrics-text;charset=utf-8;version=1.0.0";
+const BTC_DECIMALS: u8 = 8;
+const UNKNOWN_TOKEN_DECIMALS: u8 = u8::MAX;
 
-#[allow(dead_code)]
-pub(crate) async fn metrics_server(registry: Registry) -> Result<(), std::io::Error> {
-    // Serve on localhost.
-    let addr: SocketAddr = ([127, 0, 0, 1], 0).into();
-    let service = MetricService::new(registry);
-    let server = Router::new().route("/metrics", get(respond_with_metrics)).with_state(service);
-    let tcp_listener = TcpListener::bind(addr).await?;
-    let local_addr = tcp_listener.local_addr()?;
-    tracing::info!(metrics_server=%format!("http://{local_addr}/metrics"));
-    axum::serve(tcp_listener, server.into_make_service()).await?;
-    Ok(())
+// Some queue and P2P helpers intentionally only receive their narrow runtime context.
+// A node process owns one registry, so this shared handle keeps those helpers observable.
+static NODE_METRICS_STATE: OnceLock<MetricsState> = OnceLock::new();
+
+pub fn set_node_metrics_state(metrics_state: MetricsState) {
+    let _ = NODE_METRICS_STATE.set(metrics_state);
 }
 
-#[derive(Clone)]
-#[allow(dead_code)]
-pub(crate) struct MetricService {
-    reg: Arc<Mutex<Registry>>,
+pub fn node_metrics_state() -> Option<&'static MetricsState> {
+    NODE_METRICS_STATE.get()
 }
 
-async fn respond_with_metrics(state: State<MetricService>) -> impl IntoResponse {
-    let mut sink = String::new();
-    let reg = state.get_reg();
-    encode(&mut sink, &reg.lock().unwrap()).unwrap();
-    (StatusCode::OK, [(axum::http::header::CONTENT_TYPE, METRICS_CONTENT_TYPE)], sink)
+/// Creates a duration histogram using the shared HTTP and task latency buckets.
+fn duration_histogram() -> Histogram {
+    Histogram::new(exponential_buckets(0.005, 2.0, 15))
 }
 
-type SharedRegistry = Arc<Mutex<Registry>>;
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct HttpRequestLabels {
+    method: String,
+    route: String,
+    status: u16,
+}
 
-impl MetricService {
-    #[allow(dead_code)]
-    fn new(registry: Registry) -> Self {
-        Self { reg: Arc::new(Mutex::new(registry)) }
-    }
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct HttpRouteLabels {
+    method: String,
+    route: String,
+}
 
-    #[allow(dead_code)]
-    fn get_reg(&self) -> SharedRegistry {
-        Arc::clone(&self.reg)
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct TaskOutcomeLabels {
+    task: String,
+    outcome: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct TaskLabels {
+    task: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct MessageDispatchLabels {
+    message_type: String,
+    outcome: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct OutcomeLabels {
+    outcome: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct EventWatchStateLabels {
+    state: String,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum EventWatchState {
+    Healthy,
+    Syncing,
+    Failed,
+}
+
+impl EventWatchState {
+    const ALL: [Self; 3] = [Self::Healthy, Self::Syncing, Self::Failed];
+
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Healthy => "healthy",
+            Self::Syncing => "syncing",
+            Self::Failed => "failed",
+        }
     }
 }
 
+#[derive(Debug, Default)]
+struct ReadinessState {
+    startup_ready: AtomicBool,
+    database_ready: AtomicBool,
+    backend_ready: AtomicBool,
+    event_watcher_ready: AtomicBool,
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
-struct HttpRequestLabels {
-    method: String,
-    path: String,
-    status: u16,
+struct InstanceLabels {
+    flow: String,
+    status: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct StatusLabels {
+    status: String,
 }
 
 #[derive(Clone, Debug)]
 pub struct MetricsState {
     pub registry: Arc<Mutex<Registry>>,
     http_requests_total: Family<HttpRequestLabels, Counter>,
-    http_request_duration_seconds: Histogram,
-    http_requests_in_flight: prometheus_client::metrics::gauge::Gauge,
+    http_request_duration_seconds: Family<HttpRouteLabels, Histogram>,
+    http_requests_in_flight: Gauge,
+    task_runs_total: Family<TaskOutcomeLabels, Counter>,
+    task_duration_seconds: Family<TaskLabels, Histogram>,
+    task_last_success_timestamp_seconds: Family<TaskLabels, Gauge>,
+    message_dispatch_total: Family<MessageDispatchLabels, Counter>,
+    instances: Family<InstanceLabels, Gauge>,
+    graphs: Family<StatusLabels, Gauge>,
+    messages: Family<StatusLabels, Gauge>,
+    oldest_pending_message_age_seconds: Gauge,
+    ready: Gauge,
+    db_busy_retries_total: Counter,
+    db_errors_total: Counter,
+    pegin_oldest_active_age_seconds: Gauge,
+    pegin_oldest_committee_wait_age_seconds: Gauge,
+    pegout_oldest_active_age_seconds: Gauge,
+    operator_available_pegbtc_sats: Gauge,
+    fee_wallet_balance_sats: Gauge,
+    fee_wallet_spendable_utxos: Gauge,
+    graph_validation_total: Family<OutcomeLabels, Counter>,
+    message_retry_total: Counter,
+    p2p_publish_total: Family<OutcomeLabels, Counter>,
+    p2p_receive_total: Family<OutcomeLabels, Counter>,
+    p2p_oversized_messages_total: Counter,
+    btc_backend_requests_total: Family<OutcomeLabels, Counter>,
+    btc_backend_last_success_timestamp_seconds: Gauge,
+    goat_backend_requests_total: Family<OutcomeLabels, Counter>,
+    goat_backend_last_success_timestamp_seconds: Gauge,
+    spv_lag_blocks: Gauge,
+    event_watch_ready: Gauge,
+    event_watch_state: Family<EventWatchStateLabels, Gauge>,
+    event_watch_last_success_timestamp_seconds: Gauge,
+    pegin_graph_setup_total: Family<OutcomeLabels, Counter>,
+    pegin_confirm_total: Family<OutcomeLabels, Counter>,
+    pegin_post_total: Family<OutcomeLabels, Counter>,
+    pegout_disprove_total: Counter,
+    withdraw_finalize_total: Family<OutcomeLabels, Counter>,
+    goat_gas_balance_wei: Gauge,
+    required_stake_sufficient: Gauge,
+    soldering_payload_io_total: Family<OutcomeLabels, Counter>,
+    btc_tx_broadcast_total: Family<OutcomeLabels, Counter>,
+    event_watch_lag_blocks: Gauge,
+    readiness: Arc<ReadinessState>,
+    peg_btc_decimals: Arc<AtomicU8>,
+}
+
+struct InFlightGuard(Gauge);
+
+impl Drop for InFlightGuard {
+    /// Decrements the in-flight request gauge when request processing ends or is cancelled.
+    fn drop(&mut self) {
+        self.0.dec();
+    }
 }
 
 impl MetricsState {
     pub fn new(registry: Arc<Mutex<Registry>>) -> Self {
         let http_requests_total = Family::default();
-        registry.lock().unwrap().register(
-            "http_requests_total",
-            "Total number of requests",
-            http_requests_total.clone(),
-        );
+        let http_request_duration_seconds: Family<HttpRouteLabels, Histogram> =
+            Family::new_with_constructor(duration_histogram);
+        let http_requests_in_flight = Gauge::default();
+        let task_runs_total = Family::default();
+        let task_duration_seconds: Family<TaskLabels, Histogram> =
+            Family::new_with_constructor(duration_histogram);
+        let task_last_success_timestamp_seconds = Family::default();
+        let message_dispatch_total = Family::default();
+        let instances = Family::default();
+        let graphs = Family::default();
+        let messages = Family::default();
+        let oldest_pending_message_age_seconds = Gauge::default();
+        let ready = Gauge::default();
+        let db_busy_retries_total = Counter::default();
+        let db_errors_total = Counter::default();
+        let pegin_oldest_active_age_seconds = Gauge::default();
+        let pegin_oldest_committee_wait_age_seconds = Gauge::default();
+        let pegout_oldest_active_age_seconds = Gauge::default();
+        let operator_available_pegbtc_sats = Gauge::default();
+        let fee_wallet_balance_sats = Gauge::default();
+        let fee_wallet_spendable_utxos = Gauge::default();
+        let graph_validation_total = Family::default();
+        let message_retry_total = Counter::default();
+        let p2p_publish_total = Family::default();
+        let p2p_receive_total = Family::default();
+        let p2p_oversized_messages_total = Counter::default();
+        let btc_backend_requests_total = Family::default();
+        let btc_backend_last_success_timestamp_seconds = Gauge::default();
+        let goat_backend_requests_total = Family::default();
+        let goat_backend_last_success_timestamp_seconds = Gauge::default();
+        let spv_lag_blocks = Gauge::default();
+        let event_watch_ready = Gauge::default();
+        let event_watch_state: Family<EventWatchStateLabels, Gauge> = Family::default();
+        for state in EventWatchState::ALL {
+            event_watch_state
+                .get_or_create(&EventWatchStateLabels { state: state.as_str().to_owned() })
+                .set(0);
+        }
+        let event_watch_last_success_timestamp_seconds = Gauge::default();
+        let pegin_graph_setup_total = Family::default();
+        let pegin_confirm_total = Family::default();
+        let pegin_post_total = Family::default();
+        let pegout_disprove_total = Counter::default();
+        let withdraw_finalize_total = Family::default();
+        let goat_gas_balance_wei = Gauge::default();
+        let required_stake_sufficient = Gauge::default();
+        let soldering_payload_io_total = Family::default();
+        let btc_tx_broadcast_total = Family::default();
+        let event_watch_lag_blocks = Gauge::default();
+        let readiness = Arc::new(ReadinessState::default());
+        let peg_btc_decimals = Arc::new(AtomicU8::new(UNKNOWN_TOKEN_DECIMALS));
 
-        let http_request_duration_seconds = Histogram::new(exponential_buckets(1.01, 2.0, 10));
-        registry.lock().unwrap().register(
-            "http_request_duration_seconds",
-            "HTTP request duration in seconds",
-            http_request_duration_seconds.clone(),
-        );
-        let http_requests_in_flight = prometheus_client::metrics::gauge::Gauge::default();
-        registry.lock().unwrap().register(
-            "http_requests_in_flight",
-            "Number of HTTP requests currently being processed",
-            http_requests_in_flight.clone(),
-        );
+        {
+            let mut registry = registry.lock().unwrap();
+            registry.register(
+                "http_requests",
+                "Total number of HTTP requests",
+                http_requests_total.clone(),
+            );
+            registry.register(
+                "http_request_duration_seconds",
+                "HTTP request duration in seconds",
+                http_request_duration_seconds.clone(),
+            );
+            registry.register(
+                "http_requests_in_flight",
+                "Number of HTTP requests currently being processed",
+                http_requests_in_flight.clone(),
+            );
+            registry.register(
+                "bitvm_node_task_runs",
+                "Total number of node task runs",
+                task_runs_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_task_duration_seconds",
+                "Node task duration in seconds",
+                task_duration_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_task_last_success_timestamp_seconds",
+                "Unix timestamp of the last successful node task run",
+                task_last_success_timestamp_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_message_dispatch",
+                "Total number of protocol message dispatches",
+                message_dispatch_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_instances",
+                "Number of bridge instances by flow and status",
+                instances.clone(),
+            );
+            registry.register("bitvm_node_graphs", "Number of graphs by status", graphs.clone());
+            registry.register(
+                "bitvm_node_messages",
+                "Number of queued messages by state",
+                messages.clone(),
+            );
+            registry.register(
+                "bitvm_node_oldest_pending_message_age_seconds",
+                "Age in seconds of the oldest pending message",
+                oldest_pending_message_age_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_ready",
+                "Whether the node is ready to process work",
+                ready.clone(),
+            );
+            registry.register(
+                "bitvm_node_db_busy_retries",
+                "Total SQLite busy or locked retries",
+                db_busy_retries_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_db_errors",
+                "Total non-retryable database metric collection errors",
+                db_errors_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegin_oldest_active_age_seconds",
+                "Age of the oldest active Pegin",
+                pegin_oldest_active_age_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegin_oldest_committee_wait_age_seconds",
+                "Age of the oldest Pegin waiting for committee responses",
+                pegin_oldest_committee_wait_age_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegout_oldest_active_age_seconds",
+                "Age of the oldest active Pegout",
+                pegout_oldest_active_age_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_operator_available_pegbtc_sats",
+                "Locally recorded operator available pBTC in sats",
+                operator_available_pegbtc_sats.clone(),
+            );
+            registry.register(
+                "bitvm_node_fee_wallet_balance_sats",
+                "Current node fee wallet balance in sats",
+                fee_wallet_balance_sats.clone(),
+            );
+            registry.register(
+                "bitvm_node_fee_wallet_spendable_utxos",
+                "Current node fee wallet spendable UTXO count",
+                fee_wallet_spendable_utxos.clone(),
+            );
+            registry.register(
+                "bitvm_node_graph_validation",
+                "Total graph validation outcomes",
+                graph_validation_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_message_retry",
+                "Total deferred protocol messages",
+                message_retry_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_p2p_publish",
+                "Total P2P message publish outcomes",
+                p2p_publish_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_p2p_receive",
+                "Total P2P message parse outcomes",
+                p2p_receive_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_p2p_oversized_messages",
+                "Total P2P messages exceeding the configured transmit limit",
+                p2p_oversized_messages_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_btc_backend_requests",
+                "Total BTC backend health probe outcomes",
+                btc_backend_requests_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_btc_backend_last_success_timestamp_seconds",
+                "Unix timestamp of the last successful BTC backend health probe",
+                btc_backend_last_success_timestamp_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_goat_backend_requests",
+                "Total Goat backend health probe outcomes",
+                goat_backend_requests_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_goat_backend_last_success_timestamp_seconds",
+                "Unix timestamp of the last successful Goat backend health probe",
+                goat_backend_last_success_timestamp_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_spv_lag_blocks",
+                "BTC tip minus Goat SPV height",
+                spv_lag_blocks.clone(),
+            );
+            registry.register(
+                "bitvm_node_event_watch_ready",
+                "Compatibility gauge that is one only when every event watcher is healthy",
+                event_watch_ready.clone(),
+            );
+            registry.register(
+                "bitvm_node_event_watch_state",
+                "Current event watcher state; exactly one of healthy, syncing, or failed is one",
+                event_watch_state.clone(),
+            );
+            registry.register(
+                "bitvm_node_event_watch_last_success_timestamp_seconds",
+                "Unix timestamp of the last successful event watcher run",
+                event_watch_last_success_timestamp_seconds.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegin_graph_setup",
+                "Total Pegin graph setup outcomes",
+                pegin_graph_setup_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegin_confirm",
+                "Total PeginConfirm broadcast outcomes",
+                pegin_confirm_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegin_post",
+                "Total postPeginData outcomes",
+                pegin_post_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_pegout_disprove",
+                "Total confirmed Disprove terminal events",
+                pegout_disprove_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_withdraw_finalize",
+                "Total relayer withdraw finalize outcomes",
+                withdraw_finalize_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_goat_gas_balance_wei",
+                "Current Goat native gas balance in wei",
+                goat_gas_balance_wei.clone(),
+            );
+            registry.register(
+                "bitvm_node_required_stake_sufficient",
+                "Whether the local role satisfies the required stake",
+                required_stake_sufficient.clone(),
+            );
+            registry.register(
+                "bitvm_node_soldering_payload_io",
+                "Total soldering payload read and write outcomes",
+                soldering_payload_io_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_btc_tx_broadcast",
+                "Total Bitcoin transaction broadcast outcomes",
+                btc_tx_broadcast_total.clone(),
+            );
+            registry.register(
+                "bitvm_node_event_watch_lag_blocks",
+                "Maximum event watcher lag in finalized Goat blocks",
+                event_watch_lag_blocks.clone(),
+            );
+        }
 
         Self {
             registry,
-            // registry: Arc::new(registry),
             http_requests_total,
             http_request_duration_seconds,
             http_requests_in_flight,
+            task_runs_total,
+            task_duration_seconds,
+            task_last_success_timestamp_seconds,
+            message_dispatch_total,
+            instances,
+            graphs,
+            messages,
+            oldest_pending_message_age_seconds,
+            ready,
+            db_busy_retries_total,
+            db_errors_total,
+            pegin_oldest_active_age_seconds,
+            pegin_oldest_committee_wait_age_seconds,
+            pegout_oldest_active_age_seconds,
+            operator_available_pegbtc_sats,
+            fee_wallet_balance_sats,
+            fee_wallet_spendable_utxos,
+            graph_validation_total,
+            message_retry_total,
+            p2p_publish_total,
+            p2p_receive_total,
+            p2p_oversized_messages_total,
+            btc_backend_requests_total,
+            btc_backend_last_success_timestamp_seconds,
+            goat_backend_requests_total,
+            goat_backend_last_success_timestamp_seconds,
+            spv_lag_blocks,
+            event_watch_ready,
+            event_watch_state,
+            event_watch_last_success_timestamp_seconds,
+            pegin_graph_setup_total,
+            pegin_confirm_total,
+            pegin_post_total,
+            pegout_disprove_total,
+            withdraw_finalize_total,
+            goat_gas_balance_wei,
+            required_stake_sufficient,
+            soldering_payload_io_total,
+            btc_tx_broadcast_total,
+            event_watch_lag_blocks,
+            readiness,
+            peg_btc_decimals,
+        }
+    }
+
+    /// Records a task outcome and duration, updating its success timestamp when applicable.
+    pub fn record_task_run(&self, task: &str, outcome: &str, duration: Duration) {
+        self.task_runs_total
+            .get_or_create(&TaskOutcomeLabels {
+                task: task.to_owned(),
+                outcome: outcome.to_owned(),
+            })
+            .inc();
+        self.task_duration_seconds
+            .get_or_create(&TaskLabels { task: task.to_owned() })
+            .observe(duration.as_secs_f64());
+        if outcome == "success" {
+            self.task_last_success_timestamp_seconds
+                .get_or_create(&TaskLabels { task: task.to_owned() })
+                .set(current_time_secs());
+            if task == "event_watcher" {
+                self.event_watch_last_success_timestamp_seconds.set(current_time_secs());
+            }
+        }
+    }
+
+    /// Records the outcome of dispatching a decoded protocol message.
+    pub fn record_message_dispatch(&self, message_type: &str, outcome: &str) {
+        self.message_dispatch_total
+            .get_or_create(&MessageDispatchLabels {
+                message_type: message_type.to_owned(),
+                outcome: outcome.to_owned(),
+            })
+            .inc();
+    }
+
+    pub fn mark_startup_ready(&self) {
+        self.readiness.startup_ready.store(true, Ordering::Relaxed);
+        self.refresh_ready();
+    }
+
+    pub fn mark_database_ready(&self, ready: bool) {
+        self.readiness.database_ready.store(ready, Ordering::Relaxed);
+        self.refresh_ready();
+    }
+
+    pub fn mark_backend_ready(&self, ready: bool) {
+        self.readiness.backend_ready.store(ready, Ordering::Relaxed);
+        self.refresh_ready();
+    }
+
+    pub fn set_event_watch_state(&self, state: EventWatchState) {
+        for candidate in EventWatchState::ALL {
+            self.event_watch_state
+                .get_or_create(&EventWatchStateLabels { state: candidate.as_str().to_owned() })
+                .set(i64::from(candidate == state));
+        }
+
+        let healthy = state == EventWatchState::Healthy;
+        self.readiness.event_watcher_ready.store(healthy, Ordering::Relaxed);
+        self.event_watch_ready.set(i64::from(healthy));
+        self.refresh_ready();
+    }
+
+    fn refresh_ready(&self) {
+        let ready = self.readiness.startup_ready.load(Ordering::Relaxed)
+            && self.readiness.database_ready.load(Ordering::Relaxed)
+            && self.readiness.backend_ready.load(Ordering::Relaxed)
+            && self.readiness.event_watcher_ready.load(Ordering::Relaxed);
+        self.ready.set(i64::from(ready));
+    }
+
+    pub fn record_db_error(&self, error: &anyhow::Error) {
+        if error.to_string().contains("database is locked")
+            || error.to_string().contains("database is busy")
+        {
+            self.db_busy_retries_total.inc();
+        } else {
+            self.db_errors_total.inc();
+        }
+    }
+
+    pub fn record_graph_validation(&self, success: bool) {
+        self.graph_validation_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+    }
+
+    pub fn record_message_retry(&self) {
+        self.message_retry_total.inc();
+    }
+
+    pub fn record_p2p_publish(&self, success: bool) {
+        self.p2p_publish_total.get_or_create(&OutcomeLabels { outcome: outcome(success) }).inc();
+    }
+
+    pub fn record_p2p_receive(&self, success: bool) {
+        self.p2p_receive_total.get_or_create(&OutcomeLabels { outcome: outcome(success) }).inc();
+    }
+
+    pub fn record_p2p_oversized_message(&self) {
+        self.p2p_oversized_messages_total.inc();
+    }
+
+    pub fn record_btc_backend_probe(&self, success: bool) {
+        self.btc_backend_requests_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+        if success {
+            self.btc_backend_last_success_timestamp_seconds.set(current_time_secs());
+        }
+    }
+
+    pub fn record_goat_backend_probe(&self, success: bool) {
+        self.goat_backend_requests_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+        if success {
+            self.goat_backend_last_success_timestamp_seconds.set(current_time_secs());
         }
     }
+
+    pub fn set_peg_btc_decimals(&self, decimals: u8) {
+        self.peg_btc_decimals.store(decimals, Ordering::Relaxed);
+    }
+
+    pub fn record_pegin_graph_setup(&self, success: bool) {
+        self.pegin_graph_setup_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+    }
+
+    pub fn record_pegin_confirm(&self, success: bool) {
+        self.pegin_confirm_total.get_or_create(&OutcomeLabels { outcome: outcome(success) }).inc();
+    }
+
+    pub fn record_pegin_post(&self, success: bool) {
+        self.pegin_post_total.get_or_create(&OutcomeLabels { outcome: outcome(success) }).inc();
+    }
+
+    pub fn record_pegout_disprove(&self) {
+        self.pegout_disprove_total.inc();
+    }
+
+    pub fn record_withdraw_finalize(&self, success: bool) {
+        self.withdraw_finalize_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+    }
+
+    pub fn apply_goat_gas_balance(&self, balance_wei: U256) {
+        self.goat_gas_balance_wei.set(u256_to_gauge(balance_wei));
+    }
+
+    pub fn apply_required_stake(&self, sufficient: bool) {
+        self.required_stake_sufficient.set(i64::from(sufficient));
+    }
+
+    pub fn record_soldering_payload_io(&self, success: bool) {
+        self.soldering_payload_io_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+    }
+
+    pub fn record_btc_tx_broadcast(&self, success: bool) {
+        self.btc_tx_broadcast_total
+            .get_or_create(&OutcomeLabels { outcome: outcome(success) })
+            .inc();
+    }
+
+    pub fn apply_event_watch_lag(&self, lag_blocks: i64) {
+        self.event_watch_lag_blocks.set(lag_blocks.max(0));
+    }
+
+    pub fn apply_chain_health(&self, btc_height: Option<u32>, goat_spv_height: Option<u64>) {
+        if let (Some(btc_height), Some(goat_spv_height)) = (btc_height, goat_spv_height) {
+            self.spv_lag_blocks.set(
+                i64::try_from(u64::from(btc_height).saturating_sub(goat_spv_height))
+                    .unwrap_or(i64::MAX),
+            );
+        }
+    }
+
+    pub fn apply_fee_wallet(&self, balance_sats: i64, utxos: i64) {
+        self.fee_wallet_balance_sats.set(balance_sats);
+        self.fee_wallet_spendable_utxos.set(utxos);
+    }
+
+    /// Replaces the exported database gauges with the latest grouped state counts.
+    fn apply_database_metrics(&self, counts: &[store::MetricsStateCount]) {
+        self.instances.clear();
+        self.graphs.clear();
+        self.messages.clear();
+        self.oldest_pending_message_age_seconds.set(0);
+        let now = current_time_secs();
+
+        for count in counts {
+            match count.category.as_str() {
+                "instance_bridge_in" => {
+                    let status = known_status::<InstanceBridgeInStatus>(&count.state);
+                    self.instances
+                        .get_or_create(&InstanceLabels { flow: "bridge_in".to_string(), status })
+                        .inc_by(count.count);
+                }
+                "instance_bridge_out" => {
+                    let status = known_status::<InstanceBridgeOutStatus>(&count.state);
+                    self.instances
+                        .get_or_create(&InstanceLabels { flow: "bridge_out".to_string(), status })
+                        .inc_by(count.count);
+                }
+                "graph" => {
+                    let status = known_status::<GraphStatus>(&count.state);
+                    self.graphs.get_or_create(&StatusLabels { status }).inc_by(count.count);
+                }
+                "message" => {
+                    let status = known_status::<MessageState>(&count.state);
+                    self.messages
+                        .get_or_create(&StatusLabels { status: status.clone() })
+                        .inc_by(count.count);
+                    if status == "Pending" {
+                        self.oldest_pending_message_age_seconds.set(
+                            count
+                                .oldest_created_at
+                                .map_or(0, |created_at| now.saturating_sub(created_at).max(0)),
+                        );
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    fn apply_alert_snapshot(&self, snapshot: &store::NodeAlertMetricsSnapshot) {
+        let now = current_time_secs();
+        self.pegin_oldest_active_age_seconds
+            .set(age_since(snapshot.pegin_oldest_active_status_updated_at, now));
+        self.pegin_oldest_committee_wait_age_seconds
+            .set(age_since(snapshot.pegin_oldest_committee_wait_status_updated_at, now));
+        self.pegout_oldest_active_age_seconds
+            .set(age_since(snapshot.pegout_oldest_active_status_updated_at, now));
+        let decimals = self.peg_btc_decimals.load(Ordering::Relaxed);
+        if decimals != UNKNOWN_TOKEN_DECIMALS
+            && let Some(sats) = snapshot
+                .operator_available_pegbtc
+                .as_deref()
+                .and_then(|value| pegbtc_base_units_to_sats(value, decimals))
+        {
+            self.operator_available_pegbtc_sats.set(sats);
+        }
+    }
+}
+
+fn outcome(success: bool) -> String {
+    if success { "success" } else { "failed" }.to_string()
+}
+
+fn age_since(timestamp: Option<i64>, now: i64) -> i64 {
+    timestamp.map_or(0, |timestamp| now.saturating_sub(timestamp).max(0))
+}
+
+fn pegbtc_base_units_to_sats(value: &str, token_decimals: u8) -> Option<i64> {
+    let value = U256::from_str(value).ok()?;
+    let sats = if token_decimals >= BTC_DECIMALS {
+        value / U256::from(10).pow(U256::from(token_decimals - BTC_DECIMALS))
+    } else {
+        value.checked_mul(U256::from(10).pow(U256::from(BTC_DECIMALS - token_decimals)))?
+    };
+    Some(u256_to_gauge(sats))
+}
+
+fn u256_to_gauge(value: U256) -> i64 {
+    let max = U256::from(i64::MAX as u64);
+    if value > max { i64::MAX } else { value.to::<u64>() as i64 }
+}
+
+/// Returns a bounded status label, mapping unexpected database values to `unknown`.
+fn known_status<T: FromStr>(state: &str) -> String {
+    if state.parse::<T>().is_ok() { state.to_owned() } else { "unknown".to_string() }
 }
 
-// State<Arc<AppState>>,
 pub async fn metrics_middleware(
-    state: State<Arc<AppState>>,
+    State(state): State<Arc<AppState>>,
     request: Request,
     next: Next,
 ) -> impl IntoResponse {
     let start = Instant::now();
-    let path = if let Some(route) = request.extensions().get::<axum::extract::MatchedPath>() {
-        route.as_str().to_owned()
-    } else {
-        request.uri().path().to_owned()
-    };
+    let route = request
+        .extensions()
+        .get::<MatchedPath>()
+        .map_or_else(|| "unmatched".to_string(), |route| route.as_str().to_owned());
     let method = request.method().to_string();
+
     state.metrics_state.http_requests_in_flight.inc();
+    let in_flight = InFlightGuard(state.metrics_state.http_requests_in_flight.clone());
     let response = next.run(request).await;
-    state.metrics_state.http_requests_in_flight.dec();
+    drop(in_flight);
+
     let status = response.status().as_u16();
     state
         .metrics_state
         .http_requests_total
-        .get_or_create(&HttpRequestLabels { method, path, status })
+        .get_or_create(&HttpRequestLabels { method: method.clone(), route: route.clone(), status })
         .inc();
-
-    state.metrics_state.http_request_duration_seconds.observe(start.elapsed().as_secs_f64());
+    state
+        .metrics_state
+        .http_request_duration_seconds
+        .get_or_create(&HttpRouteLabels { method, route })
+        .observe(start.elapsed().as_secs_f64());
     response
 }
 
-pub async fn metrics_handler(State(app_state): State<Arc<AppState>>) -> impl IntoResponse {
+/// Refreshes database-backed gauges and returns the encoded metrics response.
+pub async fn metrics_handler(State(app_state): State<Arc<AppState>>) -> Response {
+    let database_metrics = async {
+        let mut storage = app_state.local_db.acquire().await?;
+        let counts = storage.node_metrics_state_counts().await?;
+        let snapshot = storage.node_alert_metrics_snapshot(&app_state.peer_id).await?;
+        Ok::<_, anyhow::Error>((counts, snapshot))
+    }
+    .await;
+    let (counts, snapshot) = match database_metrics {
+        Ok(metrics) => {
+            app_state.metrics_state.mark_database_ready(true);
+            metrics
+        }
+        Err(error) => {
+            app_state.metrics_state.mark_database_ready(false);
+            app_state.metrics_state.record_db_error(&error);
+            tracing::error!(error = %error, "failed to collect node database metrics");
+            return (StatusCode::SERVICE_UNAVAILABLE, "metrics unavailable\n").into_response();
+        }
+    };
+
+    let mut buffer = String::new();
+    let registry = app_state.metrics_state.registry.lock().unwrap();
+    app_state.metrics_state.apply_database_metrics(&counts);
+    app_state.metrics_state.apply_alert_snapshot(&snapshot);
+    if let Err(error) = encode(&mut buffer, &registry) {
+        tracing::error!(error = %error, "failed to encode node metrics");
+        return (StatusCode::INTERNAL_SERVER_ERROR, "metrics encoding failed\n").into_response();
+    }
+
     let mut headers = HeaderMap::new();
     headers.insert(axum::http::header::CONTENT_TYPE, METRICS_CONTENT_TYPE.parse().unwrap());
-    let mut buffer = String::new();
-    encode(&mut buffer, &app_state.metrics_state.registry.lock().unwrap()).unwrap();
-    (headers, buffer)
+    (StatusCode::OK, headers, buffer).into_response()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use prometheus_client::encoding::text::encode;
+
+    fn encoded(state: &MetricsState) -> String {
+        let mut output = String::new();
+        encode(&mut output, &state.registry.lock().unwrap()).unwrap();
+        output
+    }
+
+    #[test]
+    fn exports_correct_counter_name_and_bounded_database_labels() {
+        let state = MetricsState::new(Arc::new(Mutex::new(Registry::default())));
+        state
+            .http_requests_total
+            .get_or_create(&HttpRequestLabels {
+                method: "GET".to_string(),
+                route: "unmatched".to_string(),
+                status: 404,
+            })
+            .inc();
+        state.apply_database_metrics(&[
+            store::MetricsStateCount {
+                category: "graph".to_string(),
+                state: "unexpected-id-like-value".to_string(),
+                count: 1,
+                oldest_created_at: None,
+                last_success_at: None,
+            },
+            store::MetricsStateCount {
+                category: "graph".to_string(),
+                state: "another-unexpected-value".to_string(),
+                count: 2,
+                oldest_created_at: None,
+                last_success_at: None,
+            },
+        ]);
+
+        let output = encoded(&state);
+        assert!(output.contains("http_requests_total"));
+        assert!(!output.contains("http_requests_total_total"));
+        assert!(output.contains("route=\"unmatched\""));
+        assert!(output.contains("bitvm_node_graphs{status=\"unknown\"} 3"));
+        assert!(!output.contains("bitvm_node_graphs{status=\"OperatorPresigned\"}"));
+        assert!(!output.contains("unexpected-id-like-value"));
+        assert!(!output.contains("another-unexpected-value"));
+    }
+
+    #[test]
+    fn records_task_and_message_metrics() {
+        let state = MetricsState::new(Arc::new(Mutex::new(Registry::default())));
+        state.record_task_run("maintenance", "success", Duration::from_millis(25));
+        state.record_task_run("history_sync", "failed", Duration::from_millis(5));
+        state.record_message_dispatch("Tick", "success");
+
+        let output = encoded(&state);
+        assert!(
+            output
+                .contains("bitvm_node_task_runs_total{task=\"maintenance\",outcome=\"success\"} 1")
+        );
+        assert!(output.contains(
+            "bitvm_node_message_dispatch_total{message_type=\"Tick\",outcome=\"success\"} 1"
+        ));
+        assert!(
+            !output
+                .contains("bitvm_node_task_last_success_timestamp_seconds{task=\"history_sync\"}")
+        );
+    }
+
+    #[test]
+    fn readiness_requires_healthy_event_watchers() {
+        let state = MetricsState::new(Arc::new(Mutex::new(Registry::default())));
+        state.mark_startup_ready();
+        state.mark_database_ready(true);
+        state.mark_backend_ready(true);
+
+        let output = encoded(&state);
+        assert!(output.contains("bitvm_node_ready 0"));
+        assert!(output.contains("bitvm_node_event_watch_ready 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"healthy\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"syncing\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"failed\"} 0"));
+
+        state.set_event_watch_state(EventWatchState::Syncing);
+        let output = encoded(&state);
+        assert!(output.contains("bitvm_node_ready 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"healthy\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"syncing\"} 1"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"failed\"} 0"));
+
+        state.set_event_watch_state(EventWatchState::Healthy);
+        let output = encoded(&state);
+        assert!(output.contains("bitvm_node_ready 1"));
+        assert!(output.contains("bitvm_node_event_watch_ready 1"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"healthy\"} 1"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"syncing\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"failed\"} 0"));
+
+        state.set_event_watch_state(EventWatchState::Failed);
+        let output = encoded(&state);
+        assert!(output.contains("bitvm_node_ready 0"));
+        assert!(output.contains("bitvm_node_event_watch_ready 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"healthy\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"syncing\"} 0"));
+        assert!(output.contains("bitvm_node_event_watch_state{state=\"failed\"} 1"));
+    }
 }
diff --git a/node/src/middleware/behaviour.rs b/node/src/middleware/behaviour.rs
index 378d53712..3dcc17af0 100644
--- a/node/src/middleware/behaviour.rs
+++ b/node/src/middleware/behaviour.rs
@@ -4,6 +4,8 @@ use libp2p_swarm_derive::NetworkBehaviour;
 use std::time::Duration;
 use tokio::io::{self};
 
+pub const MAX_GOSSIPSUB_TRANSMIT_SIZE: usize = 16 * 1024 * 1024;
+
 // We create a custom network behaviour that combines Kademlia and mDNS.
 #[derive(NetworkBehaviour)]
 pub struct AllBehaviours {
@@ -21,7 +23,7 @@ impl AllBehaviours {
         //    .unwrap();
 
         let gossipsub_config = gossipsub::ConfigBuilder::default()
-            .max_transmit_size(16 * 1024 * 1024) // 16 MB
+            .max_transmit_size(MAX_GOSSIPSUB_TRANSMIT_SIZE)
             .build()
             .map_err(io::Error::other)
             .unwrap();
diff --git a/node/src/middleware/swarm.rs b/node/src/middleware/swarm.rs
index ee9b5ae43..aadd43018 100644
--- a/node/src/middleware/swarm.rs
+++ b/node/src/middleware/swarm.rs
@@ -9,6 +9,7 @@ use libp2p::gossipsub::MessageId;
 use libp2p::multiaddr::Protocol;
 use libp2p::swarm::SwarmEvent;
 use libp2p::{Multiaddr, PeerId, Swarm, gossipsub, kad, noise, tcp, yamux};
+use prometheus_client::metrics::gauge::Gauge;
 use prometheus_client::registry::Registry;
 use std::collections::HashMap;
 
@@ -105,12 +106,26 @@ pub struct BitvmNetworkManager {
     config: BitvmSwarmConfig,
     peer_id: PeerId,
     swarm: BitvmSwarmWrapper,
+    connected_peers: Gauge,
+    required_topics_healthy: Gauge,
 }
 impl BitvmNetworkManager {
     pub fn new(
         config: BitvmSwarmConfig,
         metric_registry: &mut Registry,
     ) -> anyhow::Result<BitvmNetworkManager> {
+        let connected_peers = Gauge::default();
+        let required_topics_healthy = Gauge::default();
+        metric_registry.register(
+            "bitvm_node_p2p_connected_peers",
+            "Number of currently connected P2P peers",
+            connected_peers.clone(),
+        );
+        metric_registry.register(
+            "bitvm_node_p2p_required_topics_healthy",
+            "Whether the local role has a mesh peer for each required P2P topic",
+            required_topics_healthy.clone(),
+        );
         let key_pair = libp2p::identity::Keypair::from_protobuf_encoding(&Zeroizing::new(
             base64::engine::general_purpose::STANDARD.decode(config.local_key.clone())?,
         ))?;
@@ -134,12 +149,26 @@ impl BitvmNetworkManager {
             config,
             swarm: BitvmSwarmWrapper::new(swarm),
             peer_id: key_pair.public().to_peer_id(),
+            connected_peers,
+            required_topics_healthy,
         })
     }
 
     pub fn get_peer_id_string(&self) -> String {
         self.peer_id.to_string()
     }
+
+    fn refresh_required_topics_health(&self, actor: &Actor) {
+        let role_topic = middleware::get_topic_name(&actor.to_string());
+        let all_topic = middleware::get_topic_name(&Actor::All.to_string());
+        let required_topics =
+            if role_topic == all_topic { vec![role_topic] } else { vec![role_topic, all_topic] };
+        let healthy = required_topics.into_iter().all(|topic| {
+            let topic = gossipsub::IdentTopic::new(topic);
+            self.swarm.behaviour().gossipsub.mesh_peers(&topic.hash()).next().is_some()
+        });
+        self.required_topics_healthy.set(i64::from(healthy));
+    }
     pub async fn run<H: P2pMessageHandler>(
         &mut self,
         actor: Actor,
@@ -158,6 +187,7 @@ impl BitvmNetworkManager {
                 (topic_name, gossipsub_topic)
             })
             .collect::<HashMap<String, _>>();
+        self.refresh_required_topics_health(&actor);
 
         if self.config.p2p_port > 0 {
             self.swarm.listen_on(format!("/ip4/0.0.0.0/tcp/{}", self.config.p2p_port).parse()?)?;
@@ -190,6 +220,7 @@ impl BitvmNetworkManager {
                                 Ok(_) => {}
                                 Err(e) => { tracing::error!("Fail to handle tick message {e:?}") }
                             }
+                        self.refresh_required_topics_health(&actor);
 
                     },
 
@@ -198,6 +229,7 @@ impl BitvmNetworkManager {
                                 Ok(_) => {}
                                 Err(e) => { tracing::error!("{e:?}") }
                             }
+                        self.refresh_required_topics_health(&actor);
                     },
 
                     event = self.swarm.select_next_some() => {
@@ -224,9 +256,9 @@ impl BitvmNetworkManager {
                                         data_starts_with_goatbin,
                                         "Fail to handle p2p message"
                                     )
-                                }
                             }
                         }
+                        }
                         SwarmEvent::Behaviour(AllBehavioursEvent::Gossipsub(gossipsub::Event::Subscribed { peer_id, topic})) => {
                             debug!("subscribing: {:?}, {:?}", peer_id, topic);
                             let topic_limb = split_topic_name(topic.as_str());//topic.as_str().split_once("/topic/").expect("should be $proto/topic/$actor");
@@ -269,12 +301,18 @@ impl BitvmNetworkManager {
                             debug!("new external address of peer: {} {}", peer_id, address);
                         }
                         SwarmEvent::ConnectionEstablished {peer_id, connection_id, endpoint, .. } => {
+                            self.connected_peers.set(self.swarm.connected_peers().count() as i64);
                             debug!("connected to {peer_id}: {connection_id}, endpoint: {:?}", endpoint);
                         }
+                        SwarmEvent::ConnectionClosed {peer_id, connection_id, .. } => {
+                            self.connected_peers.set(self.swarm.connected_peers().count() as i64);
+                            debug!("disconnected from {peer_id}: {connection_id}");
+                        }
                         e => {
                             debug!("Unhandled {:?}", e);
                         }
                     }
+                    self.refresh_required_topics_health(&actor);
                 }
             }
         }
diff --git a/node/src/p2p_msg_handler.rs b/node/src/p2p_msg_handler.rs
index be31343a9..49bba59bc 100644
--- a/node/src/p2p_msg_handler.rs
+++ b/node/src/p2p_msg_handler.rs
@@ -2,6 +2,7 @@ use crate::action::{
     GOATMessage, GOATMessageContent, handle_self_p2p_msg, recv_and_dispatch, send_to_peer,
 };
 use crate::env::get_local_node_info;
+use crate::metrics_service::MetricsState;
 use crate::middleware::swarm::{BitvmSwarmWrapper, P2pMessageHandler, TickMessageType};
 use crate::utils::detect_heart_beat;
 use bitvm_lib::actors::Actor;
@@ -19,6 +20,7 @@ pub struct BitvmNodeProcessor {
     pub goat_client: GOATClient,
     pub http_client: HttpAsyncClient,
     pub soldering_builder: Option<Arc<BabeBundleBuilder>>,
+    pub metrics_state: MetricsState,
 }
 impl P2pMessageHandler for BitvmNodeProcessor {
     async fn recv_and_dispatch(
@@ -40,6 +42,8 @@ impl P2pMessageHandler for BitvmNodeProcessor {
             from_peer_id,
             id,
             message,
+            &self.metrics_state,
+            true,
         )
         .await
     }
@@ -80,6 +84,7 @@ impl P2pMessageHandler for BitvmNodeProcessor {
                     peer_id,
                     GOATMessage::default_message_id(),
                     &tick_data,
+                    &self.metrics_state,
                 )
                 .await
             }
diff --git a/node/src/rpc_service/mod.rs b/node/src/rpc_service/mod.rs
index 8da2ccc05..d920828b5 100644
--- a/node/src/rpc_service/mod.rs
+++ b/node/src/rpc_service/mod.rs
@@ -31,8 +31,7 @@ use bitvm_lib::actors::Actor;
 use client::btc_chain::BTCClient;
 use client::goat_chain::GOATClient;
 use client::http_client::async_client::HttpAsyncClient;
-use prometheus_client::registry::Registry;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::time::{Duration, UNIX_EPOCH};
 use store::localdb::LocalDB;
 use tokio::net::TcpListener;
@@ -74,11 +73,10 @@ impl AppState {
         local_db: LocalDB,
         actor: Actor,
         peer_id: String,
-        registry: Arc<Mutex<Registry>>,
+        metrics_state: MetricsState,
     ) -> anyhow::Result<Arc<AppState>> {
         let btc_client = BTCClient::new(get_network(), get_btc_url_from_env().as_deref());
         let goat_client = GOATClient::new(goat_config_from_env().await, get_goat_network());
-        let metrics_state = MetricsState::new(registry);
         let http_client = HttpAsyncClient::new(None);
         Ok(Arc::new(AppState {
             local_db,
@@ -95,7 +93,7 @@ impl AppState {
         local_db: LocalDB,
         actor: Actor,
         peer_id: String,
-        registry: Arc<Mutex<Registry>>,
+        metrics_state: MetricsState,
     ) -> anyhow::Result<Arc<AppState>> {
         let (btc_client, btc_mock_adaptor) = BTCClient::new_mock_client();
         btc_mock_adaptor.set_height(900_000);
@@ -108,7 +106,7 @@ impl AppState {
             local_db,
             btc_client,
             goat_client,
-            metrics_state: MetricsState::new(registry),
+            metrics_state,
             actor,
             peer_id,
             http_client: HttpAsyncClient::new(None),
@@ -166,7 +164,6 @@ pub async fn serve_with_app_state(
         .route(routes::v1::PEGOUT, post(pegout))
         .route(routes::v1::PROOFS_CHAIN_PROOFS_DESC, get(get_chain_proof_desc))
         .route(routes::v1::PROOFS_OPERATOR_PROOF_DESC, get(get_operator_proof_desc))
-        .route(routes::METRICS, get(metrics_handler))
         .layer(create_secure_cors_layer())
         .layer(
             TraceLayer::new_for_http()
@@ -210,6 +207,7 @@ pub async fn serve_with_app_state(
                 ),
         )
         .layer(middleware::from_fn_with_state(app_state.clone(), metrics_middleware))
+        .route(routes::METRICS, get(metrics_handler))
         .with_state(app_state);
 
     let listener = TcpListener::bind(&addr)
@@ -245,10 +243,10 @@ pub async fn serve(
     local_db: LocalDB,
     actor: Actor,
     peer_id: String,
-    registry: Arc<Mutex<Registry>>,
+    metrics_state: MetricsState,
     cancellation_token: CancellationToken,
 ) -> anyhow::Result<String> {
-    let app_state = AppState::create_arc_app_state(local_db, actor, peer_id, registry).await?;
+    let app_state = AppState::create_arc_app_state(local_db, actor, peer_id, metrics_state).await?;
     serve_with_app_state(addr, app_state, cancellation_token).await
 }
 
@@ -257,6 +255,7 @@ mod tests {
     use crate::env::{
         ENV_GOAT_CHAIN_URL, ENV_GOAT_GATEWAY_CONTRACT_ADDRESS, ENV_PROOF_SEVER_URL, get_network,
     };
+    use crate::metrics_service::MetricsState;
     use crate::rpc_service::bitvm::{
         BRIDGE_IN_AMOUNTS, GraphGetResponse, GraphListResponse, InstanceGetResponse,
         InstanceListResponse, InstanceOverviewResponse, InstanceSettingResponse,
@@ -378,6 +377,52 @@ mod tests {
         listener.local_addr().unwrap().to_string()
     }
 
+    #[tokio::test(flavor = "multi_thread")]
+    async fn metrics_use_route_templates_and_exclude_scrapes()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let addr = available_addr();
+        let local_db = create_local_db(&temp_sqlite_db_path()).await;
+        let metrics_state = MetricsState::new(Arc::new(Mutex::new(Registry::default())));
+        let app_state = rpc_service::AppState::create_arc_mock_app_state(
+            local_db,
+            Actor::Verifier,
+            generate_local_key().public().to_peer_id().to_string(),
+            metrics_state,
+        )
+        .await?;
+        let cancellation_token = CancellationToken::new();
+        let server_token = cancellation_token.clone();
+        let server =
+            tokio::spawn(rpc_service::serve_with_app_state(addr.clone(), app_state, server_token));
+        sleep(Duration::from_millis(100)).await;
+
+        let client = Client::new();
+        client.get(format!("http://{addr}/")).send().await?.error_for_status()?;
+        let unmatched = client.get(format!("http://{addr}/missing")).send().await?;
+        assert_eq!(unmatched.status().as_u16(), 404);
+        let first_scrape =
+            client.get(format!("http://{addr}/metrics")).send().await?.text().await?;
+        let second_scrape =
+            client.get(format!("http://{addr}/metrics")).send().await?.text().await?;
+
+        assert!(
+            first_scrape
+                .contains("http_requests_total{method=\"GET\",route=\"/\",status=\"200\"} 1")
+        );
+        assert!(
+            first_scrape.contains(
+                "http_requests_total{method=\"GET\",route=\"unmatched\",status=\"404\"} 1"
+            )
+        );
+        assert!(first_scrape.contains("http_requests_in_flight 0"));
+        assert!(!first_scrape.contains("route=\"/metrics\""));
+        assert_eq!(first_scrape, second_scrape);
+
+        cancellation_token.cancel();
+        server.await??;
+        Ok(())
+    }
+
     async fn init_nodes_data(local_db: &LocalDB, nodes: &[Node]) -> anyhow::Result<()> {
         let mut tx = local_db.start_transaction().await?;
         for node in nodes {
@@ -498,7 +543,7 @@ mod tests {
             local_db,
             Actor::Verifier,
             generate_local_key().public().to_peer_id().to_string(),
-            Arc::new(Mutex::new(Registry::default())),
+            MetricsState::new(Arc::new(Mutex::new(Registry::default()))),
             CancellationToken::new(),
         ));
         sleep(Duration::from_secs(3)).await;
@@ -701,7 +746,7 @@ mod tests {
             local_db.clone(),
             actor.clone(),
             peer_id.clone(),
-            Arc::new(Mutex::new(Registry::default())),
+            MetricsState::new(Arc::new(Mutex::new(Registry::default()))),
             CancellationToken::new(),
         ));
         sleep(Duration::from_secs(3)).await;
@@ -854,7 +899,7 @@ mod tests {
             local_db,
             committee,
             committee_peer_id,
-            Arc::new(Mutex::new(Registry::default())),
+            MetricsState::new(Arc::new(Mutex::new(Registry::default()))),
             CancellationToken::new(),
         ));
         sleep(Duration::from_secs(3)).await;
diff --git a/node/src/scheduled_tasks/event_watch_task.rs b/node/src/scheduled_tasks/event_watch_task.rs
index 3cab9ae64..e55389c55 100644
--- a/node/src/scheduled_tasks/event_watch_task.rs
+++ b/node/src/scheduled_tasks/event_watch_task.rs
@@ -6,6 +6,7 @@ use crate::env::{
     get_goat_gateway_the_graph_urls_from_env, get_goat_swap_event_filter_from_from_env,
     get_goat_swap_event_filter_gap_from_env, get_goat_swap_the_graph_urls_from_env, get_network,
 };
+use crate::metrics_service::{EventWatchState, MetricsState};
 use crate::rpc_service::current_time_secs;
 use crate::scheduled_tasks::get_timestamp_from_contract_data;
 use crate::utils::evm_swap_utils::IEscrowManager::EscrowData;
@@ -39,7 +40,7 @@ use std::collections::HashMap;
 use std::ops::AddAssign;
 use std::str::FromStr;
 use std::sync::Arc;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use store::localdb::{GraphRuntimeUpdate, InstanceUpdate, LocalDB, NodeQuery, StorageProcessor};
 use store::{
     GoatTxProcessingStatus, GoatTxRecord, GoatTxType, GraphStatus, GraphStatusSource,
@@ -51,6 +52,41 @@ use tokio_util::sync::CancellationToken;
 use tracing::{info, warn};
 use uuid::Uuid;
 
+async fn refresh_event_watch_metrics(
+    local_db: &LocalDB,
+    goat_client: &GOATClient,
+    metrics_state: &MetricsState,
+) -> anyhow::Result<()> {
+    let finalized_height = goat_client.get_finalized_block_number().await.map_err(|error| {
+        metrics_state.record_goat_backend_probe(false);
+        warn!(event = "metrics_backend_probe", backend = "goat", operation = "get_finalized_block_number", error = %error, "event watcher lag probe failed");
+        error
+    })?;
+    metrics_state.record_goat_backend_probe(true);
+
+    let snapshot = async {
+        let mut storage = local_db.acquire().await?;
+        storage.event_watch_metrics_snapshot(finalized_height).await
+    }
+    .await
+    .map_err(|error| {
+        metrics_state.record_db_error(&error);
+        warn!(event = "metrics_event_watch", error = %error, "failed to collect event watcher state");
+        error
+    })?;
+
+    metrics_state.apply_event_watch_lag(snapshot.lag_blocks);
+    let state = if snapshot.failed_count > 0 {
+        EventWatchState::Failed
+    } else if snapshot.syncing_count > 0 {
+        EventWatchState::Syncing
+    } else {
+        EventWatchState::Healthy
+    };
+    metrics_state.set_event_watch_state(state);
+    Ok(())
+}
+
 #[allow(clippy::too_many_arguments)]
 pub async fn fetch_and_handle_block_range_events<'a>(
     actor: Actor,
@@ -592,6 +628,9 @@ async fn handle_withdraw_disproved_events<'a>(
             })
             .await?;
         if is_new_event {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_pegout_disprove();
+            }
             add_node_reward(
                 storage_processor,
                 &verifier_addr.unwrap(),
@@ -1291,6 +1330,7 @@ pub async fn monitor_events_item(
         watch_events_config.get_watch_contract_type(),
     )
     .await?;
+
     let query_client = GraphQueryClient::new();
     // let current_finalized = goat_client.get_finalized_block_number().await?;
     let current_finalized = match query_client
@@ -1330,7 +1370,7 @@ pub async fn monitor_events_item(
         let query_client_clone = query_client.clone();
         let watch_events_config_clone = watch_events_config.clone();
         tokio::spawn(async move {
-            let _ = fetch_history_events(
+            if let Err(error) = fetch_history_events(
                 actor.clone(),
                 btc_client.clone(),
                 goat_client,
@@ -1339,7 +1379,10 @@ pub async fn monitor_events_item(
                 watch_contract_clone,
                 watch_events_config_clone,
             )
-            .await;
+            .await
+            {
+                warn!(event = "event_watch_history_sync", error = %error, "event watcher history sync task exited unexpectedly");
+            }
         });
         return Ok(());
     }
@@ -1366,6 +1409,7 @@ pub async fn monitor_events_item(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 pub async fn run_watch_event_task(
     actor: Actor,
     local_db: LocalDB,
@@ -1374,6 +1418,7 @@ pub async fn run_watch_event_task(
     interval: u64,
     cancellation_token: CancellationToken,
     goat_init_config: GoatInitConfig,
+    metrics_state: MetricsState,
 ) -> anyhow::Result<String> {
     let gateway_contract: EvmAddress = get_goat_address_from_env(ENV_GOAT_GATEWAY_CONTRACT_ADDRESS)
         .ok_or(anyhow::anyhow!("need to set gateway contract address"))?;
@@ -1490,6 +1535,7 @@ pub async fn run_watch_event_task(
     loop {
         tokio::select! {
             _ = tokio::time::sleep(Duration::from_secs(interval)) => {
+                let started_at = Instant::now();
                 // Execute the normal monitoring logic
                 match monitor_events(
                         actor.clone(),
@@ -1500,8 +1546,38 @@ pub async fn run_watch_event_task(
                     )
                     .await
                     {
-                        Ok(_) => {}
+                        Ok(_) => {
+                            metrics_state.record_task_run(
+                                "event_watcher",
+                                "success",
+                                started_at.elapsed(),
+                            );
+                            let local_db = local_db.clone();
+                            let goat_client = goat_client.clone();
+                            let metrics_state = metrics_state.clone();
+                            tokio::spawn(async move {
+                                if let Ok(Err(error)) = tokio::time::timeout(
+                                    Duration::from_secs(30),
+                                    refresh_event_watch_metrics(
+                                        &local_db,
+                                        goat_client.as_ref(),
+                                        &metrics_state,
+                                    ),
+                                )
+                                .await
+                                {
+                                    metrics_state.set_event_watch_state(EventWatchState::Failed);
+                                    warn!(event = "metrics_event_watch", error = %error, "failed to refresh event watcher metrics");
+                                }
+                            });
+                        }
                         Err(e) => {
+                            metrics_state.set_event_watch_state(EventWatchState::Failed);
+                            metrics_state.record_task_run(
+                                "event_watcher",
+                                "failed",
+                                started_at.elapsed(),
+                            );
                             warn!("fail to monitor events: {e}");
                         }
                     }
diff --git a/node/src/scheduled_tasks/instance_maintenance_tasks.rs b/node/src/scheduled_tasks/instance_maintenance_tasks.rs
index cd4e1b156..8d7bb0e00 100644
--- a/node/src/scheduled_tasks/instance_maintenance_tasks.rs
+++ b/node/src/scheduled_tasks/instance_maintenance_tasks.rs
@@ -1,4 +1,7 @@
-use crate::action::{ConfirmInstance, GOATMessageContent, PeginRequest, PostReady};
+use crate::action::{
+    ConfirmInstance, GOATMessage, GOATMessageContent, PeginConfirmNonce, PeginConfirmPartialSig,
+    PeginRequest, PostReady, push_local_unhandled_messages,
+};
 use crate::env::{
     COMMITTEE_INSTANCE_KEYS_DIR, get_bitvm_key, get_committee_instance_key_delete_timelock_blocks,
     get_instance_maintenance_batch_size, get_instance_presigned_time_expired_secs,
@@ -10,7 +13,9 @@ use crate::scheduled_tasks::get_timestamp_from_contract_data;
 use crate::utils::evm_swap_utils::IEscrowManager::EscrowData;
 use crate::utils::{
     SELF_SENDER, check_bridge_in_uxto_available_or_self_spent, gen_instance_parameters_local,
-    upsert_message,
+    get_committee_endorse_sigs_for_pegin, get_committee_partial_sig_for_instance,
+    get_committee_pub_nonce_for_instance, load_committee_instance_keypair,
+    store_committee_pub_nonce_for_instance, upsert_message,
 };
 use alloy::sol_types::SolType;
 use bitvm_lib::actors::Actor;
@@ -38,6 +43,7 @@ const TASK_KEY_INSTANCE_WINDOW_EXPIRATION: &str = "instance_window_expiration_mo
 const TASK_KEY_INSTANCE_EXPIRATION: &str = "instance_expiration_monitor";
 const TASK_KEY_INSTANCE_BTC_TX: &str = "instance_btc_tx_monitor";
 const TASK_KEY_INSTANCE_BRIDGE_OUT: &str = "instance_bridge_out_monitor";
+const TASK_KEY_PEGIN_CONFIRM_RECOVERY: &str = "pegin_confirm_recovery_monitor";
 
 #[derive(Clone, Debug)]
 struct InstancePageState {
@@ -141,10 +147,14 @@ pub async fn instance_answers_monitor(
     let current_height = goat_client.get_finalized_block_number().await?;
     let response_window_blocks = goat_client.gateway_get_response_window_blocks().await? as i64;
     for tx_record in tx_records {
-        let mut tx = local_db.start_transaction().await?;
-        if let Some(event) = tx_record.extra {
-            let event: BridgeInRequestEvent = serde_json::from_str(&event)?;
-            if tx_record.height + response_window_blocks < current_height {
+        let event = tx_record
+            .extra
+            .as_deref()
+            .map(serde_json::from_str::<BridgeInRequestEvent>)
+            .transpose()?;
+        let is_outside_response_window = tx_record.height + response_window_blocks < current_height;
+        let discarded_instance = if is_outside_response_window {
+            if let Some(event) = event.as_ref() {
                 info!(
                     "instance_answers_monitor: instance_id:{} BridgeInRequest is outside the response window",
                     tx_record.instance_id
@@ -154,7 +164,7 @@ pub async fn instance_answers_monitor(
                     generate_instance_from_bridge_in_request_event(
                         btc_client,
                         goat_client,
-                        &event,
+                        event,
                         true,
                     )
                     .await
@@ -167,6 +177,21 @@ pub async fn instance_answers_monitor(
                     // for the case: if bridgeIn confirm is broadcast,but L2 not minted,
                     // instance status will been updated to L2Minted when normal finished
                     instance.status = InstanceBridgeInStatus::UserDiscarded.to_string();
+                    Some(instance)
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        let mut tx = local_db.start_transaction().await?;
+        if let Some(event) = event {
+            if is_outside_response_window {
+                if let Some(instance) = discarded_instance {
                     tx.upsert_instance(&instance).await?;
                 }
             } else {
@@ -488,6 +513,145 @@ pub async fn instance_btc_tx_monitor(
     Ok(())
 }
 
+/// Re-publish persisted PeginConfirm signing material until the transaction is visible on Bitcoin.
+/// This never derives a new partial signature: it only reuses the deterministic nonce or stored signature.
+pub async fn pegin_confirm_recovery_monitor(
+    local_db: &LocalDB,
+    btc_client: &BTCClient,
+    actor: &Actor,
+) -> anyhow::Result<()> {
+    if actor != &Actor::Committee {
+        return Ok(());
+    }
+
+    let instances = find_one_instance_page(
+        local_db,
+        TASK_KEY_PEGIN_CONFIRM_RECOVERY,
+        InstanceQuery::default()
+            .with_is_bridge_in(true)
+            .with_status(InstanceBridgeInStatus::Presigned.to_string()),
+        get_instance_maintenance_batch_size(),
+    )
+    .await?;
+    if instances.is_empty() {
+        return Ok(());
+    }
+
+    let committee_master_key = CommitteeMasterKey::new(get_bitvm_key()?);
+    for instance in instances {
+        let Some(pegin_confirm_txid) = instance.pegin_confirm_txid.clone() else {
+            warn!(
+                instance_id = %instance.instance_id,
+                "skip PeginConfirm recovery: instance has no expected PeginConfirm txid"
+            );
+            continue;
+        };
+        match btc_client.get_tx(&pegin_confirm_txid.0).await {
+            Ok(Some(_)) => continue,
+            Ok(None) => {}
+            Err(error) => {
+                warn!(
+                    instance_id = %instance.instance_id,
+                    error = %error,
+                    "defer PeginConfirm recovery: unable to query Bitcoin transaction"
+                );
+                continue;
+            }
+        }
+
+        let instance_id = instance.instance_id;
+        let instance_parameters = gen_instance_parameters_local(&instance)?;
+        let instance_keypair = load_committee_instance_keypair(&committee_master_key, instance_id)?;
+        let local_committee_pubkey = instance_keypair.public_key().into();
+
+        if let Some(partial_sig) =
+            get_committee_partial_sig_for_instance(local_db, instance_id, &local_committee_pubkey)
+                .await?
+        {
+            let Some((_, endorse_sig)) =
+                get_committee_endorse_sigs_for_pegin(local_db, instance_id)
+                    .await?
+                    .into_iter()
+                    .find(|(pubkey, _)| *pubkey == local_committee_pubkey)
+            else {
+                warn!(
+                    instance_id = %instance_id,
+                    "skip PeginConfirm partial signature recovery: local endorsement signature is missing"
+                );
+                continue;
+            };
+            let message = GOATMessage::new(
+                Actor::Committee,
+                GOATMessageContent::PeginConfirmPartialSig(PeginConfirmPartialSig {
+                    instance_id,
+                    committee_pubkey: local_committee_pubkey,
+                    partial_sig,
+                    endorse_sig,
+                }),
+            );
+            push_local_unhandled_messages(local_db, instance_id, &message, 0).await?;
+            tracing::info!(
+                event = "pegin_confirm_recovery",
+                action = "republish_partial_signature",
+                instance_id = %instance_id,
+                "queued persisted PeginConfirm partial signature for re-publication"
+            );
+            continue;
+        }
+
+        let instance_parameters_hash = instance_parameters.parameters_hash()?;
+        let (_, derived_pub_nonce, nonce_sig) = committee_master_key
+            .nonce_for_instance_job_with_keypair(
+                instance_id,
+                instance_parameters_hash,
+                instance_keypair,
+            );
+        let pub_nonce = match get_committee_pub_nonce_for_instance(
+            local_db,
+            instance_id,
+            &local_committee_pubkey,
+        )
+        .await?
+        {
+            Some(stored_pub_nonce) => {
+                if stored_pub_nonce != derived_pub_nonce {
+                    anyhow::bail!(
+                        "stored PeginConfirm nonce differs from deterministic nonce for instance {instance_id}"
+                    );
+                }
+                stored_pub_nonce
+            }
+            None => {
+                store_committee_pub_nonce_for_instance(
+                    local_db,
+                    instance_id,
+                    local_committee_pubkey,
+                    derived_pub_nonce.clone(),
+                )
+                .await?;
+                derived_pub_nonce
+            }
+        };
+        let message = GOATMessage::new(
+            Actor::Committee,
+            GOATMessageContent::PeginConfirmNonce(PeginConfirmNonce {
+                instance_id,
+                committee_pubkey: local_committee_pubkey,
+                pub_nonce,
+                nonce_sig,
+            }),
+        );
+        push_local_unhandled_messages(local_db, instance_id, &message, 0).await?;
+        tracing::info!(
+            event = "pegin_confirm_recovery",
+            action = "republish_nonce",
+            instance_id = %instance_id,
+            "queued persisted PeginConfirm nonce for re-publication"
+        );
+    }
+    Ok(())
+}
+
 pub async fn get_bridge_out_deadline<'a>(
     storage_processor: &mut StorageProcessor<'a>,
     instance_id: &Uuid,
diff --git a/node/src/scheduled_tasks/mod.rs b/node/src/scheduled_tasks/mod.rs
index 6a91e0a1d..48a0d8174 100644
--- a/node/src/scheduled_tasks/mod.rs
+++ b/node/src/scheduled_tasks/mod.rs
@@ -8,9 +8,10 @@ mod spv_maintenance_tasks;
 
 use crate::action::GOATMessageContent;
 use crate::env::{
-    get_maintenance_run_timeout_secs, is_enable_babe_setup_state_cleanup,
-    is_enable_update_spv_contract, is_relayer,
+    get_maintenance_run_timeout_secs, get_network, get_node_goat_address, get_node_pubkey,
+    is_enable_babe_setup_state_cleanup, is_enable_update_spv_contract, is_relayer,
 };
+use crate::metrics_service::MetricsState;
 use crate::rpc_service::current_time_secs;
 use crate::scheduled_tasks::babe_setup_state_cleanup_task::babe_setup_state_cleanup_monitor;
 use crate::scheduled_tasks::graph_maintenance_tasks::{
@@ -19,10 +20,11 @@ use crate::scheduled_tasks::graph_maintenance_tasks::{
 use crate::scheduled_tasks::instance_maintenance_tasks::{
     instance_answers_monitor, instance_bridge_out_monitor, instance_btc_tx_monitor,
     instance_committee_key_cleanup_monitor, instance_expiration_monitor,
-    instance_window_expiration_monitor,
+    instance_window_expiration_monitor, pegin_confirm_recovery_monitor,
 };
 use crate::scheduled_tasks::node_maintenance_tasks::node_available_pbtc_update_monitor;
 use crate::scheduled_tasks::spv_maintenance_tasks::spv_header_hash_update;
+use crate::utils::node_p2wsh_address;
 use bitvm_lib::actors::Actor;
 use client::btc_chain::BTCClient;
 use client::goat_chain::GOATClient;
@@ -36,6 +38,125 @@ use store::{Graph, MessageType};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info, warn};
 
+/// Refreshes inexpensive dependency and funding signals used by alerting.
+async fn refresh_alert_health(
+    btc_client: &BTCClient,
+    goat_client: &GOATClient,
+    metrics_state: &MetricsState,
+    actor: &Actor,
+) {
+    let (btc_height, goat_height, goat_spv_height, peg_btc_decimals) = tokio::join!(
+        btc_client.get_height(),
+        goat_client.get_latest_block_number(),
+        goat_client.btc_spv_latest_height(),
+        goat_client.peg_btc_decimals(),
+    );
+    let btc_height = match btc_height {
+        Ok(height) => {
+            metrics_state.record_btc_backend_probe(true);
+            Some(height)
+        }
+        Err(error) => {
+            metrics_state.record_btc_backend_probe(false);
+            warn!(event = "metrics_backend_probe", backend = "btc", error = %error, "BTC backend health probe failed");
+            None
+        }
+    };
+    let goat_height_healthy = goat_height.is_ok();
+    metrics_state.record_goat_backend_probe(goat_height_healthy);
+    if let Err(error) = goat_height {
+        warn!(event = "metrics_backend_probe", backend = "goat", operation = "get_latest_block_number", error = %error, "Goat backend health probe failed");
+    }
+    let goat_spv_height = match goat_spv_height {
+        Ok(height) => {
+            metrics_state.record_goat_backend_probe(true);
+            Some(height)
+        }
+        Err(error) => {
+            metrics_state.record_goat_backend_probe(false);
+            warn!(event = "metrics_backend_probe", backend = "goat", operation = "btc_spv_latest_height", error = %error, "Goat SPV health probe failed");
+            None
+        }
+    };
+    match peg_btc_decimals {
+        Ok(decimals) => {
+            metrics_state.record_goat_backend_probe(true);
+            metrics_state.set_peg_btc_decimals(decimals);
+        }
+        Err(error) => {
+            metrics_state.record_goat_backend_probe(false);
+            warn!(event = "metrics_backend_probe", backend = "goat", operation = "peg_btc_decimals", error = %error, "failed to load pegBTC decimals");
+        }
+    }
+    metrics_state.apply_chain_health(btc_height, goat_spv_height);
+    metrics_state.mark_backend_ready(
+        btc_height.is_some() && goat_height_healthy && goat_spv_height.is_some(),
+    );
+
+    match get_node_pubkey() {
+        Ok(pubkey) => {
+            match btc_client.get_address_utxo(node_p2wsh_address(get_network(), &pubkey)).await {
+                Ok(utxos) => {
+                    metrics_state.record_btc_backend_probe(true);
+                    let balance_sats = utxos.iter().map(|utxo| utxo.value.to_sat()).sum::<u64>();
+                    metrics_state.apply_fee_wallet(
+                        i64::try_from(balance_sats).unwrap_or(i64::MAX),
+                        i64::try_from(utxos.len()).unwrap_or(i64::MAX),
+                    );
+                }
+                Err(error) => {
+                    metrics_state.record_btc_backend_probe(false);
+                    warn!(event = "metrics_backend_probe", backend = "btc", operation = "get_address_utxo", error = %error, "BTC fee wallet probe failed");
+                }
+            }
+        }
+        Err(error) => {
+            warn!(event = "metrics_fee_wallet", error = %error, "failed to derive fee wallet address")
+        }
+    }
+
+    if let Some(goat_address) = get_node_goat_address() {
+        match goat_client.native_balance(&goat_address.0).await {
+            Ok(balance) => {
+                metrics_state.record_goat_backend_probe(true);
+                metrics_state.apply_goat_gas_balance(balance);
+            }
+            Err(error) => {
+                metrics_state.record_goat_backend_probe(false);
+                warn!(event = "metrics_backend_probe", backend = "goat", operation = "native_balance", error = %error, "Goat gas balance probe failed");
+            }
+        }
+    }
+
+    if *actor == Actor::Operator {
+        let stake = async {
+            let pubkey = get_node_pubkey()?;
+            let xonly: [u8; 32] = pubkey.to_bytes()[1..33]
+                .try_into()
+                .map_err(|_| anyhow::anyhow!("invalid local operator public key"))?;
+            let operator_address = goat_client.stake_mana_pubkey_to_address(&xonly).await?;
+            let (minimum, locked) = tokio::try_join!(
+                goat_client.gateway_get_min_stake_amount(),
+                goat_client.stake_mana_lock_stake_of(&operator_address),
+            )?;
+            Ok::<_, anyhow::Error>(locked >= minimum)
+        }
+        .await;
+        match stake {
+            Ok(sufficient) => {
+                metrics_state.record_goat_backend_probe(true);
+                metrics_state.apply_required_stake(sufficient);
+            }
+            Err(error) => {
+                metrics_state.record_goat_backend_probe(false);
+                warn!(event = "metrics_backend_probe", backend = "goat", operation = "required_stake", error = %error, "required stake probe failed");
+            }
+        }
+    } else {
+        metrics_state.apply_required_stake(true);
+    }
+}
+
 async fn fetch_on_turn_graph_by_status<'a>(
     storage_processor: &mut StorageProcessor<'a>,
     graph_status: &str,
@@ -55,27 +176,36 @@ async fn fetch_on_turn_graph_by_status<'a>(
 }
 
 async fn run_maintenance_subtask<T>(
+    metrics_state: &MetricsState,
     task: &'static str,
     operation: impl Future<Output = anyhow::Result<T>>,
 ) {
     let started_at = Instant::now();
     match operation.await {
-        Ok(_) => debug!(
-            event = "maintenance_subtask_result",
-            task,
-            outcome = "succeeded",
-            elapsed_ms = started_at.elapsed().as_millis() as u64,
-            "maintenance subtask completed"
-        ),
-        Err(error) => warn!(
-            event = "maintenance_subtask_result",
-            task,
-            outcome = "failed",
-            elapsed_ms = started_at.elapsed().as_millis() as u64,
-            error_class = "maintenance",
-            error = %error,
-            "maintenance subtask failed after execution"
-        ),
+        Ok(_) => {
+            let elapsed = started_at.elapsed();
+            metrics_state.record_task_run(task, "success", elapsed);
+            debug!(
+                event = "maintenance_subtask_result",
+                task,
+                outcome = "succeeded",
+                elapsed_ms = elapsed.as_millis() as u64,
+                "maintenance subtask completed"
+            )
+        }
+        Err(error) => {
+            let elapsed = started_at.elapsed();
+            metrics_state.record_task_run(task, "failed", elapsed);
+            warn!(
+                event = "maintenance_subtask_result",
+                task,
+                outcome = "failed",
+                elapsed_ms = elapsed.as_millis() as u64,
+                error_class = "maintenance",
+                error = %error,
+                "maintenance subtask failed after execution"
+            )
+        }
     }
 }
 
@@ -89,6 +219,7 @@ async fn run(
     local_db: &LocalDB,
     btc_client: Arc<BTCClient>,
     goat_client: Arc<GOATClient>,
+    metrics_state: &MetricsState,
 ) -> anyhow::Result<MaintenanceRunOutcome> {
     let btc_client = btc_client.as_ref();
     let goat_client = goat_client.as_ref();
@@ -97,6 +228,7 @@ async fn run(
         && matches!(&actor, Actor::Verifier | Actor::Operator | Actor::All)
     {
         run_maintenance_subtask(
+            metrics_state,
             "babe_setup_state_cleanup_monitor",
             babe_setup_state_cleanup_monitor(local_db),
         )
@@ -105,6 +237,7 @@ async fn run(
 
     if actor == Actor::Operator || is_relayer() {
         run_maintenance_subtask(
+            metrics_state,
             "node_available_pbtc_update_monitor",
             node_available_pbtc_update_monitor(local_db, goat_client),
         )
@@ -113,6 +246,7 @@ async fn run(
 
     if is_enable_update_spv_contract() {
         run_maintenance_subtask(
+            metrics_state,
             "spv_header_hash_update",
             spv_header_hash_update(btc_client, goat_client),
         )
@@ -132,40 +266,63 @@ async fn run(
     }
 
     run_maintenance_subtask(
+        metrics_state,
         "instance_answers_monitor",
         instance_answers_monitor(local_db, btc_client, goat_client),
     )
     .await;
     run_maintenance_subtask(
+        metrics_state,
         "instance_window_expiration_monitor",
         instance_window_expiration_monitor(local_db, goat_client),
     )
     .await;
     run_maintenance_subtask(
+        metrics_state,
         "instance_expiration_monitor",
         instance_expiration_monitor(local_db, btc_client),
     )
     .await;
     run_maintenance_subtask(
+        metrics_state,
         "instance_btc_tx_monitor",
         instance_btc_tx_monitor(local_db, btc_client),
     )
     .await;
     run_maintenance_subtask(
+        metrics_state,
+        "pegin_confirm_recovery_monitor",
+        pegin_confirm_recovery_monitor(local_db, btc_client, &actor),
+    )
+    .await;
+    run_maintenance_subtask(
+        metrics_state,
         "instance_committee_key_cleanup_monitor",
         instance_committee_key_cleanup_monitor(local_db, btc_client),
     )
     .await;
-    run_maintenance_subtask("instance_bridge_out_monitor", instance_bridge_out_monitor(local_db))
+    run_maintenance_subtask(
+        metrics_state,
+        "instance_bridge_out_monitor",
+        instance_bridge_out_monitor(local_db),
+    )
+    .await;
+    run_maintenance_subtask(
+        metrics_state,
+        "detect_init_withdraw_call",
+        detect_init_withdraw_call(local_db),
+    )
+    .await;
+    run_maintenance_subtask(metrics_state, "detect_kickoff", detect_kickoff(local_db, btc_client))
         .await;
-    run_maintenance_subtask("detect_init_withdraw_call", detect_init_withdraw_call(local_db)).await;
-    run_maintenance_subtask("detect_kickoff", detect_kickoff(local_db, btc_client)).await;
     run_maintenance_subtask(
+        metrics_state,
         "detect_take1_or_challenge",
         detect_take1_or_challenge(local_db, btc_client),
     )
     .await;
     run_maintenance_subtask(
+        metrics_state,
         "process_graph_challenge",
         process_graph_challenge(local_db, btc_client),
     )
@@ -180,6 +337,7 @@ pub async fn run_maintenance_tasks(
     goat_client: Arc<GOATClient>,
     interval: u64,
     cancellation_token: CancellationToken,
+    metrics_state: MetricsState,
 ) -> anyhow::Result<String> {
     let mut tick: u64 = 0;
     let maintenance_run_timeout = Duration::from_secs(get_maintenance_run_timeout_secs());
@@ -198,9 +356,16 @@ pub async fn run_maintenance_tasks(
                 // Execute the normal monitoring logic
                 match tokio::time::timeout(
                     maintenance_run_timeout,
-                    run(actor.clone(),&local_db,btc_client.clone(),goat_client.clone()),
+                    run(
+                        actor.clone(),
+                        &local_db,
+                        btc_client.clone(),
+                        goat_client.clone(),
+                        &metrics_state,
+                    ),
                 ).await {
                     Ok(Ok(MaintenanceRunOutcome::Completed)) => {
+                        metrics_state.record_task_run("maintenance", "success", tick_start.elapsed());
                         info!(
                             event = "maintenance_tick_result",
                             tick,
@@ -210,6 +375,7 @@ pub async fn run_maintenance_tasks(
                         );
                     }
                     Ok(Ok(MaintenanceRunOutcome::DeferredHistorySync)) => {
+                        metrics_state.record_task_run("maintenance", "success", tick_start.elapsed());
                         info!(
                             event = "maintenance_tick_result",
                             tick,
@@ -220,6 +386,7 @@ pub async fn run_maintenance_tasks(
                         );
                     }
                     Ok(Err(error)) => {
+                        metrics_state.record_task_run("maintenance", "failed", tick_start.elapsed());
                         error!(
                             event = "maintenance_tick_result",
                             tick,
@@ -230,6 +397,7 @@ pub async fn run_maintenance_tasks(
                         )
                     }
                     Err(_) => {
+                        metrics_state.record_task_run("maintenance", "failed", tick_start.elapsed());
                         error!(
                             event = "maintenance_tick_result",
                             tick,
@@ -241,6 +409,26 @@ pub async fn run_maintenance_tasks(
                     }
                 }
                 if tick.is_multiple_of(6) {
+                    let btc_client = btc_client.clone();
+                    let goat_client = goat_client.clone();
+                    let metrics_state = metrics_state.clone();
+                    let metrics_actor = actor.clone();
+                    tokio::spawn(async move {
+                        if tokio::time::timeout(
+                            Duration::from_secs(30),
+                            refresh_alert_health(
+                                btc_client.as_ref(),
+                                goat_client.as_ref(),
+                                &metrics_state,
+                                &metrics_actor,
+                            ),
+                        )
+                        .await
+                        .is_err()
+                        {
+                            warn!(event = "metrics_alert_health", "alert health probe timed out");
+                        }
+                    });
                     let queue_started_at = Instant::now();
                     match local_db.acquire().await {
                         Ok(mut storage) => match storage
diff --git a/node/src/soldering_payload_store.rs b/node/src/soldering_payload_store.rs
index aa6835465..59a6657b6 100644
--- a/node/src/soldering_payload_store.rs
+++ b/node/src/soldering_payload_store.rs
@@ -50,6 +50,14 @@ fn parse_soldering_proof_s3_path(path: &str) -> Result<(String, String)> {
 }
 
 pub(crate) async fn write_soldering_proof_store_payload(path: &str, payload: &[u8]) -> Result<()> {
+    let result = write_soldering_proof_store_payload_inner(path, payload).await;
+    if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+        metrics_state.record_soldering_payload_io(result.is_ok());
+    }
+    result
+}
+
+async fn write_soldering_proof_store_payload_inner(path: &str, payload: &[u8]) -> Result<()> {
     if is_soldering_proof_s3_path(path) {
         let (bucket, key) = parse_soldering_proof_s3_path(path)?;
         let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
@@ -84,6 +92,14 @@ pub(crate) async fn write_soldering_proof_store_payload(path: &str, payload: &[u
 }
 
 pub(crate) async fn read_soldering_proof_store_payload(path: &str) -> Result<Vec<u8>> {
+    let result = read_soldering_proof_store_payload_inner(path).await;
+    if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+        metrics_state.record_soldering_payload_io(result.is_ok());
+    }
+    result
+}
+
+async fn read_soldering_proof_store_payload_inner(path: &str) -> Result<Vec<u8>> {
     if is_soldering_proof_s3_path(path) {
         let (bucket, key) = parse_soldering_proof_s3_path(path)?;
         let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
diff --git a/node/src/utils.rs b/node/src/utils.rs
index 6deaa1328..f064a3cef 100644
--- a/node/src/utils.rs
+++ b/node/src/utils.rs
@@ -15,7 +15,7 @@ use alloy::signers::Signer;
 use alloy::signers::local::PrivateKeySigner;
 use anyhow::{Context, Result, anyhow, bail};
 use bitcoin::address::NetworkUnchecked;
-use bitcoin::consensus::encode::{deserialize, serialize};
+use bitcoin::consensus::encode::deserialize;
 use bitcoin::hashes::Hash;
 use bitcoin::key::Keypair;
 use bitcoin::{
@@ -29,7 +29,9 @@ use bitcoin_light_client_circuit::{
 use bitvm::treepp::*;
 use bitvm_lib::actors::Actor;
 use bitvm_lib::committee::*;
-use bitvm_lib::keys::{OperatorMasterKey, VerifierMasterKey, WatchtowerMasterKey};
+use bitvm_lib::keys::{
+    CommitteeMasterKey, OperatorMasterKey, VerifierMasterKey, WatchtowerMasterKey,
+};
 use bitvm_lib::operator::*;
 use bitvm_lib::timelocks::{connector_f_timelock_blocks, default_timelock_config};
 use bitvm_lib::types::{
@@ -111,6 +113,21 @@ use zkm_verifier::{
 pub const SELF_SENDER: &str = "self";
 const BRIDGE_OUT_INSTANCE_ID_PREFIX: [u8; 4] = *b"BOID";
 
+pub(crate) fn load_committee_instance_keypair(
+    committee_master_key: &CommitteeMasterKey,
+    instance_id: Uuid,
+) -> Result<Keypair> {
+    let mut envelope_path = PathBuf::from(COMMITTEE_INSTANCE_KEYS_DIR);
+    envelope_path.push(format!("{instance_id}.json"));
+    committee_master_key.load_instance_keypair(instance_id, &envelope_path).with_context(|| {
+        format!(
+            "load committee instance keypair failed for {} at {}",
+            instance_id,
+            envelope_path.display()
+        )
+    })
+}
+
 /// Derive the shared bridge-out instance ID from its escrow hash.
 ///
 /// Both the RPC tag endpoint and the chain-event watcher must use this ID so
@@ -2260,62 +2277,6 @@ pub async fn get_fee_rate(client: &BTCClient) -> Result<f64> {
     }
 }
 
-pub async fn get_nst_fee_rate(client: &BTCClient) -> Result<f64> {
-    Ok(get_fee_rate(client).await? * 3.0)
-}
-
-pub async fn broadcast_nonstandard_tx(btc_client: &BTCClient, tx: &Transaction) -> Result<()> {
-    match broadcast_tx(btc_client, tx).await {
-        Ok(_) => Ok(()),
-        Err(e) => {
-            let network = btc_client.network();
-            let base_url = get_mara_slipstream_api_base_url(network);
-            let submit_url = format!("{}/transactions", base_url.trim_end_matches('/'));
-            let tx_hex = hex::encode(serialize(tx));
-
-            warn!(
-                "normal broadcast failed, fallback to MARA slipstream api. network: {network:?}, url: {submit_url}, err: {e}"
-            );
-
-            let response = reqwest::Client::new()
-                .post(&submit_url)
-                .json(&serde_json::json!({ "tx_hex": tx_hex }))
-                .send()
-                .await
-                .map_err(|fallback_err| {
-                    anyhow!(
-                        "fallback broadcast request failed. normal error: {e}; fallback error: {fallback_err}"
-                    )
-                })?;
-
-            let status = response.status();
-            let body = response
-                .text()
-                .await
-                .unwrap_or_else(|_| "<failed to read response body>".to_string());
-
-            if !status.is_success() {
-                bail!(
-                    "fallback broadcast failed. normal error: {e}; fallback status: {status}; fallback body: {body}"
-                );
-            }
-
-            let status_field = serde_json::from_str::<serde_json::Value>(&body)
-                .ok()
-                .and_then(|v| v.get("status").and_then(|s| s.as_str()).map(str::to_string));
-            if let Some(status_field) = status_field
-                && !status_field.eq_ignore_ascii_case("success")
-            {
-                bail!(
-                    "fallback broadcast returned non-success status. normal error: {e}; fallback body: {body}"
-                );
-            }
-
-            Ok(())
-        }
-    }
-}
-
 /// Broadcasts a raw transaction to the Bitcoin network using the mempool API.
 ///
 /// Requirements:
@@ -2326,6 +2287,9 @@ pub async fn broadcast_tx(client: &BTCClient, tx: &Transaction) -> Result<()> {
     let started_at = Instant::now();
     match client.broadcast(tx).await {
         Ok(()) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_btc_tx_broadcast(true);
+            }
             tracing::info!(
                 event = "btc_tx_broadcast",
                 outcome = "broadcasted",
@@ -2338,6 +2302,9 @@ pub async fn broadcast_tx(client: &BTCClient, tx: &Transaction) -> Result<()> {
             Ok(())
         }
         Err(err) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_btc_tx_broadcast(false);
+            }
             tracing::warn!(
                 event = "btc_tx_broadcast",
                 outcome = "failed",
@@ -2362,6 +2329,9 @@ pub async fn broadcast_package(
     let started_at = Instant::now();
     match client.broadcast_package(txns).await {
         Ok(_) => {
+            if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                metrics_state.record_btc_tx_broadcast(true);
+            }
             tracing::info!(
                 event = "btc_tx_package_broadcast",
                 outcome = "broadcasted",
@@ -2386,6 +2356,9 @@ pub async fn broadcast_package(
                     broadcast_tx(client, tx).await?;
                 }
             } else {
+                if let Some(metrics_state) = crate::metrics_service::node_metrics_state() {
+                    metrics_state.record_btc_tx_broadcast(false);
+                }
                 // Surface the original error when fallback is disabled
                 return Err(e);
             }
@@ -2523,21 +2496,36 @@ pub async fn get_watchtower_challenge_info(
     Ok(WatchtowerChallengeInfo { challenge_txids, included_watchtowers, resolved_branch_txids })
 }
 
-/// Returns `(btc_best_block_hash, included_watchtowers_bitmap)` using every confirmed
+/// Returns `(btc_best_block_hash, included_watchtowers_bitmap)` using every finalized
 /// challenge-branch resolution for the block hash while only challenges set bitmap bits.
+///
+/// The selected hash is signed into the operator's pubin and cannot be replaced after a
+/// reorganization. Require every branch that determines the bitmap to be at least as deeply
+/// buried as the header/SPV finality window before returning it.
 pub async fn compute_operator_pubin_blockhash_and_bitmap(
     btc_client: &BTCClient,
     resolved_branch_txids: &[Txid],
     included_watchtowers_bits: &[bool],
 ) -> Result<([u8; 32], [u8; 32])> {
+    let tip_height = btc_client.get_height().await?;
+    let required_burial_depth = get_btc_block_confirms(btc_client.network());
     let btc_best_block_hash = {
         let mut largest: Option<(u32, BlockHash)> = None;
         for txid in resolved_branch_txids {
             let status = btc_client.get_tx_status(txid).await?;
-            let (height, hash) = match (status.block_height, status.block_hash) {
-                (Some(height), Some(hash)) => (height, hash),
+            let (height, hash) = match (status.confirmed, status.block_height, status.block_hash) {
+                (true, Some(height), Some(hash)) => (height, hash),
                 _ => bail!("watchtower branch resolution tx {txid} is not confirmed yet"),
             };
+            // `BTC_BLOCK_CONFIRMS` is the number of blocks that must follow a block before
+            // the SPV/header pipeline consumes it. Match the proof-builder's strict boundary:
+            // the anchor must have more than this many blocks after it.
+            let burial_depth = tip_height.saturating_sub(height);
+            if burial_depth <= required_burial_depth {
+                bail!(
+                    "watchtower branch resolution tx {txid} is not final enough for operator pubin: height={height}, tip={tip_height}, burial_depth={burial_depth}, required_burial_depth>{required_burial_depth}"
+                );
+            }
             if largest.is_none_or(|(h, _)| height > h) {
                 largest = Some((height, hash));
             }
@@ -2942,68 +2930,6 @@ pub async fn build_sign_and_broadcast_tx(
     }
 }
 
-pub async fn build_sign_and_broadcast_non_standard_tx(
-    client: &BTCClient,
-    node_keypair: Keypair,
-    mut tx: Transaction,
-    total_input_amount: Amount,
-) -> Result<Txid> {
-    let fixed_inputs_num = tx.input.len();
-    let total_output_amount: Amount = tx.output.iter().map(|o| o.value).sum();
-    let fee_rate = get_nst_fee_rate(client).await?;
-    let node_address = node_p2wsh_address(get_network(), &node_keypair.public_key().into());
-    let shortfall =
-        Amount::from_sat(total_output_amount.to_sat().saturating_sub(total_input_amount.to_sat()));
-    match get_proper_utxo_set(
-        client,
-        tx.weight().to_vbytes_ceil(),
-        node_address.clone(),
-        shortfall,
-        fee_rate,
-    )
-    .await?
-    {
-        Some((inputs, _, change_amount)) => {
-            for input in &inputs {
-                tx.input.push(TxIn {
-                    previous_output: input.outpoint,
-                    script_sig: ScriptBuf::new(),
-                    sequence: Sequence::MAX,
-                    witness: Witness::default(),
-                });
-            }
-            if change_amount > Amount::from_sat(DUST_AMOUNT) {
-                tx.output.push(TxOut {
-                    script_pubkey: node_address.script_pubkey(),
-                    value: change_amount,
-                });
-            }
-            for (i, input) in inputs.iter().enumerate() {
-                node_sign(
-                    &mut tx,
-                    i + fixed_inputs_num,
-                    input.amount,
-                    EcdsaSighashType::All,
-                    &node_keypair,
-                )?;
-            }
-            broadcast_nonstandard_tx(client, &tx).await?;
-            Ok(tx.compute_txid())
-        }
-        None => {
-            let current_balance = client
-                .get_address_utxo(node_address)
-                .await?
-                .iter()
-                .map(|u| u.value)
-                .sum::<Amount>();
-            bail!(SpecialError::InsufficientBalance(format!(
-                "Not enough balance to complete the transaction, current_balance: {current_balance} < shortfall: {shortfall}"
-            )));
-        }
-    }
-}
-
 pub async fn build_cpfp_txns(
     btc_client: &BTCClient,
     parent_tx: &Transaction,
@@ -4568,7 +4494,9 @@ pub(crate) async fn store_operator_presigned_graph(
         )));
     }
 
-    let mut tx = local_db.start_transaction().await?;
+    // The definition path reads existing state before updating it. Reserve the
+    // writer up front so another task cannot invalidate that read snapshot.
+    let mut tx = local_db.start_immediate_transaction().await?;
     ingest_graph_definition(&mut tx, simple_graph, GraphDefinitionIngestKind::OperatorPresigned)
         .await?;
     tx.commit().await?;
@@ -4586,7 +4514,9 @@ pub(crate) async fn store_finalized_graph_if_needed(
         bail!(SpecialError::InvalidGraph(format!("graph {graph_id} is not fully pre-signed")));
     }
 
-    let mut tx = local_db.start_transaction().await?;
+    // The definition path reads existing state before updating it. Reserve the
+    // writer up front so another task cannot invalidate that read snapshot.
+    let mut tx = local_db.start_immediate_transaction().await?;
     let outcome =
         ingest_graph_definition(&mut tx, simple_graph, GraphDefinitionIngestKind::Finalized)
             .await?;
@@ -6209,8 +6139,10 @@ mod commit_pubin_tests {
 
         let init_txid = make_txid(0x00);
         let challenge_txid_wt0 = make_txid(0x01);
+        let timeout_txid_wt1 = make_txid(0x03);
         let challenge_txid_wt2 = make_txid(0x02);
         let block_hash_low = make_block_hash(0x10);
+        let block_hash_middle = make_block_hash(0x15);
         let block_hash_high = make_block_hash(0x20);
 
         let challenge_vout_0 =
@@ -6218,7 +6150,9 @@ mod commit_pubin_tests {
         let challenge_vout_2 =
             output_topology::watchtower_challenge_init::watchtower_connector(2) as u32;
 
-        // wt0 confirmed at height 100, wt2 at height 200 (highest)
+        // All three branches are finalized; wt2's height 200 block is the anchor.
+        let required_burial_depth = get_btc_block_confirms(btc_client.network());
+        mock_adaptor.set_height(200 + required_burial_depth + 1);
         mock_adaptor.set_tx(
             challenge_txid_wt0,
             create_confirmed_tx(
@@ -6228,6 +6162,10 @@ mod commit_pubin_tests {
                 block_hash_low,
             ),
         );
+        mock_adaptor.set_tx(
+            timeout_txid_wt1,
+            create_confirmed_tx(timeout_txid_wt1, &[(init_txid, 1)], 150, block_hash_middle),
+        );
         mock_adaptor.set_tx(
             challenge_txid_wt2,
             create_confirmed_tx(
@@ -6238,7 +6176,7 @@ mod commit_pubin_tests {
             ),
         );
 
-        let resolved_branch_txids = vec![challenge_txid_wt0, challenge_txid_wt2];
+        let resolved_branch_txids = vec![challenge_txid_wt0, timeout_txid_wt1, challenge_txid_wt2];
         let bits = vec![true, false, true];
 
         let (best_hash, bitmap) =
diff --git a/proof-builder-rpc/src/api/metrics_service.rs b/proof-builder-rpc/src/api/metrics_service.rs
index 4167ab214..960876cce 100644
--- a/proof-builder-rpc/src/api/metrics_service.rs
+++ b/proof-builder-rpc/src/api/metrics_service.rs
@@ -1,92 +1,441 @@
 use crate::api::ApiState;
-use axum::extract::{Request, State};
-use axum::http::HeaderMap;
+use crate::task::current_time_secs;
+use axum::extract::{MatchedPath, Request, State};
+use axum::http::{HeaderMap, StatusCode};
 use axum::middleware::Next;
-use axum::response::IntoResponse;
+use axum::response::{IntoResponse, Response};
 use prometheus_client::encoding::text::encode;
 use prometheus_client::metrics::counter::Counter;
 use prometheus_client::metrics::family::Family;
+use prometheus_client::metrics::gauge::Gauge;
 use prometheus_client::metrics::histogram::{Histogram, exponential_buckets};
 use prometheus_client::registry::Registry;
 use std::sync::{Arc, Mutex};
+use std::time::Duration;
 use tokio::time::Instant;
 
 const METRICS_CONTENT_TYPE: &str = "application/openmetrics-text;charset=utf-8;version=1.0.0";
+pub(crate) const HEADER_CHAIN_PROOF: &str = "header_chain";
+pub(crate) const COMMIT_CHAIN_PROOF: &str = "commit_chain";
+pub(crate) const STATE_CHAIN_PROOF: &str = "state_chain";
+pub(crate) const OPERATOR_PROOF: &str = "operator";
+pub(crate) const WATCHTOWER_PROOF: &str = "watchtower";
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
 struct HttpRequestLabels {
     method: String,
-    path: String,
+    route: String,
     status: u16,
 }
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct HttpDurationLabels {
+    method: String,
+    route: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct AttemptLabels {
+    proof_type: String,
+    outcome: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct ProofTypeLabels {
+    proof_type: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct ProofStateLabels {
+    proof_type: String,
+    state: String,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, prometheus_client::encoding::EncodeLabelSet)]
+struct ApiResultLabels {
+    operation: String,
+    result: String,
+}
+
 #[derive(Clone, Debug)]
-pub(super) struct ApiMetricsState {
-    pub registry: Arc<Mutex<Registry>>,
-    http_requests_total: Family<HttpRequestLabels, Counter>,
-    http_request_duration_seconds: Histogram,
-    http_requests_in_flight: prometheus_client::metrics::gauge::Gauge,
+pub(crate) struct ApiMetricsState {
+    registry: Arc<Mutex<Registry>>,
+    http_requests: Family<HttpRequestLabels, Counter>,
+    http_request_duration_seconds: Family<HttpDurationLabels, Histogram>,
+    http_requests_in_flight: Gauge,
+    proof_attempts: Family<AttemptLabels, Counter>,
+    proof_attempt_duration_seconds: Family<AttemptLabels, Histogram>,
+    proof_last_success_timestamp_seconds: Family<ProofTypeLabels, Gauge>,
+    proof_tasks: Family<ProofStateLabels, Gauge>,
+    proof_oldest_task_age_seconds: Family<ProofStateLabels, Gauge>,
+    api_results: Family<ApiResultLabels, Counter>,
+}
+
+struct InFlightGuard(Gauge);
+
+impl Drop for InFlightGuard {
+    /// Decrements the in-flight request gauge when request processing ends or is cancelled.
+    fn drop(&mut self) {
+        self.0.dec();
+    }
 }
 
 impl ApiMetricsState {
-    pub(super) fn new() -> Self {
+    /// Creates and registers the complete Proof Builder metric set.
+    pub(crate) fn new() -> Self {
         let registry = Arc::new(Mutex::new(Registry::default()));
-        let http_requests_total = Family::default();
-        registry.lock().unwrap().register(
-            "http_requests_total",
-            "Total number of requests",
-            http_requests_total.clone(),
-        );
+        let http_requests = Family::default();
+        let http_request_duration_seconds =
+            Family::<HttpDurationLabels, Histogram>::new_with_constructor(|| {
+                Histogram::new(exponential_buckets(0.005, 2.0, 15))
+            });
+        let http_requests_in_flight = Gauge::default();
+        let proof_attempts = Family::default();
+        let proof_attempt_duration_seconds =
+            Family::<AttemptLabels, Histogram>::new_with_constructor(|| {
+                Histogram::new(exponential_buckets(1.0, 2.0, 18))
+            });
+        let proof_last_success_timestamp_seconds = Family::default();
+        let proof_tasks = Family::default();
+        let proof_oldest_task_age_seconds = Family::default();
+        let api_results = Family::default();
 
-        let http_request_duration_seconds = Histogram::new(exponential_buckets(1.01, 2.0, 10));
-        registry.lock().unwrap().register(
+        let mut registry_guard = registry.lock().unwrap();
+        registry_guard.register(
+            "http_requests",
+            "Total number of HTTP requests",
+            http_requests.clone(),
+        );
+        registry_guard.register(
             "http_request_duration_seconds",
             "HTTP request duration in seconds",
             http_request_duration_seconds.clone(),
         );
-        let http_requests_in_flight = prometheus_client::metrics::gauge::Gauge::default();
-        registry.lock().unwrap().register(
+        registry_guard.register(
             "http_requests_in_flight",
             "Number of HTTP requests currently being processed",
             http_requests_in_flight.clone(),
         );
+        registry_guard.register(
+            "bitvm_proof_builder_attempts",
+            "Total number of proof build attempts",
+            proof_attempts.clone(),
+        );
+        registry_guard.register(
+            "bitvm_proof_builder_attempt_duration_seconds",
+            "Proof attempt duration in seconds",
+            proof_attempt_duration_seconds.clone(),
+        );
+        registry_guard.register(
+            "bitvm_proof_builder_last_success_timestamp_seconds",
+            "Unix timestamp of the latest successful proof",
+            proof_last_success_timestamp_seconds.clone(),
+        );
+        registry_guard.register(
+            "bitvm_proof_builder_tasks",
+            "Number of persisted proof tasks by state",
+            proof_tasks.clone(),
+        );
+        registry_guard.register(
+            "bitvm_proof_builder_oldest_task_age_seconds",
+            "Age of the oldest persisted proof task by state",
+            proof_oldest_task_age_seconds.clone(),
+        );
+        registry_guard.register(
+            "bitvm_proof_builder_api_results",
+            "Total number of Proof Builder API business results",
+            api_results.clone(),
+        );
+        drop(registry_guard);
 
         Self {
             registry,
-            http_requests_total,
+            http_requests,
             http_request_duration_seconds,
             http_requests_in_flight,
+            proof_attempts,
+            proof_attempt_duration_seconds,
+            proof_last_success_timestamp_seconds,
+            proof_tasks,
+            proof_oldest_task_age_seconds,
+            api_results,
         }
     }
+
+    /// Records one proof attempt with its proof type, outcome, and end-to-end duration.
+    pub(crate) fn record_attempt(&self, proof_type: &str, outcome: &str, duration: Duration) {
+        let labels =
+            AttemptLabels { proof_type: proof_type.to_owned(), outcome: outcome.to_owned() };
+        self.proof_attempts.get_or_create(&labels).inc();
+        self.proof_attempt_duration_seconds.get_or_create(&labels).observe(duration.as_secs_f64());
+    }
+
+    /// Creates a guard that records a failed API business result unless explicitly updated.
+    pub(crate) fn api_result(&self, operation: &'static str) -> ApiResultGuard {
+        ApiResultGuard { metrics: self.clone(), operation, result: "failed" }
+    }
+
+    /// Rebuilds proof task counts, ages, and success timestamps from persisted state rows.
+    fn refresh_proof_snapshot(&self, rows: &[store::MetricsStateCount], now: i64) {
+        self.proof_last_success_timestamp_seconds.clear();
+        self.proof_tasks.clear();
+        self.proof_oldest_task_age_seconds.clear();
+        for row in rows {
+            let Some(proof_type) = proof_type_label(&row.category) else {
+                continue;
+            };
+            let state = proof_state_label(&row.state);
+            let labels =
+                ProofStateLabels { proof_type: proof_type.to_owned(), state: state.to_owned() };
+            self.proof_tasks.get_or_create(&labels).inc_by(row.count);
+            if matches!(state, "new" | "proving") {
+                let age = row
+                    .oldest_created_at
+                    .map_or(0, |created_at| now.saturating_sub(created_at).max(0));
+                let oldest_age = self.proof_oldest_task_age_seconds.get_or_create(&labels);
+                oldest_age.set(oldest_age.get().max(age));
+            }
+            if let Some(last_success_at) = row.last_success_at {
+                let gauge = self
+                    .proof_last_success_timestamp_seconds
+                    .get_or_create(&ProofTypeLabels { proof_type: proof_type.to_owned() });
+                gauge.set(gauge.get().max(last_success_at));
+            }
+        }
+    }
+
+    /// Refreshes persisted proof metrics and encodes the complete registry.
+    fn scrape(
+        &self,
+        rows: &[store::MetricsStateCount],
+        now: i64,
+    ) -> Result<String, std::fmt::Error> {
+        let mut buffer = String::new();
+        let registry = self.registry.lock().unwrap();
+        self.refresh_proof_snapshot(rows, now);
+        encode(&mut buffer, &registry)?;
+        Ok(buffer)
+    }
+}
+
+pub(crate) struct ApiResultGuard {
+    metrics: ApiMetricsState,
+    operation: &'static str,
+    result: &'static str,
+}
+
+impl ApiResultGuard {
+    /// Sets the business result that the guard records when dropped.
+    pub(crate) fn set(&mut self, result: &'static str) {
+        self.result = result;
+    }
+}
+
+impl Drop for ApiResultGuard {
+    /// Records the final API business result when handler execution leaves the scope.
+    fn drop(&mut self) {
+        self.metrics
+            .api_results
+            .get_or_create(&ApiResultLabels {
+                operation: self.operation.to_owned(),
+                result: self.result.to_owned(),
+            })
+            .inc();
+    }
 }
 
 pub(super) async fn metrics_middleware(
-    state: State<Arc<ApiState>>,
+    State(state): State<Arc<ApiState>>,
     request: Request,
     next: Next,
 ) -> impl IntoResponse {
     let start = Instant::now();
-    let path = if let Some(route) = request.extensions().get::<axum::extract::MatchedPath>() {
-        route.as_str().to_owned()
-    } else {
-        request.uri().path().to_owned()
-    };
+    let route = request
+        .extensions()
+        .get::<MatchedPath>()
+        .map_or("unmatched", MatchedPath::as_str)
+        .to_owned();
     let method = request.method().to_string();
+    state.metrics_state.http_requests_in_flight.inc();
+    let in_flight = InFlightGuard(state.metrics_state.http_requests_in_flight.clone());
     let response = next.run(request).await;
-    state.metrics_state.http_requests_in_flight.dec();
+    drop(in_flight);
     let status = response.status().as_u16();
     state
         .metrics_state
-        .http_requests_total
-        .get_or_create(&HttpRequestLabels { method, path, status })
+        .http_requests
+        .get_or_create(&HttpRequestLabels { method: method.clone(), route: route.clone(), status })
         .inc();
-
-    state.metrics_state.http_request_duration_seconds.observe(start.elapsed().as_secs_f64());
+    state
+        .metrics_state
+        .http_request_duration_seconds
+        .get_or_create(&HttpDurationLabels { method, route })
+        .observe(start.elapsed().as_secs_f64());
     response
 }
 
-pub(super) async fn metrics_handler(State(app_state): State<Arc<ApiState>>) -> impl IntoResponse {
+/// Refreshes database-backed proof metrics and returns the encoded metrics response.
+pub(super) async fn metrics_handler(State(app_state): State<Arc<ApiState>>) -> Response {
+    let rows = match app_state.local_db.acquire().await {
+        Ok(mut storage_processor) => match storage_processor.proof_metrics_state_counts().await {
+            Ok(rows) => rows,
+            Err(error) => {
+                tracing::warn!("Failed to query proof metrics: {error}");
+                return StatusCode::SERVICE_UNAVAILABLE.into_response();
+            }
+        },
+        Err(error) => {
+            tracing::warn!("Failed to acquire database for proof metrics: {error}");
+            return StatusCode::SERVICE_UNAVAILABLE.into_response();
+        }
+    };
     let mut headers = HeaderMap::new();
     headers.insert(axum::http::header::CONTENT_TYPE, METRICS_CONTENT_TYPE.parse().unwrap());
-    let mut buffer = String::new();
-    encode(&mut buffer, &app_state.metrics_state.registry.lock().unwrap()).unwrap();
-    (headers, buffer)
+    match app_state.metrics_state.scrape(&rows, current_time_secs()) {
+        Ok(buffer) => (headers, buffer).into_response(),
+        Err(error) => {
+            tracing::error!(error = %error, "failed to encode proof builder metrics");
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        }
+    }
+}
+
+/// Maps a persisted proof category to its bounded Prometheus proof-type label.
+fn proof_type_label(category: &str) -> Option<&'static str> {
+    match category {
+        "header-chain" => Some("header_chain"),
+        "commit-chain" => Some("commit_chain"),
+        "state-chain" => Some("state_chain"),
+        "operator" => Some("operator"),
+        "watchtower" => Some("watchtower"),
+        _ => None,
+    }
+}
+
+/// Maps a persisted numeric proof state to its bounded Prometheus state label.
+fn proof_state_label(state: &str) -> &'static str {
+    match state {
+        "0" => "new",
+        "1" => "proving",
+        "2" => "proven",
+        "3" => "failed",
+        _ => "unknown",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exports_bounded_http_and_business_metrics() {
+        let metrics = ApiMetricsState::new();
+        metrics
+            .http_requests
+            .get_or_create(&HttpRequestLabels {
+                method: "GET".to_owned(),
+                route: "/v1/proofs/:id".to_owned(),
+                status: 200,
+            })
+            .inc();
+        metrics
+            .http_request_duration_seconds
+            .get_or_create(&HttpDurationLabels {
+                method: "GET".to_owned(),
+                route: "/v1/proofs/:id".to_owned(),
+            })
+            .observe(0.01);
+        metrics.http_requests_in_flight.inc();
+        {
+            let _in_flight = InFlightGuard(metrics.http_requests_in_flight.clone());
+            assert_eq!(metrics.http_requests_in_flight.get(), 1);
+        }
+        assert_eq!(metrics.http_requests_in_flight.get(), 0);
+        metrics.record_attempt("operator", "failed", Duration::from_secs(1));
+        metrics.record_attempt("watchtower", "success", Duration::from_secs(2));
+        {
+            let mut result = metrics.api_result("operator_submit");
+            result.set("pending");
+        }
+
+        let output = metrics.scrape(&[], 0).unwrap();
+        assert!(output.contains("http_requests_total"));
+        assert!(!output.contains("http_requests_total_total"));
+        assert!(output.contains("route=\"/v1/proofs/:id\""));
+        assert!(output.contains("bitvm_proof_builder_attempts_total"));
+        assert!(output.contains("proof_type=\"watchtower\",outcome=\"success\""));
+        assert!(output.contains("http_requests_in_flight 0"));
+        assert!(output.contains("bitvm_proof_builder_api_results_total"));
+    }
+
+    #[test]
+    fn refreshes_observed_proof_state_series() {
+        let metrics = ApiMetricsState::new();
+        let output = metrics
+            .scrape(
+                &[
+                    store::MetricsStateCount {
+                        category: "header-chain".to_owned(),
+                        state: "0".to_owned(),
+                        count: 2,
+                        oldest_created_at: Some(90),
+                        last_success_at: None,
+                    },
+                    store::MetricsStateCount {
+                        category: "operator".to_owned(),
+                        state: "unexpected".to_owned(),
+                        count: 1,
+                        oldest_created_at: Some(80),
+                        last_success_at: None,
+                    },
+                    store::MetricsStateCount {
+                        category: "operator".to_owned(),
+                        state: "4".to_owned(),
+                        count: 2,
+                        oldest_created_at: Some(70),
+                        last_success_at: None,
+                    },
+                    store::MetricsStateCount {
+                        category: "operator".to_owned(),
+                        state: "2".to_owned(),
+                        count: 1,
+                        oldest_created_at: Some(90),
+                        last_success_at: Some(95),
+                    },
+                    store::MetricsStateCount {
+                        category: "arbitrary-user-value".to_owned(),
+                        state: "0".to_owned(),
+                        count: 99,
+                        oldest_created_at: Some(1),
+                        last_success_at: None,
+                    },
+                ],
+                100,
+            )
+            .unwrap();
+        assert!(
+            output
+                .contains("bitvm_proof_builder_tasks{proof_type=\"header_chain\",state=\"new\"} 2")
+        );
+        assert!(
+            output.contains(
+                "bitvm_proof_builder_oldest_task_age_seconds{proof_type=\"header_chain\",state=\"new\"} 10"
+            )
+        );
+        assert!(
+            output
+                .contains("bitvm_proof_builder_tasks{proof_type=\"operator\",state=\"unknown\"} 3")
+        );
+        assert!(output.contains(
+            "bitvm_proof_builder_last_success_timestamp_seconds{proof_type=\"operator\"} 95"
+        ));
+        assert!(
+            !output.contains("bitvm_proof_builder_oldest_task_age_seconds{proof_type=\"operator\"")
+        );
+        assert!(
+            !output
+                .contains("bitvm_proof_builder_tasks{proof_type=\"header_chain\",state=\"failed\"")
+        );
+        assert!(!output.contains("arbitrary-user-value"));
+    }
 }
diff --git a/proof-builder-rpc/src/api/mod.rs b/proof-builder-rpc/src/api/mod.rs
index 8ad9cfa07..b24288b54 100644
--- a/proof-builder-rpc/src/api/mod.rs
+++ b/proof-builder-rpc/src/api/mod.rs
@@ -1,4 +1,4 @@
-mod metrics_service;
+pub(crate) mod metrics_service;
 mod proof_handler;
 mod response;
 pub(crate) mod routes;
@@ -10,7 +10,7 @@ use crate::api::proof_handler::{
     post_watchtower_proof_task, update_operator_proof_task_timeout,
     update_watchtower_proof_task_timeout,
 };
-use axum::http::Method;
+use axum::http::{Method, StatusCode};
 use axum::routing::{get, post};
 use axum::{Router, middleware};
 use std::sync::Arc;
@@ -25,20 +25,20 @@ struct ApiState {
 }
 
 impl ApiState {
-    pub(crate) async fn create_arc_app_state(local_db: LocalDB) -> anyhow::Result<Arc<ApiState>> {
-        let metrics_state = ApiMetricsState::new();
-        Ok(Arc::new(ApiState { local_db, metrics_state }))
+    /// Creates shared API state from the database and metrics registry.
+    fn new(local_db: LocalDB, metrics_state: ApiMetricsState) -> Arc<ApiState> {
+        Arc::new(ApiState { local_db, metrics_state })
     }
 }
 pub(crate) async fn serve(
     addr: String,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     cancellation_token: CancellationToken,
 ) -> anyhow::Result<String> {
-    let api_state = ApiState::create_arc_app_state(local_db).await?;
-    let server = Router::new()
+    let api_state = ApiState::new(local_db, metrics_state);
+    let instrumented_routes = Router::new()
         .route(routes::ROOT, get(root))
-        .route(routes::METRICS, get(metrics_handler))
         .route(routes::v1::PROOFS_CHAIN_PROOFS_DESC, get(get_chain_proof_task_desc))
         .route(routes::v1::PROOFS_WATCHTOWER_PROOF, post(post_watchtower_proof_task))
         .route(
@@ -48,7 +48,11 @@ pub(crate) async fn serve(
         .route(routes::v1::PROOFS_OPERATOR_PROOF, post(post_operator_proof_task))
         .route(routes::v1::PROOFS_OPERATOR_PROOF_TIMEOUT, post(update_operator_proof_task_timeout))
         .route(routes::v1::PROOFS_OPERATOR_PROOF_DESC, get(get_operator_proof_task_desc))
-        .layer(middleware::from_fn_with_state(api_state.clone(), metrics_middleware))
+        .fallback(|| async { StatusCode::NOT_FOUND })
+        .layer(middleware::from_fn_with_state(api_state.clone(), metrics_middleware));
+    let server = Router::new()
+        .route(routes::METRICS, get(metrics_handler))
+        .merge(instrumented_routes)
         .layer(CorsLayer::new().allow_headers(Any).allow_origin(Any).allow_methods(vec![
             Method::GET,
             Method::POST,
@@ -78,3 +82,63 @@ pub(crate) async fn serve(
 async fn root() -> &'static str {
     "Hello, World!"
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    fn available_addr() -> String {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        listener.local_addr().unwrap().to_string()
+    }
+
+    async fn get(addr: &str, path: &str) -> anyhow::Result<String> {
+        let mut stream = tokio::net::TcpStream::connect(addr).await?;
+        stream
+            .write_all(
+                format!("GET {path} HTTP/1.1\r\nHost: {addr}\r\nConnection: close\r\n\r\n")
+                    .as_bytes(),
+            )
+            .await?;
+        let mut response = Vec::new();
+        stream.read_to_end(&mut response).await?;
+        Ok(String::from_utf8(response)?)
+    }
+
+    #[tokio::test]
+    async fn metrics_use_route_templates_and_exclude_scrapes() -> anyhow::Result<()> {
+        let addr = available_addr();
+        let cancellation_token = CancellationToken::new();
+        let server_token = cancellation_token.clone();
+        let server = tokio::spawn(serve(
+            addr.clone(),
+            store::create_local_db("sqlite::memory:").await,
+            ApiMetricsState::new(),
+            server_token,
+        ));
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+        assert!(get(&addr, "/").await?.starts_with("HTTP/1.1 200"));
+        assert!(get(&addr, "/missing").await?.starts_with("HTTP/1.1 404"));
+        let first_scrape = get(&addr, "/metrics").await?;
+        let second_scrape = get(&addr, "/metrics").await?;
+
+        assert!(
+            first_scrape
+                .contains("http_requests_total{method=\"GET\",route=\"/\",status=\"200\"} 1")
+        );
+        assert!(
+            first_scrape.contains(
+                "http_requests_total{method=\"GET\",route=\"unmatched\",status=\"404\"} 1"
+            )
+        );
+        assert!(first_scrape.contains("http_requests_in_flight 0"));
+        assert!(!first_scrape.contains("route=\"/metrics\""));
+        assert!(!second_scrape.contains("route=\"/metrics\""));
+
+        cancellation_token.cancel();
+        server.await??;
+        Ok(())
+    }
+}
diff --git a/proof-builder-rpc/src/api/proof_handler.rs b/proof-builder-rpc/src/api/proof_handler.rs
index d55eb949a..30511b924 100644
--- a/proof-builder-rpc/src/api/proof_handler.rs
+++ b/proof-builder-rpc/src/api/proof_handler.rs
@@ -1,4 +1,5 @@
 use crate::api::ApiState;
+use crate::api::metrics_service::ApiResultGuard;
 use crate::api::response::{ApiErrorExt, ApiResult, ok_response};
 use crate::api::validation::InputValidator;
 use crate::task::{
@@ -17,11 +18,17 @@ use std::sync::Arc;
 use store::ProofState;
 use tracing::info;
 
+/// Marks validation failures as invalid API results while preserving the original result.
+fn record_invalid<T, E>(api_result: &mut ApiResultGuard, result: Result<T, E>) -> Result<T, E> {
+    result.inspect_err(|_| api_result.set("invalid"))
+}
+
 #[axum::debug_handler]
 pub(super) async fn get_chain_proof_task_desc(
     State(api_state): State<Arc<ApiState>>,
     Query(payload): Query<ChainProofDescRequest>,
 ) -> ApiResult<ProofDescResponse> {
+    let mut api_result = api_state.metrics_state.api_result("chain_desc");
     let mut storage_process =
         api_state.local_db.acquire().await.api_error("GET_CHAIN_PROOF_ERROR")?;
 
@@ -61,6 +68,13 @@ pub(super) async fn get_chain_proof_task_desc(
                 .api_error("GET_CHAIN_PROOF_ERROR")?
                 .map(|v| v.block_start);
 
+            api_result.set(if proof.proof_state == ProofState::Proven.to_i64() {
+                "ready"
+            } else if proof.proof_state == ProofState::Failed.to_i64() {
+                "failed"
+            } else {
+                "pending"
+            });
             ok_response(ProofDescResponse {
                 proof_desc: Some(ProofDesc {
                     block_start: proof.block_start,
@@ -84,10 +98,13 @@ pub(super) async fn get_chain_proof_task_desc(
             })
         }
 
-        None => ok_response(ProofDescResponse {
-            proof_desc: None,
-            error: Some("No proof found".to_string()),
-        }),
+        None => {
+            api_result.set("not_found");
+            ok_response(ProofDescResponse {
+                proof_desc: None,
+                error: Some("No proof found".to_string()),
+            })
+        }
     }
 }
 
@@ -96,13 +113,27 @@ pub(super) async fn get_operator_proof_task_desc(
     State(api_state): State<Arc<ApiState>>,
     Query(payload): Query<OperatorProofDescRequest>,
 ) -> ApiResult<ProofDescResponse> {
-    let instance_id = InputValidator::validate_uuid(&payload.instance_id, "instance_id")?;
-    let graph_id = InputValidator::validate_uuid(&payload.graph_id, "graph_id")?;
+    let mut api_result = api_state.metrics_state.api_result("operator_desc");
+    let instance_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.instance_id, "instance_id"),
+    )?;
+    let graph_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.graph_id, "graph_id"),
+    )?;
     let operator_proof = find_operator_task(&api_state.local_db, instance_id, graph_id)
         .await
         .api_error("POST_OPERATOR_PROOF_TASK_ERROR")?;
     match operator_proof {
         Some(operator_proof) => {
+            api_result.set(if operator_proof.proof_state == ProofState::Proven.to_i64() {
+                "ready"
+            } else if operator_proof.proof_state == ProofState::Failed.to_i64() {
+                "failed"
+            } else {
+                "pending"
+            });
             info!("Get Operator Proof:{operator_proof:?}");
             ok_response(ProofDescResponse {
                 proof_desc: Some(ProofDesc {
@@ -126,10 +157,13 @@ pub(super) async fn get_operator_proof_task_desc(
                 error: None,
             })
         }
-        None => ok_response(ProofDescResponse {
-            proof_desc: None,
-            error: Some("No proof found".to_string()),
-        }),
+        None => {
+            api_result.set("not_found");
+            ok_response(ProofDescResponse {
+                proof_desc: None,
+                error: Some("No proof found".to_string()),
+            })
+        }
     }
 }
 
@@ -138,8 +172,15 @@ pub(super) async fn post_operator_proof_task(
     State(api_state): State<Arc<ApiState>>,
     Json(payload): Json<OperatorProofRequest>,
 ) -> ApiResult<OperatorProofResponse> {
-    let instance_id = InputValidator::validate_uuid(&payload.instance_id, "instance_id")?;
-    let graph_id = InputValidator::validate_uuid(&payload.graph_id, "graph_id")?;
+    let mut api_result = api_state.metrics_state.api_result("operator_submit");
+    let instance_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.instance_id, "instance_id"),
+    )?;
+    let graph_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.graph_id, "graph_id"),
+    )?;
     let operator_proof = find_operator_task(&api_state.local_db, instance_id, graph_id)
         .await
         .api_error("POST_OPERATOR_PROOF_TASK_ERROR")?;
@@ -148,6 +189,7 @@ pub(super) async fn post_operator_proof_task(
             if operator_proof.proof_state == ProofState::Proven.to_i64()
                 && operator_proof.path_to_proof.is_some() =>
         {
+            api_result.set("ready");
             ok_response(OperatorProofResponse {
                 proof_data: Some(ProofData::load_proof_data(
                     &operator_proof.path_to_proof.unwrap(),
@@ -156,13 +198,20 @@ pub(super) async fn post_operator_proof_task(
                 error: None,
             })
         }
-        Some(operator_proof) => ok_response(OperatorProofResponse {
-            proof_data: None,
-            error: Some(format!(
-                "The proof is not ready, state {}, path:{:?}",
-                operator_proof.proof_state, operator_proof.path_to_proof
-            )),
-        }),
+        Some(operator_proof) => {
+            api_result.set(if operator_proof.proof_state == ProofState::Failed.to_i64() {
+                "failed"
+            } else {
+                "pending"
+            });
+            ok_response(OperatorProofResponse {
+                proof_data: None,
+                error: Some(format!(
+                    "The proof is not ready, state {}, path:{:?}",
+                    operator_proof.proof_state, operator_proof.path_to_proof
+                )),
+            })
+        }
 
         None => {
             add_operator_task(
@@ -178,6 +227,7 @@ pub(super) async fn post_operator_proof_task(
             )
             .await
             .api_error("POST_OPERATOR_PROOF_TASK_ERROR")?;
+            api_result.set("created");
             ok_response(OperatorProofResponse {
                 proof_data: None,
                 error: Some("No proof found".to_string()),
@@ -191,8 +241,15 @@ pub(super) async fn update_operator_proof_task_timeout(
     State(api_state): State<Arc<ApiState>>,
     Json(payload): Json<OperatorProofTimeoutUpdateRequest>,
 ) -> ApiResult<OperatorProofTimeoutUpdateResponse> {
-    let instance_id = InputValidator::validate_uuid(&payload.instance_id, "instance_id")?;
-    let graph_id = InputValidator::validate_uuid(&payload.graph_id, "graph_id")?;
+    let mut api_result = api_state.metrics_state.api_result("operator_timeout");
+    let instance_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.instance_id, "instance_id"),
+    )?;
+    let graph_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.graph_id, "graph_id"),
+    )?;
     match update_operator_task_state(
         &api_state.local_db,
         instance_id,
@@ -202,18 +259,24 @@ pub(super) async fn update_operator_proof_task_timeout(
     )
     .await
     {
-        Ok(rows_affected) => ok_response(OperatorProofTimeoutUpdateResponse {
-            instance_id: instance_id.to_string(),
-            graph_id: graph_id.to_string(),
-            data: Some(format!("{rows_affected} rows affected")),
-            error: None,
-        }),
-        Err(error) => ok_response(OperatorProofTimeoutUpdateResponse {
-            instance_id: instance_id.to_string(),
-            graph_id: graph_id.to_string(),
-            data: None,
-            error: Some(format!("update error: {error}")),
-        }),
+        Ok(rows_affected) => {
+            api_result.set(if rows_affected == 0 { "not_found" } else { "updated" });
+            ok_response(OperatorProofTimeoutUpdateResponse {
+                instance_id: instance_id.to_string(),
+                graph_id: graph_id.to_string(),
+                data: Some(format!("{rows_affected} rows affected")),
+                error: None,
+            })
+        }
+        Err(error) => {
+            api_result.set("failed");
+            ok_response(OperatorProofTimeoutUpdateResponse {
+                instance_id: instance_id.to_string(),
+                graph_id: graph_id.to_string(),
+                data: None,
+                error: Some(format!("update error: {error}")),
+            })
+        }
     }
 }
 
@@ -222,11 +285,20 @@ pub(super) async fn post_watchtower_proof_task(
     State(api_state): State<Arc<ApiState>>,
     Json(payload): Json<WatchtowerProofRequest>,
 ) -> ApiResult<WatchtowerProofResponse> {
-    let instance_id = InputValidator::validate_uuid(&payload.instance_id, "instance_id")?;
-    let graph_id = InputValidator::validate_uuid(&payload.graph_id, "graph_id")?;
-    let challenge_init_txid =
-        InputValidator::validate_btc_txid(&payload.challenge_init_txid, "challenge_init_txid")?
-            .to_string();
+    let mut api_result = api_state.metrics_state.api_result("watchtower_submit");
+    let instance_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.instance_id, "instance_id"),
+    )?;
+    let graph_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.graph_id, "graph_id"),
+    )?;
+    let challenge_init_txid = record_invalid(
+        &mut api_result,
+        InputValidator::validate_btc_txid(&payload.challenge_init_txid, "challenge_init_txid"),
+    )?
+    .to_string();
 
     let watchtower_proof =
         find_watchtower_task(&api_state.local_db, instance_id, graph_id, &payload.public_key)
@@ -238,6 +310,7 @@ pub(super) async fn post_watchtower_proof_task(
             if watchtower_proof.proof_state == ProofState::Proven.to_i64()
                 && watchtower_proof.path_to_proof.is_some() =>
         {
+            api_result.set("ready");
             ok_response(WatchtowerProofResponse {
                 proof_data: Some(ProofData::load_proof_data(
                     &watchtower_proof.path_to_proof.unwrap(),
@@ -246,13 +319,20 @@ pub(super) async fn post_watchtower_proof_task(
                 error: None,
             })
         }
-        Some(watchtower_proof) => ok_response(WatchtowerProofResponse {
-            proof_data: None,
-            error: Some(format!(
-                "No proof is not ready, state {}, path:{:?}",
-                watchtower_proof.proof_state, watchtower_proof.path_to_proof
-            )),
-        }),
+        Some(watchtower_proof) => {
+            api_result.set(if watchtower_proof.proof_state == ProofState::Failed.to_i64() {
+                "failed"
+            } else {
+                "pending"
+            });
+            ok_response(WatchtowerProofResponse {
+                proof_data: None,
+                error: Some(format!(
+                    "No proof is not ready, state {}, path:{:?}",
+                    watchtower_proof.proof_state, watchtower_proof.path_to_proof
+                )),
+            })
+        }
 
         None => {
             add_watchtower_task(
@@ -265,6 +345,7 @@ pub(super) async fn post_watchtower_proof_task(
             )
             .await
             .api_error("POST_WATCHTOWER_PROOF_TASK_ERROR")?;
+            api_result.set("created");
             ok_response(WatchtowerProofResponse {
                 proof_data: None,
                 error: Some("No proof found".to_string()),
@@ -278,8 +359,15 @@ pub(super) async fn update_watchtower_proof_task_timeout(
     State(api_state): State<Arc<ApiState>>,
     Json(payload): Json<WatchtowerProofTimeoutUpdateRequest>,
 ) -> ApiResult<WatchtowerProofTimeoutUpdateResponse> {
-    let instance_id = InputValidator::validate_uuid(&payload.instance_id, "instance_id")?;
-    let graph_id = InputValidator::validate_uuid(&payload.graph_id, "graph_id")?;
+    let mut api_result = api_state.metrics_state.api_result("watchtower_timeout");
+    let instance_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.instance_id, "instance_id"),
+    )?;
+    let graph_id = record_invalid(
+        &mut api_result,
+        InputValidator::validate_uuid(&payload.graph_id, "graph_id"),
+    )?;
     match update_watchtower_task_state(
         &api_state.local_db,
         instance_id,
@@ -290,19 +378,25 @@ pub(super) async fn update_watchtower_proof_task_timeout(
     )
     .await
     {
-        Ok(rows_affected) => ok_response(WatchtowerProofTimeoutUpdateResponse {
-            instance_id: instance_id.to_string(),
-            graph_id: graph_id.to_string(),
-            public_key: payload.public_key.clone(),
-            data: Some(format!("{rows_affected} rows affected")),
-            error: None,
-        }),
-        Err(error) => ok_response(WatchtowerProofTimeoutUpdateResponse {
-            instance_id: instance_id.to_string(),
-            graph_id: graph_id.to_string(),
-            public_key: payload.public_key.clone(),
-            data: None,
-            error: Some(format!("update error: {error}")),
-        }),
+        Ok(rows_affected) => {
+            api_result.set(if rows_affected == 0 { "not_found" } else { "updated" });
+            ok_response(WatchtowerProofTimeoutUpdateResponse {
+                instance_id: instance_id.to_string(),
+                graph_id: graph_id.to_string(),
+                public_key: payload.public_key.clone(),
+                data: Some(format!("{rows_affected} rows affected")),
+                error: None,
+            })
+        }
+        Err(error) => {
+            api_result.set("failed");
+            ok_response(WatchtowerProofTimeoutUpdateResponse {
+                instance_id: instance_id.to_string(),
+                graph_id: graph_id.to_string(),
+                public_key: payload.public_key.clone(),
+                data: None,
+                error: Some(format!("update error: {error}")),
+            })
+        }
     }
 }
diff --git a/proof-builder-rpc/src/main.rs b/proof-builder-rpc/src/main.rs
index 099edb19d..2b263215d 100644
--- a/proof-builder-rpc/src/main.rs
+++ b/proof-builder-rpc/src/main.rs
@@ -3,6 +3,7 @@ mod config;
 mod task;
 
 use crate::task::{is_start_generate_proof_tasks, run_generate_proof_tasks};
+use api::metrics_service::ApiMetricsState;
 use clap::Parser;
 use futures::future;
 use tokio::signal;
@@ -41,13 +42,16 @@ async fn main() -> anyhow::Result<()> {
     let cancellation_token = CancellationToken::new();
     info!("load db {}", opt.database_url);
     let local_db = store::create_local_db(&opt.database_url).await;
+    let metrics_state = ApiMetricsState::new();
     let local_db_clone1 = local_db.clone();
+    let api_metrics_state = metrics_state.clone();
     let mut task_handles: Vec<JoinHandle<anyhow::Result<String, String>>> = vec![];
     let cancel_token_clone = cancellation_token.clone();
     let opt_rpc_addr = opt.rpc_addr.clone();
     info!("start api server");
     task_handles.push(tokio::spawn(async move {
-        match api::serve(opt_rpc_addr, local_db_clone1, cancel_token_clone).await {
+        match api::serve(opt_rpc_addr, local_db_clone1, api_metrics_state, cancel_token_clone).await
+        {
             Ok(tag) => Ok(tag),
             Err(e) => {
                 tracing::error!("RPC service error: {}", e);
@@ -59,7 +63,9 @@ async fn main() -> anyhow::Result<()> {
         info!("start generate proof tasks");
         let cancel_token_clone = cancellation_token.clone();
         task_handles.push(tokio::spawn(async move {
-            match run_generate_proof_tasks(cfg, local_db, 1, cancel_token_clone).await {
+            match run_generate_proof_tasks(cfg, local_db, metrics_state, 1, cancel_token_clone)
+                .await
+            {
                 Ok(tag) => Ok(tag),
                 Err(e) => {
                     tracing::error!("Main program is exiting: {e:?}");
diff --git a/proof-builder-rpc/src/task/commit_chain_proof.rs b/proof-builder-rpc/src/task/commit_chain_proof.rs
index 93e1cd24f..d5970e589 100644
--- a/proof-builder-rpc/src/task/commit_chain_proof.rs
+++ b/proof-builder-rpc/src/task/commit_chain_proof.rs
@@ -12,10 +12,13 @@ use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 use tracing::info;
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+use crate::api::metrics_service::{ApiMetricsState, COMMIT_CHAIN_PROOF};
+
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 pub(crate) fn spawn_commit_chain_proof_task(
     args: commit_chain_proof::Args,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     initial_delay: u64,
     cancellation_token: CancellationToken,
@@ -90,16 +93,57 @@ pub(crate) fn spawn_commit_chain_proof_task(
                     let proving_start = tokio::time::Instant::now();
                     let (input, proof, cycles, proving_time) = match builder.build_proof(&ctx) {
                         Ok(data) => data,
-                        Err(err) => {
-                            tracing::error!("Build proof error, {err:?}");
+                        Err(error) => {
+                            metrics_state.record_attempt(
+                                COMMIT_CHAIN_PROOF,
+                                "failed",
+                                proving_start.elapsed(),
+                            );
+                            tracing::error!("Build proof error: {error:?}");
                             continue;
                         }
                     };
                     let proving_duration = proving_start.elapsed().as_secs_f32() * 1000.0;
                     let zkm_version = proof.zkm_version.clone();
-                    let (public_value_hex, proof_size) = builder.save_proof(&ctx, &input, cycles, proof)?;
-
-                    create_commit_chain_proof(&local_db, block_start, 0xffffffff_i64 - block_start, args.output_proof.clone(), public_value_hex, proof_size as i64, cycles, CommitChainProofBuilder::name(), starts_from_genesis, proving_duration as i64, proving_time as i64, store::ProofState::Proven,zkm_version).await?;
+                    let (public_value_hex, proof_size) =
+                        match builder.save_proof(&ctx, &input, cycles, proof) {
+                            Ok(data) => data,
+                            Err(error) => {
+                                metrics_state.record_attempt(
+                                    COMMIT_CHAIN_PROOF,
+                                    "failed",
+                                    proving_start.elapsed(),
+                                );
+                                return Err(error);
+                            }
+                        };
+                    let persist_result = create_commit_chain_proof(
+                        &local_db,
+                        block_start,
+                        0xffffffff_i64 - block_start,
+                        args.output_proof.clone(),
+                        public_value_hex,
+                        proof_size as i64,
+                        cycles,
+                        CommitChainProofBuilder::name(),
+                        starts_from_genesis,
+                        proving_duration as i64,
+                        proving_time as i64,
+                        store::ProofState::Proven,
+                        zkm_version,
+                    )
+                    .await;
+                    let outcome = if matches!(&persist_result, Ok(affected) if *affected > 0) {
+                        "success"
+                    } else {
+                        "failed"
+                    };
+                    metrics_state.record_attempt(
+                        COMMIT_CHAIN_PROOF,
+                        outcome,
+                        proving_start.elapsed(),
+                    );
+                    persist_result?;
                     args = ProofBuilderConfig::run_next(args, CommitChainProofBuilder::name())?;
                 }
                 _ = cancellation_token.cancelled() => {
diff --git a/proof-builder-rpc/src/task/header_chain_proof.rs b/proof-builder-rpc/src/task/header_chain_proof.rs
index 4f663b654..fdd496e28 100644
--- a/proof-builder-rpc/src/task/header_chain_proof.rs
+++ b/proof-builder-rpc/src/task/header_chain_proof.rs
@@ -6,13 +6,15 @@ use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 use tracing::info;
 
+use crate::api::metrics_service::{ApiMetricsState, HEADER_CHAIN_PROOF};
 use crate::config::ProofBuilderConfig;
 use crate::task::{create_long_running_task, fetch_latest_long_running_task};
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 pub(crate) fn spawn_header_chain_proof_task(
     args: header_chain_proof::Args,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     initial_delay: u64,
     cancellation_token: CancellationToken,
@@ -77,17 +79,58 @@ pub(crate) fn spawn_header_chain_proof_task(
                            total_block_headers,
                     };
                     let proving_start = tokio::time::Instant::now();
-                    let (input, proof, cycles, proving_time) = match builder.build_proof(&ctx){
-                        Ok(d) => d,
-                        Err(err) => {
-                            tracing::error!("Build proof error: {err}");
+                    let (input, proof, cycles, proving_time) = match builder.build_proof(&ctx) {
+                        Ok(data) => data,
+                        Err(error) => {
+                            metrics_state.record_attempt(
+                                HEADER_CHAIN_PROOF,
+                                "failed",
+                                proving_start.elapsed(),
+                            );
+                            tracing::error!("Build proof error: {error}");
                             continue;
                         }
                     };
                     let proving_duration = proving_start.elapsed().as_secs_f32() * 1000.0;
                     let zkm_version = proof.zkm_version.clone();
-                    let (public_value_hex, proof_size) = builder.save_proof(&ctx, &input, cycles, proof)?;
-                    create_long_running_task(&local_db, args.start as i64, args.batch_size as i64, args.output_proof.clone(), public_value_hex, proof_size as i64, cycles, HeaderChainProofBuilder::name(), proving_duration as i64, proving_time as i64, store::ProofState::Proven, zkm_version).await?;
+                    let (public_value_hex, proof_size) =
+                        match builder.save_proof(&ctx, &input, cycles, proof) {
+                            Ok(data) => data,
+                            Err(error) => {
+                                metrics_state.record_attempt(
+                                    HEADER_CHAIN_PROOF,
+                                    "failed",
+                                    proving_start.elapsed(),
+                                );
+                                return Err(error);
+                            }
+                        };
+                    let persist_result = create_long_running_task(
+                        &local_db,
+                        args.start as i64,
+                        args.batch_size as i64,
+                        args.output_proof.clone(),
+                        public_value_hex,
+                        proof_size as i64,
+                        cycles,
+                        HeaderChainProofBuilder::name(),
+                        proving_duration as i64,
+                        proving_time as i64,
+                        store::ProofState::Proven,
+                        zkm_version,
+                    )
+                    .await;
+                    let outcome = if matches!(&persist_result, Ok(affected) if *affected > 0) {
+                        "success"
+                    } else {
+                        "failed"
+                    };
+                    metrics_state.record_attempt(
+                        HEADER_CHAIN_PROOF,
+                        outcome,
+                        proving_start.elapsed(),
+                    );
+                    persist_result?;
                     args = ProofBuilderConfig::run_next(args, HeaderChainProofBuilder::name())?;
                 }
                 _ = cancellation_token.cancelled() => {
diff --git a/proof-builder-rpc/src/task/mod.rs b/proof-builder-rpc/src/task/mod.rs
index 75efccbe3..c240d6046 100644
--- a/proof-builder-rpc/src/task/mod.rs
+++ b/proof-builder-rpc/src/task/mod.rs
@@ -5,6 +5,7 @@ mod header_chain_proof;
 mod operator_proof;
 mod state_chain_proof;
 mod watchtower_proof;
+use crate::api::metrics_service::ApiMetricsState;
 use crate::config::ProofBuilderConfig;
 use crate::task::{
     commit_chain_proof::spawn_commit_chain_proof_task,
@@ -39,6 +40,7 @@ pub(crate) fn is_start_generate_proof_tasks(cfg: &ProofBuilderConfig) -> bool {
 pub(crate) async fn run_generate_proof_tasks(
     cfg: ProofBuilderConfig,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     cancellation_token: CancellationToken,
 ) -> anyhow::Result<String> {
@@ -46,6 +48,7 @@ pub(crate) async fn run_generate_proof_tasks(
         Either::Left(spawn_header_chain_proof_task(
             cfg.header_chain.clone(),
             local_db.clone(),
+            metrics_state.clone(),
             interval,
             0,
             cancellation_token.clone(),
@@ -58,6 +61,7 @@ pub(crate) async fn run_generate_proof_tasks(
         Either::Left(spawn_commit_chain_proof_task(
             cfg.commit_chain.clone(),
             local_db.clone(),
+            metrics_state.clone(),
             interval,
             interval / 4,
             cancellation_token.clone(),
@@ -70,6 +74,7 @@ pub(crate) async fn run_generate_proof_tasks(
         Either::Left(spawn_state_chain_proof_task(
             cfg.state_chain.clone(),
             local_db.clone(),
+            metrics_state.clone(),
             interval,
             interval / 4,
             cancellation_token.clone(),
@@ -82,6 +87,7 @@ pub(crate) async fn run_generate_proof_tasks(
         Either::Left(spawn_operator_proof_task(
             cfg.operator.clone(),
             local_db.clone(),
+            metrics_state.clone(),
             interval,
             interval / 2,
             cancellation_token.clone(),
@@ -94,6 +100,7 @@ pub(crate) async fn run_generate_proof_tasks(
         Either::Left(spawn_watchtower_proof_task(
             cfg.watchtower.clone(),
             local_db.clone(),
+            metrics_state,
             interval,
             interval * 3 / 4,
             cancellation_token.clone(),
diff --git a/proof-builder-rpc/src/task/operator_proof.rs b/proof-builder-rpc/src/task/operator_proof.rs
index a35243cb1..af4edb625 100644
--- a/proof-builder-rpc/src/task/operator_proof.rs
+++ b/proof-builder-rpc/src/task/operator_proof.rs
@@ -13,10 +13,13 @@ use tracing::info;
 use util::hex_parse;
 use zkm_sdk::HashableKey;
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+use crate::api::metrics_service::{ApiMetricsState, OPERATOR_PROOF};
+
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 pub(crate) fn spawn_operator_proof_task(
     args: operator_proof::Args,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     initial_delay: u64,
     cancellation_token: CancellationToken,
@@ -146,7 +149,13 @@ pub(crate) fn spawn_operator_proof_task(
                     };
 
                     let proving_duration = proving_start.elapsed().as_secs_f32() * 1000.0;
-                    let affected = update_operator_task(&local_db, task_index, args.output.clone(), public_value_hex, proof_size as i64, cycles, proof_state, proving_duration as i64, proving_time as i64, zkm_version).await?;
+                    let succeeded = matches!(proof_state, ProofState::Proven);
+                    let update_result = update_operator_task(&local_db, task_index, args.output.clone(), public_value_hex, proof_size as i64, cycles, proof_state, proving_duration as i64, proving_time as i64, zkm_version).await;
+                    let persisted =
+                        matches!(&update_result, Ok(affected) if *affected > 0);
+                    let outcome = if succeeded && persisted { "success" } else { "failed" };
+                    metrics_state.record_attempt(OPERATOR_PROOF, outcome, proving_start.elapsed());
+                    let affected = update_result?;
                     tracing::info!("update operator task: {args:?}, cycles: {cycles}, index: {}, affected row: {affected}", task_index);
                     args = ProofBuilderConfig::run_next(args, OperatorProofBuilder::name())?;
                 }
diff --git a/proof-builder-rpc/src/task/state_chain_proof.rs b/proof-builder-rpc/src/task/state_chain_proof.rs
index 8912c6bb0..61c92e717 100644
--- a/proof-builder-rpc/src/task/state_chain_proof.rs
+++ b/proof-builder-rpc/src/task/state_chain_proof.rs
@@ -9,6 +9,8 @@ use store::localdb::LocalDB;
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 
+use crate::api::metrics_service::{ApiMetricsState, STATE_CHAIN_PROOF};
+
 #[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
 async fn spawn_state_chain_ctx_builder(
     args: state_chain_proof::Args,
@@ -115,12 +117,13 @@ async fn spawn_state_chain_ctx_builder(
     }
 }
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 async fn spawn_state_chain_prover(
     start_index: u64,
     batch_size: u64,
     input_proof: String,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     cancellation_token: CancellationToken,
 ) -> anyhow::Result<()> {
@@ -183,44 +186,42 @@ async fn spawn_state_chain_prover(
                 };
                 tracing::info!("Updated long running task to proving state, affected rows: {affteced}");
 
-                let (input, proof, cycles, proving_time) =
-                    match builder.build_proof(&ctx) {
-                        Ok(d) => d,
-                        Err(err) => {
-                            tracing::error!("Build proof error: {err}");
-                            continue;
-                        }
-                    };
-
-                let zkm_version = proof.zkm_version.clone();
-                let (public_value_hex, proof_size) = match builder.save_proof(&ctx, &input, cycles, proof) {
-                    Ok(d) => d,
-                    Err(e) => {
-                        tracing::error!("Save proof error: {e}");
-                        continue;
-                    }
+                let attempt_start = tokio::time::Instant::now();
+                let attempt: anyhow::Result<u64> = async {
+                    let (input, proof, cycles, proving_time) = builder.build_proof(&ctx)?;
+                    let zkm_version = proof.zkm_version.clone();
+                    let (public_value_hex, proof_size) =
+                        builder.save_proof(&ctx, &input, cycles, proof)?;
+                    update_long_running_task(
+                        &local_db,
+                        start_index as i64,
+                        batch_size as i64,
+                        args.output_proof.clone(),
+                        public_value_hex,
+                        proof_size as i64,
+                        cycles,
+                        Proven,
+                        StateChainProofBuilder::name(),
+                        proving_time as i64,
+                        zkm_version,
+                    )
+                    .await
+                }
+                .await;
+                let outcome = if matches!(&attempt, Ok(affected) if *affected > 0) {
+                    "success"
+                } else {
+                    "failed"
                 };
-
-                let affteced = match update_long_running_task(
-                    &local_db,
-                    start_index as i64,
-                    batch_size as i64,
-                    args.output_proof.clone(),
-                    public_value_hex,
-                    proof_size as i64,
-                    cycles,
-                    Proven,
-                    StateChainProofBuilder::name(),
-                    proving_time as i64,
-                    zkm_version,
-                ).await {
+                metrics_state.record_attempt(STATE_CHAIN_PROOF, outcome, attempt_start.elapsed());
+                let affected = match attempt {
                     Ok(affected) => affected,
-                    Err(e) => {
-                        tracing::error!("Update long running task to proven state error: {e:?}");
+                    Err(error) => {
+                        tracing::error!("State chain proof attempt failed: {error}");
                         continue;
                     }
                 };
-                tracing::info!("Updated long running task to proven state, affected rows: {affteced}");
+                tracing::info!("Updated long running task to proven state, affected rows: {affected}");
                 start_index += batch_size;
             }
             _ = cancellation_token.cancelled() => {
@@ -230,10 +231,11 @@ async fn spawn_state_chain_prover(
     }
 }
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 pub(crate) fn spawn_state_chain_proof_task(
     args: state_chain_proof::Args,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     initial_delay: u64,
     cancellation_token: CancellationToken,
@@ -294,6 +296,7 @@ pub(crate) fn spawn_state_chain_proof_task(
             args.batch_size,
             input_proof,
             local_db.clone(),
+            metrics_state,
             interval,
             cancellation_token.clone(),
         ));
diff --git a/proof-builder-rpc/src/task/watchtower_proof.rs b/proof-builder-rpc/src/task/watchtower_proof.rs
index c795ecd80..3f2317001 100644
--- a/proof-builder-rpc/src/task/watchtower_proof.rs
+++ b/proof-builder-rpc/src/task/watchtower_proof.rs
@@ -8,10 +8,13 @@ use tokio_util::sync::CancellationToken;
 use tracing::info;
 use watchtower_proof::{WatchtowerProofBuilder, fetch_target_block};
 
-#[tracing::instrument(level = "info", skip(local_db, cancellation_token))]
+use crate::api::metrics_service::{ApiMetricsState, WATCHTOWER_PROOF};
+
+#[tracing::instrument(level = "info", skip(local_db, metrics_state, cancellation_token))]
 pub(crate) fn spawn_watchtower_proof_task(
     args: watchtower_proof::Args,
     local_db: LocalDB,
+    metrics_state: ApiMetricsState,
     interval: u64,
     initial_delay: u64,
     cancellation_token: CancellationToken,
@@ -101,7 +104,13 @@ pub(crate) fn spawn_watchtower_proof_task(
                         }
                     };
                     let proving_duration = proving_start.elapsed().as_secs_f32() * 1000.0;
-                    let affected = update_watchtower_task(&local_db, task_index, args.output.clone(), public_value_hex, proof_size as i64, cycles, proof_state, proving_duration as i64, proving_time as i64, zkm_version).await?;
+                    let succeeded = matches!(proof_state, ProofState::Proven);
+                    let update_result = update_watchtower_task(&local_db, task_index, args.output.clone(), public_value_hex, proof_size as i64, cycles, proof_state, proving_duration as i64, proving_time as i64, zkm_version).await;
+                    let persisted =
+                        matches!(&update_result, Ok(affected) if *affected > 0);
+                    let outcome = if succeeded && persisted { "success" } else { "failed" };
+                    metrics_state.record_attempt(WATCHTOWER_PROOF, outcome, proving_start.elapsed());
+                    let affected = update_result?;
                     tracing::info!("update watchtower task: {args:?}, cycles: {cycles}, index: {}, affected row: {affected}", task_index);
                     args = ProofBuilderConfig::run_next(args, WatchtowerProofBuilder::name())?;
                 }