add max shape

Author: weilzkm

crates/core/machine/src/shape/maximal_shapes.json

@@ -27052,6 +27052,26 @@
         "CloClz": 6,
         "SyscallCore": 3
       }
+    },
+    {
+      "inner": {
+        "Cpu": 21,
+        "MemoryLocal": 20,
+        "Lt": 20,
+        "MemoryInstrs": 20,
+        "SyscallInstrs": 20,
+        "ShiftLeft": 20,
+        "Bitwise": 20,
+        "ShiftRight": 20,
+        "Mul": 20,
+        "Global": 20,
+        "MiscInstrs": 20,
+        "Branch": 20,
+        "Jump": 20,
+        "AddSub": 20,
+        "CloClz": 20,
+        "SyscallCore": 20
+      }
     }
   ]
 }

crates/core/machine/src/shape/small_shapes.json

@@ -152683,5 +152683,28 @@
       "CloClz": 6,
       "SyscallCore": 18
     }
+  },
+  {
+    "inner": {
+      "Cpu": 21,
+      "MemoryLocal": 20,
+      "Lt": 20,
+      "MemoryInstrs": 20,
+      "DivRem": 20,
+      "SyscallInstrs": 20,
+      "ShiftLeft": 20,
+      "Bitwise": 20,
+      "ShiftRight": 20,
+      "Mul": 20,
+      "Global": 20,
+      "MemoryGlobalInit": 20,
+      "MiscInstrs": 20,
+      "Branch": 20,
+      "MemoryGlobalFinalize": 20,
+      "Jump": 20,
+      "AddSub": 20,
+      "CloClz": 20,
+      "SyscallCore": 20
+    }
   }
 ]

examples/Cargo.lock

@@ -6,3 +6,5 @@ publish = false
 
 [dependencies]
 zkm-zkvm = { path = "../../../crates/zkvm/entrypoint", features= ["embedded"] }
+sha3 = { version = "0.10.8", default-features = false }
+sha2 = { version = "0.10.8", default-features = false }

examples/fibonacci/guest/Cargo.toml

@@ -7,9 +7,15 @@
 // inside the zkVM.
 #![no_std]
 #![no_main]
+
+use sha2::Sha256;
+use sha3::{Digest, Keccak256};
+extern crate alloc;
+use alloc::vec::Vec;
+
 zkm_zkvm::entrypoint!(main);
 
