feat(examples): add Midnight Poseidon EVM transcript end-to-end flow

Add a Midnight Poseidon example and transcript adapter that exercise proof generation, verification, and EVM verifier artifact generation.

- Add Midnight EVM transcript hash helper with tests for scalar/point encoding behavior.

- Add midnight_poseidon_evm example to prove/verify and emit Solidity, bytecode, and calldata artifacts.

- Ignore generated Midnight artifact output directory and keep incidental example formatting tidy.

Author: jtcoolen

.gitignore

@@ -2,6 +2,7 @@
 .DS_Store
 
 /target
+snark-verifier-sdk/target/midnight/
 testdata
 
 # Cargo.lock

snark-verifier-sdk/examples/midnight_poseidon_evm.rs

@@ -0,0 +1,150 @@
+//! Generate and verify the Poseidon example with Midnight's EVM transcript.
+//! Run with:
+//!   cargo run --example midnight_poseidon_evm --features midnight,loader_evm,revm -p snark-verifier-sdk
+use ff::Field;
+use midnight_circuits::{
+    hash::poseidon::PoseidonChip,
+    instructions::{hash::HashCPU, AssignmentInstructions, PublicInputInstructions},
+};
+use midnight_curves::Bls12;
+use midnight_proofs::poly::kzg::params::ParamsKZG;
+use midnight_proofs::{
+    circuit::{Layouter, Value},
+    plonk::Error,
+};
+use midnight_zk_stdlib::{Relation, ZkStdLib, ZkStdLibArch};
+use rand::{rngs::OsRng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use snark_verifier_sdk::midnight_adapter::{MidnightBundleOptions, MidnightProofBundle};
+use std::path::PathBuf;
+
+#[path = "support/midnight_evm_transcript.rs"]
+mod midnight_evm_transcript;
+use midnight_evm_transcript::MidnightEvmHash;
+
+type F = midnight_curves::Fq;
+
+#[derive(Clone, Default)]
+pub struct PoseidonExample;
+
+impl Relation for PoseidonExample {
+    type Instance = F;
+
+    type Witness = [F; 3];
+
+    // Expose one public output column containing the Poseidon hash value.
+    fn format_instance(instance: &Self::Instance) -> Result<Vec<F>, Error> {
+        Ok(vec![*instance])
+    }
+
+    // Build the relation: hash witness values with Poseidon and constrain as public output.
+    fn circuit(
+        &self,
+        std_lib: &ZkStdLib,
+        layouter: &mut impl Layouter<F>,
+        _instance: Value<Self::Instance>,
+        witness: Value<Self::Witness>,
+    ) -> Result<(), Error> {
+        let assigned_message = std_lib.assign_many(layouter, &witness.transpose_array())?;
+        let output = std_lib.poseidon(layouter, &assigned_message)?;
+        std_lib.constrain_as_public_input(layouter, &output)
+    }
+
+    // Enable only Poseidon chip plumbing for this example circuit.
+    fn used_chips(&self) -> ZkStdLibArch {
+        ZkStdLibArch { poseidon: true, ..ZkStdLibArch::default() }
+    }
+
+    // No custom relation payload is needed for this stateless demo relation.
+    fn write_relation<W: std::io::Write>(&self, _writer: &mut W) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    // No custom relation payload is needed for this stateless demo relation.
+    fn read_relation<R: std::io::Read>(_reader: &mut R) -> std::io::Result<Self> {
+        Ok(PoseidonExample)
+    }
+}
+
+fn main() {
+    const K: u32 = 6;
+    let srs = ParamsKZG::<Bls12>::unsafe_setup(K, OsRng);
+
+    // Build proving/verifying keys for the Poseidon relation.
+    let relation = PoseidonExample;
+    let vk = midnight_zk_stdlib::setup_vk(&srs, &relation);
+    let pk = midnight_zk_stdlib::setup_pk(&relation, &vk);
+
+    // Sample random witness and derive the expected public output.
+    let mut rng = ChaCha8Rng::from_entropy();
+    let witness: [F; 3] = core::array::from_fn(|_| F::random(&mut rng));
+    let instance = <PoseidonChip<F> as HashCPU<F, F>>::hash(&witness);
+
+    // Produce and verify an EVM-transcript proof using MidnightEvmHash.
+    let proof = midnight_zk_stdlib::prove::<PoseidonExample, MidnightEvmHash>(
+        &srs, &pk, &relation, &instance, witness, OsRng,
+    )
+    .expect("EVM-transcript proof generation should not fail");
+
+    midnight_zk_stdlib::verify::<PoseidonExample, MidnightEvmHash>(
+        &srs.verifier_params(),
+        &vk,
+        &instance,
+        None,
+        &proof,
+    )
+    .expect("EVM-transcript native verification should succeed");
+
+    // Build adapter bundle used for Solidity/codegen bridge.
+    let bundle = MidnightProofBundle::from_vk(
+        srs.verifier_params(),
+        vk.vk().clone(),
+        proof.clone(),
+        vec![vec![instance]],
+        MidnightBundleOptions::default(),
+    )
+    .expect("Bundle creation should succeed");
+
+    // Generate Solidity source, compile bytecode, and encode calldata artifacts.
+    let solidity = bundle
+        .generate_evm_verifier_solidity()
+        .expect("failed to generate Solidity verifier source");
+    let bytecode =
+        bundle.generate_evm_verifier_bytecode().expect("failed to compile Solidity verifier");
+    let calldata = bundle.encode_evm_calldata().expect("failed to encode EVM calldata");
+
+    let out_dir =
+        std::env::var_os("MIDNIGHT_ARTIFACT_DIR").map(PathBuf::from).unwrap_or_else(|| {
+            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target").join("midnight")
+        });
+    std::fs::create_dir_all(&out_dir).expect("failed to create output directory");
+    let solidity_path = out_dir.join("MidnightPoseidonVerifier.sol");
+    let bytecode_path = out_dir.join("midnight_poseidon.bytecode");
+    let calldata_path = out_dir.join("midnight_poseidon.calldata");
+
+    // Persist generated artifacts to disk (default: target/midnight).
+    std::fs::write(&solidity_path, &solidity).expect("failed to write Solidity verifier");
+    std::fs::write(&bytecode_path, format!("0x{}", hex::encode(&bytecode)))
+        .expect("failed to write verifier bytecode");
+    std::fs::write(&calldata_path, hex::encode(&calldata)).expect("failed to write calldata");
+
+    println!("proof bytes: {}", proof.len());
+    println!("deployment code bytes: {}", bytecode.len());
+    println!("calldata bytes: {}", calldata.len());
+    println!("wrote {}", solidity_path.display());
+    println!("wrote {}", bytecode_path.display());
+    println!("wrote {}", calldata_path.display());
+
+    #[cfg(feature = "revm")]
+    {
+        // Optional local revm simulation for end-to-end gas measurement.
+        if std::env::var("RUN_REVM").ok().as_deref() == Some("1") {
+            let gas = bundle
+                .verify_with_generated_solidity_revm()
+                .expect("revm verification should succeed");
+            println!("revm gas: {gas}");
+        } else {
+            println!("revm verification skipped (set RUN_REVM=1 to run local revm simulation)");
+        }
+    }
+}

snark-verifier-sdk/examples/standard_plonk.rs

@@ -47,7 +47,7 @@ mod application {
                         [a, b, c].map(|column| meta.query_advice(column, Rotation::cur()));
                     let [q_a, q_b, q_c, q_ab, constant] = [q_a, q_b, q_c, q_ab, constant]
                         .map(|column| meta.query_fixed(column, Rotation::cur()));
-                let instance = meta.query_instance(instance, Rotation::cur());
+                    let instance = meta.query_instance(instance, Rotation::cur());
                     Some(
                         q_a * a.clone()
                             + q_b * b.clone()
@@ -200,9 +200,7 @@ fn main() {
                 }
             }
         } else {
-            println!(
-                "revm verification skipped (set RUN_REVM=1 to run local revm simulation)"
-            );
+            println!("revm verification skipped (set RUN_REVM=1 to run local revm simulation)");
         }
     }
 }