fix evm proof generation

Author: IDEA-godwin

.gitignore

@@ -14,6 +14,7 @@ pgo-data.profdata
 # Proofs
 **/proof-with-pis.json
 **/proof-with-io.json
+contracts
 
 # Env
 .env

Cargo.lock

@@ -79,13 +79,13 @@ pub fn track_energy(m3ter: M3ter, m3ter_payloads: &[M3terPayload], start_nonce:
     let mut energy_sum = 0.0;
     let mut latest_nonce = start_nonce;
     for payload in m3ter_payloads.iter() {
-        if latest_nonce + 1 != payload.nonce || payload.nonce < latest_nonce {
+        if latest_nonce + 1 != payload.nonce {
             println!("Invalid nonce: {} < {} for m3ter_id {}", &payload.nonce, &latest_nonce, &m3ter.m3ter_id);
-            return (0.0, start_nonce);
+            break; // Nonce is not sequential or is less than the latest nonce
         }
         // if !m3ter.validate_payload(payload) {
         //     println!("Invalid payload: {:?}", payload);
-        //     return (energy_sum, latest_nonce);
+        //     break
         // }
         energy_sum += payload.energy;
         latest_nonce = payload.nonce;

lib/src/lib.rs

@@ -15,10 +15,10 @@ pub fn validate_signature(message_hash: Vec<u8>, public_key: &str, signature_str
     }
 }
 
-pub fn _validate_unique_nonce(nonce: u128) -> bool {
-    // Check if the nonce is unique (greater than 0)
-    nonce > 0
-}
+// pub fn _validate_unique_nonce(nonce: u128) -> bool {
+//     // Check if the nonce is unique (greater than 0)
+//     nonce > 0
+// }
 
 fn build_signature(raw_signature: &str) -> Option<Signature> {
     let signature = Signature::from_slice(&decode_hex(raw_signature));

lib/src/util.rs

@@ -27,6 +27,7 @@ serde = { workspace = true }
 energy-tracker-lib = { path = "../lib" }
 dotenv = "0.15.0"
 base64 = "0.22.1"
+bincode = "1.3.3"
 
 [build-dependencies]
 sp1-build = "5.0.0"

script/Cargo.toml

@@ -10,8 +10,11 @@
 //! RUST_LOG=info cargo run --release --bin evm -- --system plonk
 //! ```
 
+use std::{fs::File, io::BufReader};
+
 use alloy_sol_types::SolType;
 use clap::{Parser, ValueEnum};
+use energy_tracker_lib::{Payload, PublicValuesStruct};
 use serde::{Deserialize, Serialize};
 use sp1_sdk::{
     include_elf, HashableKey, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey,
@@ -41,10 +44,11 @@ enum ProofSystem {
 /// A fixture that can be used to test the verification of SP1 zkVM proofs inside Solidity.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct SP1FibonacciProofFixture {
-    a: u32,
-    b: u32,
-    n: u32,
+struct ProofFixture {
+    previous_balances: Vec<f32>,
+    previous_nonces: Vec<i32>,
+    new_balances: Vec<f32>,
+    new_nonces: Vec<i32>,
     vkey: String,
     public_values: String,
     proof: String,
@@ -57,15 +61,24 @@ fn main() {
     // Parse the command line arguments.
     let args = EVMArgs::parse();
 
+    std::env::set_var("SP1_PROVER", "network");
+    std::env::set_var("NETWORK_PRIVATE_KEY", "3b62b0fb8da4fc79eff9236c50527cd8bb9cd7c264f1c838b105d4570aa0491e");
+
     // Setup the prover client.
     let client = ProverClient::from_env();
 
     // Setup the program.
     let (pk, vk) = client.setup(ENERGY_TRACKER_ELF);
 
     // Setup the inputs.
+    let file = File::open("script/src/sample.json").unwrap();
+    let reader = BufReader::new(file);
+    let payload: Payload = serde_json::from_reader(reader).unwrap();
+    // let previous_nonces = &payload.previous_nonces;
+    // let previous_balances = &payload.previous_balances;
+
     let mut stdin = SP1Stdin::new();
-    stdin.write(&args.n);
+    stdin.write(&payload);
 
     println!("Proof System: {:?}", args.system);
 
@@ -76,51 +89,56 @@ fn main() {
     }
     .expect("failed to generate proof");
 
-    // create_proof_fixture(&proof, &vk, args.system);
+    create_proof_fixture(&proof, &vk, args.system);
 }
 
-//// Create a fixture for the given proof.
-// fn create_proof_fixture(
-//     proof: &SP1ProofWithPublicValues,
-//     vk: &SP1VerifyingKey,
-//     system: ProofSystem,
-// ) {
-//     // Deserialize the public values.
-//     let bytes = proof.public_values.as_slice();
-//     let PublicValuesStruct { n, a, b } = PublicValuesStruct::abi_decode(bytes).unwrap();
-
-//     // Create the testing fixture so we can test things end-to-end.
-//     let fixture = SP1FibonacciProofFixture {
-//         a,
-//         b,
-//         n,
-//         vkey: vk.bytes32().to_string(),
-//         public_values: format!("0x{}", hex::encode(bytes)),
-//         proof: format!("0x{}", hex::encode(proof.bytes())),
-//     };
-
-//     // The verification key is used to verify that the proof corresponds to the execution of the
-//     // program on the given input.
-//     //
-//     // Note that the verification key stays the same regardless of the input.
-//     println!("Verification Key: {}", fixture.vkey);
-
-//     // The public values are the values which are publicly committed to by the zkVM.
-//     //
-//     // If you need to expose the inputs or outputs of your program, you should commit them in
-//     // the public values.
-    // println!("Public Values: {}", fixture.public_values);
-
-//     // The proof proves to the verifier that the program was executed with some inputs that led to
-//     // the give public values.
-//     println!("Proof Bytes: {}", fixture.proof);
+// Create a fixture for the given proof.
+fn create_proof_fixture(
+    proof: &SP1ProofWithPublicValues,
+    vk: &SP1VerifyingKey,
+    system: ProofSystem,
+) {
+    // Deserialize the public values.
+    let bytes = proof.public_values.as_slice();
+    let PublicValuesStruct { 
+        previous_balances,
+        previous_nonces,
+        new_balances, 
+        new_nonces } = bincode::deserialize(bytes).unwrap();
+
+    // Create the testing fixture so we can test things end-to-end.
+    let fixture = ProofFixture {
+        previous_balances,
+        previous_nonces,
+        new_balances, 
+        new_nonces,
+        vkey: vk.bytes32().to_string(),
+        public_values: format!("0x{}", hex::encode(bytes)),
+        proof: format!("0x{}", hex::encode(proof.bytes())),
+    };
+
+    // The verification key is used to verify that the proof corresponds to the execution of the
+    // program on the given input.
+    //
+    // Note that the verification key stays the same regardless of the input.
+    println!("Verification Key: {}", fixture.vkey);
+
+    // The public values are the values which are publicly committed to by the zkVM.
+    //
+    // If you need to expose the inputs or outputs of your program, you should commit them in
+    // the public values.
+    println!("Public Values: {}", fixture.public_values);
+
+    // The proof proves to the verifier that the program was executed with some inputs that led to
+    // the give public values.
+    println!("Proof Bytes: {}", fixture.proof);
 
     // Save the fixture to a file.
-    // let fixture_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../contracts/src/fixtures");
-    // std::fs::create_dir_all(&fixture_path).expect("failed to create fixture path");
-    // std::fs::write(
-    //     fixture_path.join(format!("{:?}-fixture.json", system).to_lowercase()),
-    //     serde_json::to_string_pretty(&fixture).unwrap(),
-    // )
-    // .expect("failed to write fixture");
-// }
+    let fixture_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../contracts/src/fixtures");
+    std::fs::create_dir_all(&fixture_path).expect("failed to create fixture path");
+    std::fs::write(
+        fixture_path.join(format!("{:?}-fixture.json", system).to_lowercase()),
+        serde_json::to_string_pretty(&fixture).unwrap(),
+    )
+    .expect("failed to write fixture");
+}

script/src/bin/evm.rs

@@ -14,7 +14,7 @@ use std::{fs::File, io::BufReader};
 
 use alloy_sol_types::SolType;
 use clap::Parser;
-use energy_tracker_lib::Payload;
+use energy_tracker_lib::{Payload, PublicValuesStruct};
 use sp1_sdk::{include_elf, ProverClient, SP1Stdin};
 
 use base64::{Engine as _, alphabet, engine::{self, general_purpose}};
@@ -58,33 +58,21 @@ fn main() {
     // let previous_nonces = &payload.previous_nonces;
     // let previous_balances = &payload.previous_balances;
 
-    // let decoded_nonces = engine::general_purpose::URL_SAFE_NO_PAD.decode(previous_nonces).unwrap();
-    // let values  = m3ter_payload.previous_nonces.len();
-    // loop {
-    //     if after_strip.len() / 64 >= 1 {
-    //         let split = data_to_bytes.split_off(32);
-    //         values.push(hex::encode(data_to_bytes.clone()));
-    //         data_to_bytes = split;
-    //     } else { break; }
-    // }
-
-    // assert_eq!(hex_input, &hex::encode(decoded_nonces));
-
     // Setup the inputs.
     let mut stdin = SP1Stdin::new();
     stdin.write(&payload);
 
     if args.execute {
         // Execute the program
-        let (output, report) = client.execute(ENERGY_TRACKER_ELF, &stdin).run().unwrap();
+        let (mut output, report) = client.execute(ENERGY_TRACKER_ELF, &stdin).run().unwrap();
         println!("Program executed successfully.");
 
         // Read the output.
         // let decoded = PublicValuesStruct::abi_decode(output.as_slice()).unwrap();
         // let PublicValuesStruct { n, a, b } = decoded;
         // println!("n: {}", n);
         // println!("a: {}", a);
-        println!("output: {}", output.raw());
+        println!("output: {:?}", bincode::deserialize::<PublicValuesStruct>(output.as_slice()).unwrap());
 
         // let (expected_a, expected_b) = fibonacci_lib::fibonacci(n);
         // assert_eq!(a, expected_a);