feat: Add blanket implementations for remote and perf traits + NativeHost remote support (#81)

This commit adds blanket implementations and native host remote proving support:

1. `ZkVmRemoteHost`: Automatically implemented for any type that implements
   both `ZkVmHost` and `ZkVmRemoteProver`. Eliminates manual implementations.

2. `ZkVmRemoteProgram`: Automatically implemented for any type implementing
   `ZkVmProgram`. All programs get remote proving without explicit impls.

3. `ZkVmProgramPerf`: Automatically implemented for any type implementing
   `ZkVmProgram`. All programs get perf reporting without explicit impls.

4. **NativeHost now implements `ZkVmRemoteProver`**: Executes proofs
   synchronously and hex-encodes them in the "proof ID". Combined with
   blanket impl #1, `NativeHost` automatically gets `ZkVmRemoteHost`!

These changes eliminate all wrapper boilerplate while maintaining type safety.

Author: evgenyzdanovich

Cargo.lock

@@ -15,6 +15,8 @@ rustdoc.all = "warn"
 [dependencies]
 zkaleido.workspace = true
 
+async-trait.workspace = true
 bincode.workspace = true
 borsh.workspace = true
+hex.workspace = true
 serde.workspace = true

adapters/native/Cargo.toml

@@ -1,9 +1,11 @@
 use std::{env, fmt, sync::Arc};
 
+use async_trait::async_trait;
 use zkaleido::{
     Proof, ProofMetadata, ProofReceipt, ProofReceiptWithMetadata, ProofType, PublicValues,
     VerifyingKey, VerifyingKeyCommitment, ZkVm, ZkVmError, ZkVmExecutor, ZkVmHost,
-    ZkVmOutputExtractor, ZkVmProver, ZkVmResult, ZkVmTypedVerifier, ZkVmVkProvider,
+    ZkVmOutputExtractor, ZkVmProver, ZkVmRemoteProver, ZkVmResult, ZkVmTypedVerifier,
+    ZkVmVkProvider,
 };
 
 use crate::{env::NativeMachine, input::NativeMachineInputBuilder, proof::NativeProofReceipt};
@@ -97,3 +99,53 @@ impl fmt::Debug for NativeHost {
         write!(f, "native")
     }
 }
+
+/// Implementation of `ZkVmRemoteProver` for `NativeHost`.
+///
+/// Since `NativeHost` executes proofs synchronously, this implementation:
+/// - Runs the proof immediately in `start_proving`
+/// - Serializes the result and hex-encodes it as the "proof ID"
+/// - Deserializes and returns the proof in `get_proof_if_ready_inner`
+///
+/// Combined with the blanket impl `impl<T: ZkVmHost + ZkVmRemoteProver> ZkVmRemoteHost for T`,
+/// this automatically gives `NativeHost` the `ZkVmRemoteHost` trait, allowing it to work
+/// seamlessly with async/remote proving interfaces.
+#[async_trait(?Send)]
+impl ZkVmRemoteProver for NativeHost {
+    async fn start_proving<'a>(
+        &self,
+        input: <Self::Input<'a> as zkaleido::ZkVmInputBuilder<'a>>::Input,
+        proof_type: ProofType,
+    ) -> ZkVmResult<String> {
+        // Execute proof synchronously
+        let proof_receipt = self.prove(input, proof_type)?;
+
+        // Serialize using bincode
+        let serialized = bincode::serialize(&proof_receipt)
+            .map_err(|e| ZkVmError::InvalidProofReceipt(e.into()))?;
+
+        // Encode as hex to use as "proof ID"
+        Ok(hex::encode(serialized))
+    }
+
+    async fn get_proof_if_ready_inner(
+        &self,
+        id: String,
+    ) -> ZkVmResult<Option<Self::ZkVmProofReceipt>> {
+        // Decode the hex-encoded proof
+        let decoded = hex::decode(&id).map_err(|_| {
+            ZkVmError::InvalidProofReceipt(
+                std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid hex encoding").into(),
+            )
+        })?;
+
+        // Deserialize the ProofReceiptWithMetadata
+        let proof: ProofReceiptWithMetadata =
+            bincode::deserialize(&decoded).map_err(|e| ZkVmError::InvalidProofReceipt(e.into()))?;
+
+        // Convert to NativeProofReceipt
+        let native_receipt = proof.try_into().map_err(ZkVmError::InvalidProofReceipt)?;
+
+        Ok(Some(native_receipt))
+    }
+}

adapters/native/src/host.rs

@@ -41,5 +41,3 @@ impl ZkVmProgram for FibCompositionProgram {
         H::extract_serde_public_output(public_values)
     }
 }
-
-impl ZkVmProgramPerf for FibCompositionProgram {}

examples/fibonacci-composition/src/program.rs

@@ -31,8 +31,6 @@ impl ZkVmProgram for FibProgram {
     }
 }
 
-impl ZkVmProgramPerf for FibProgram {}
-
 #[cfg(test)]
 pub mod tests {
     use std::sync::Arc;

examples/fibonacci/src/program.rs

@@ -33,8 +33,6 @@ impl ZkVmProgram for Risc0Groth16VerifyProgram {
     }
 }
 
-impl ZkVmProgramPerf for Risc0Groth16VerifyProgram {}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

examples/groth16-verify-risc0/src/program.rs

@@ -33,8 +33,6 @@ impl ZkVmProgram for SP1Groth16VerifyProgram {
     }
 }
 
-impl ZkVmProgramPerf for SP1Groth16VerifyProgram {}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

examples/groth16-verify-sp1/src/program.rs

@@ -37,8 +37,6 @@ impl ZkVmProgram for SchnorrSigProgram {
     }
 }
 
-impl ZkVmProgramPerf for SchnorrSigProgram {}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

examples/schnorr-sig-verify/src/program.rs

@@ -31,8 +31,6 @@ impl ZkVmProgram for ShaChainProgram {
     }
 }
 
-impl ZkVmProgramPerf for ShaChainProgram {}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

examples/sha2-chain/src/program.rs

@@ -35,3 +35,10 @@ pub trait ZkVmHostPerf: ZkVmHost {
 
 /// A trait implemented by the host of a zkVM program with support for remote proving operations.
 pub trait ZkVmRemoteHost: ZkVmHost + ZkVmRemoteProver {}
+
+/// Blanket implementation of `ZkVmRemoteHost` for any type that implements both
+/// `ZkVmHost` and `ZkVmRemoteProver`.
+///
+/// This allows any host that provides the necessary trait implementations to automatically
+/// satisfy the `ZkVmRemoteHost` trait without requiring explicit implementations.
+impl<T> ZkVmRemoteHost for T where T: ZkVmHost + ZkVmRemoteProver {}