-pub fn main() {
+pub fn fib() {
     // Read an input to the program.
     //
     // Behind the scenes, this compiles down to a system call which handles reading inputs
@@ -36,3 +42,27 @@ pub fn main() {
     zkm_zkvm::io::commit(&a);
     zkm_zkvm::io::commit(&b);
 }
+
+pub fn sha2() {
+    let input: Vec<u8> = zkm_zkvm::io::read();
+
+    let mut hasher = Sha256::new();
+    hasher.update(input);
+    let result: [u8; 32] = hasher.finalize().into();
+
+    zkm_zkvm::io::commit::<[u8; 32]>(&result.into());
+}
+
+pub fn sha3() {
+    let input: Vec<u8> = zkm_zkvm::io::read();
+
+    let mut hasher = Keccak256::new();
+    hasher.update(input);
+    let result = hasher.finalize();
+
+    zkm_zkvm::io::commit::<[u8; 32]>(&result.into());
+}
+
+pub fn main() {
+    sha3();
+}

examples/fibonacci/guest/src/main.rs

@@ -1,14 +1,15 @@
+use std::time::{Duration, Instant};
 use zkm_sdk::{include_elf, utils, ProverClient, ZKMProofWithPublicValues, ZKMStdin};
 
 /// The ELF we want to execute inside the zkVM.
 const ELF: &[u8] = include_elf!("fibonacci");
 
-fn main() {
+fn fib() {
     // Setup logging.
     utils::setup_logger();
 
     // Create an input stream and write '1000' to it.
-    let n = 1000u32;
+    let n = 100000u32;
 
     // The input stream that the guest will read from using `zkm_zkvm::io::read`. Note that the
     // types of the elements in the input stream must match the types being read in the guest.
@@ -24,8 +25,11 @@ fn main() {
 
     // Generate the proof for the given guest and input.
     let (pk, vk) = client.setup(ELF);
+    let start = Instant::now();
     let mut proof = client.prove(&pk, stdin).run().unwrap();
-
+    let end = Instant::now();
+    let duration = end.duration_since(start);
+    println!("benchmark_sha2 end, duration: {:?}", duration.as_secs_f64());
     println!("generated proof");
 
     // Read and verify the output.
@@ -52,3 +56,51 @@ fn main() {
 
     println!("successfully generated and verified proof for the program!")
 }
+
+fn sha2(num_bytes: usize) {
+    // Setup logging.
+    utils::setup_logger();
+
+    // The input stream that the guest will read from using `zkm_zkvm::io::read`. Note that the
+    // types of the elements in the input stream must match the types being read in the guest.
+    let mut stdin = ZKMStdin::new();
+    let input = vec![5u8; num_bytes];
+    stdin.write(&input);
+
+    // Create a `ProverClient` method.
+    let client = ProverClient::new();
+
+    // Execute the guest using the `ProverClient.execute` method, without generating a proof.
+    let (_, report) = client.execute(ELF, stdin.clone()).run().unwrap();
+    println!("executed program with {} cycles", report.total_instruction_count());
+
+    /*
+    // Generate the proof for the given guest and input.
+    let (pk, vk) = client.setup(ELF);
+    let start = Instant::now();
+    let mut proof = client.prove(&pk, stdin).run().unwrap();
+    let end = Instant::now();
+    let duration = end.duration_since(start);
+    println!("benchmark_sha2 end, duration: {:?}", duration.as_secs_f64());
+
+    println!("generated proof");
+
+    // Verify proof and public values
+    client.verify(&proof, &vk).expect("verification failed");
+
+    // Test a round trip of proof serialization and deserialization.
+    proof.save("proof-with-pis.bin").expect("saving proof failed");
+    let deserialized_proof =
+        ZKMProofWithPublicValues::load("proof-with-pis.bin").expect("loading proof failed");
+
+    // Verify the deserialized proof.
+    client.verify(&deserialized_proof, &vk).expect("verification failed");
+    */
+    println!("successfully generated and verified proof for the program!")
+}
+
+fn main() {
+    sha2(256);
+    sha2(512);
+    sha2(1048);
+}

examples/fibonacci/host/src/main.rs

@@ -3,4 +3,4 @@ use zkm_build::{build_program_with_args, BuildArgs};
 
 fn main() {
     zkm_build::build_program("../guest");
-}
+}

examples/fibonacci_c_lib/host/build.rs

@@ -1,7 +1,14 @@
 module simple-go
 
-go 1.22.5
+go 1.24.0
+
+toolchain go1.24.7
 
 replace github.com/ProjectZKM/Ziren/crates/go-runtime/zkm_runtime => ../../../crates/go-runtime/zkm_runtime
 
 require github.com/ProjectZKM/Ziren/crates/go-runtime/zkm_runtime v0.0.0-20240817102429-2faba0888c02
+
+require (
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/sys v0.36.0 // indirect
+)

examples/simple-go/guest/go.mod

@@ -1,17 +1,52 @@
 package main
 
 import (
-	"log"
+	"crypto/sha256"
+	"fmt"
 
 	"github.com/ProjectZKM/Ziren/crates/go-runtime/zkm_runtime"
+	"golang.org/x/crypto/sha3"
 )
 
-func main() {
-	a := zkm_runtime.Read[uint32]()
+func fib() {
+	n := zkm_runtime.Read[uint32]()
+	zkm_runtime.Commit[uint32](n)
 
-	if a != 10 {
-		log.Fatal("%x != 10", a)
+	a := uint32(0)
+	b := uint32(1)
+	for i := uint32(0); i < n; i++ {
+		c := a + b
+		c %= 7919
+		a = b
+		b = c
 	}
 
 	zkm_runtime.Commit[uint32](a)
+	zkm_runtime.Commit[uint32](b)
+}
+
+func sha2() {
+	data := zkm_runtime.Read[[]byte]()
+
+	hash := sha256.Sum256(data)
+
+	zkm_runtime.Commit[[32]byte](hash)
+}
+
+func keccak() {
+	data := zkm_runtime.Read[[]byte]()
+
+	hasher := sha3.NewLegacyKeccak256()
+	hasher.Write(data)
+	hash := hasher.Sum(nil)
+
+	var sumArray [32]byte
+	copy(sumArray[:], hash)
+	fmt.Println(sumArray)
+	zkm_runtime.Commit[[32]byte](sumArray)
+}
+
+func main() {
+	// fib()
+	keccak()
 }

examples/simple-go/guest/main.go

@@ -1,5 +1,5 @@
-use std::process::Command;
 use std::path::Path;
+use std::process::Command;
 
 fn main() {
     let go_src = Path::new("../guest");