feat: add read/commit API for go runtime

emulator/src/state.rs

@@ -237,14 +237,14 @@ impl State {
  .expect("set memory range failed");
  }
  _ => {
- // if name.contains("sys_common") && name.contains("thread_info") {
- // log::debug!("patch {}", name);
- // let r: Vec<u8> = vec![0x03, 0xe0, 0x00, 0x08, 0, 0, 0, 0];
- // let r = Box::new(r.as_slice());
- // self.memory
- // .set_memory_range(symbol.st_value as u32, r)
- // .expect("set memory range failed");
- //}
+ if name.contains("sys_common") && name.contains("thread_info") {
+ log::debug!("patch {}", name);
+ let r: Vec<u8> = vec![0x03, 0xe0, 0x00, 0x08, 0, 0, 0, 0];
+ let r = Box::new(r.as_slice());
+ self.memory
+ .set_memory_range(symbol.st_value as u32, r)
+ .expect("set memory range failed");
+ }
  }
  },
  Err(e) => {

go-runtime/zkm_runtime/deserialize.go

@@ -0,0 +1,130 @@
+package zkm_runtime
+
+import (
+ "encoding/binary"
+ "fmt"
+ "reflect"
+)
+
+func DeserializeData(data []byte, e any) {
+ if e == nil {
+ return
+ }
+ value := reflect.ValueOf(e)
+ // If e represents a value as opposed to a pointer, the answer won't
+ // get back to the caller. Make sure it's a pointer.
+ if value.Type().Kind() != reflect.Pointer {
+ panic("attempt to deserialize into a non-pointer")
+ }
+
+ if value.IsValid() {
+ if value.Kind() == reflect.Pointer && !value.IsNil() {
+ // That's okay, we'll store through the pointer.
+ } else if !value.CanSet() {
+ panic("gob: DecodeValue of unassignable value")
+ }
+ }
+
+ index, err := deserializeData(data, value.Elem(), 0)
+ if err != nil {
+ panic(err)
+ }
+ if index != len(data) {
+ panic("deserialize failed")
+ }
+}
+
+func deserializeData(data []byte, v reflect.Value, index int) (int, error) {
+ switch v.Kind() {
+ case reflect.Bool:
+ v.SetBool(data[index] == 1)
+ return index + 1, nil
+ case reflect.Int8:
+ v.SetInt(int64(int8(data[index])))
+ return index + 1, nil
+ case reflect.Uint8:
+ v.SetUint(uint64(data[index]))
+ return index + 1, nil
+ case reflect.Int16:
+ b := []byte{data[index], data[index+1]}
+ a := binary.LittleEndian.Uint16(b)
+ v.SetInt(int64(int16(a)))
+ return index + 2, nil
+ case reflect.Uint16:
+ b := []byte{data[index], data[index+1]}
+ a := binary.LittleEndian.Uint16(b)
+ v.SetUint(uint64(a))
+ return index + 2, nil
+ case reflect.Int32:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3]}
+ a := binary.LittleEndian.Uint32(b)
+ v.SetInt(int64(int32(a)))
+ return index + 4, nil
+ case reflect.Uint32:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3]}
+ a := binary.LittleEndian.Uint32(b)
+ v.SetUint(uint64(a))
+ return index + 4, nil
+ case reflect.Int64:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3],
+ data[index+4], data[index+5], data[index+6], data[index+7]}
+ a := binary.LittleEndian.Uint64(b)
+ v.SetInt(int64(a))
+ return index + 8, nil
+ case reflect.Uint64:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3],
+ data[index+4], data[index+5], data[index+6], data[index+7]}
+ a := binary.LittleEndian.Uint64(b)
+ v.SetUint(a)
+ return index + 8, nil
+ case reflect.Slice:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3],
+ data[index+4], data[index+5], data[index+6], data[index+7]}
+
+ length := binary.LittleEndian.Uint64(b)
+ index += 8
+ switch v.Type().Elem().Kind() {
+ case reflect.Uint8:
+ bytes := data[index : index+int(length)]
+ v.SetBytes(bytes)
+ return index + int(length), nil
+ }
+ return index, fmt.Errorf("unsupport type: %v, elem: %v", v.Kind(), v.Elem().Kind())
+ case reflect.Array:
+ for i := 0; i < v.Len(); i++ {
+ var err error
+ index, err = deserializeData(data, v.Index(i), index)
+ if err != nil {
+ return index, err
+ }
+ }
+ return index, nil
+ case reflect.String:
+ b := []byte{data[index], data[index+1], data[index+2], data[index+3],
+ data[index+4], data[index+5], data[index+6], data[index+7]}
+ l := binary.LittleEndian.Uint64(b)
+ index += 8
+ length := int(l)
+ str := make([]byte, length)
+ copy(str[:], data[index:index+length])
+ v.SetString(string(str))
+ return index + length, nil
+ case reflect.Ptr:
+ if data[index] == 0 {
+ v.SetZero()
+ return index + 1, nil
+ }
+ return deserializeData(data, v.Elem(), index+1)
+ case reflect.Struct:
+ for i := 0; i < v.NumField(); i++ {
+ field := v.Field(i)
+ var err error
+ index, err = deserializeData(data, field, index)
+ if err != nil {
+ return index, err
+ }
+ }
+ return index, nil
+ }
+ return index, fmt.Errorf("unsupport type: %v", v.Kind())
+}

go-runtime/zkm_runtime/go.mod

@@ -0,0 +1,3 @@
+module github.com/zkMIPS/zkm/go-runtime/zkm_runtime
+
+go 1.22.5

go-runtime/zkm_runtime/runtime.go

@@ -0,0 +1,30 @@
+//go:build mips
+// +build mips
+
+package zkm_runtime
+
+func SyscallWrite(fd int, write_buf []byte, nbytes int) int
+func SyscallHintLen() int
+func SyscallHintRead(ptr []byte, len int)
+
+func Read[T any]() T {
+ len := SyscallHintLen()
+ var value []byte
+ capacity := (len + 3) / 4 * 4
+ value = make([]byte, capacity)
+ var result T
+ SyscallHintRead(value, len)
+ DeserializeData(value[0:len], &result)
+ return result
+}
+
+func Commit[T any](value T) {
+ bytes := MustSerializeData(value)
+ length := len(bytes)
+ if (length & 3) != 0 {
+ d := make([]byte, 4-(length&3))
+ bytes = append(bytes, d...)
+ }
+
+ SyscallWrite(3, bytes, length)
+}

go-runtime/zkm_runtime/serialize.go

@@ -0,0 +1,114 @@
+// ported from https://github.com/blocto/solana-go-sdk/blob/v1.30.0/pkg/bincode/serialize.go
+
+package zkm_runtime
+
+import (
+ "encoding/binary"
+ "fmt"
+ "reflect"
+)
+
+func SerializeData(data any) ([]byte, error) {
+ return serializeData(reflect.ValueOf(data))
+}
+
+func MustSerializeData(data interface{}) []byte {
+ serializedData, err := serializeData(reflect.ValueOf(data))
+ if err != nil {
+ panic(err)
+ }
+ return serializedData
+}
+
+func serializeData(v reflect.Value) ([]byte, error) {
+ switch v.Kind() {
+ case reflect.Bool:
+ if v.Bool() {
+ return []byte{1}, nil
+ }
+ return []byte{0}, nil
+ case reflect.Int8:
+ return []byte{uint8(v.Int())}, nil
+ case reflect.Uint8:
+ return []byte{uint8(v.Uint())}, nil
+ case reflect.Int16:
+ b := make([]byte, 2)
+ binary.LittleEndian.PutUint16(b, uint16(v.Int()))
+ return b, nil
+ case reflect.Uint16:
+ b := make([]byte, 2)
+ binary.LittleEndian.PutUint16(b, uint16(v.Uint()))
+ return b, nil
+ case reflect.Int32:
+ b := make([]byte, 4)
+ binary.LittleEndian.PutUint32(b, uint32(v.Int()))
+ return b, nil
+ case reflect.Uint32:
+ b := make([]byte, 4)
+ binary.LittleEndian.PutUint32(b, uint32(v.Uint()))
+ return b, nil
+ case reflect.Int64:
+ b := make([]byte, 8)
+ binary.LittleEndian.PutUint64(b, uint64(v.Int()))
+ return b, nil
+ case reflect.Uint64:
+ b := make([]byte, 8)
+ binary.LittleEndian.PutUint64(b, uint64(v.Uint()))
+ return b, nil
+ case reflect.Slice:
+ switch v.Type().Elem().Kind() {
+ case reflect.Uint8:
+ output := make([]byte, 8)
+ binary.LittleEndian.PutUint64(output, uint64(v.Len()))
+
+ for i := 0; i < v.Len(); i++ {
+ d, err := serializeData(v.Index(i))
+ if err != nil {
+ return nil, err
+ }
+ output = append(output, d...)
+ }
+ return output, nil
+ }
+ return nil, fmt.Errorf("unsupport type: %v, elem: %v", v.Kind(), v.Elem().Kind())
+ case reflect.Array:
+ switch v.Type().Elem().Kind() {
+ case reflect.Uint8:
+ b := make([]byte, 0, v.Len())
+ for i := 0; i < v.Len(); i++ {
+ b = append(b, byte(v.Index(i).Uint()))
+ }
+ return b, nil
+ }
+ return nil, fmt.Errorf("unsupport type: %v, elem: %v", v.Kind(), v.Elem().Kind())
+ case reflect.String:
+ b := make([]byte, 8+len(v.String()))
+ binary.LittleEndian.PutUint64(b, uint64(len(v.String())))
+ copy(b[8:], []byte(v.String()))
+ return b, nil
+ case reflect.Ptr:
+ if v.IsNil() {
+ return []byte{0}, nil
+ }
+ d, err := serializeData(v.Elem())
+ if err != nil {
+ return nil, err
+ }
+ b := make([]byte, 1+len(d))
+ b[0] = 1
+ copy(b[1:], d[:])
+ return b, nil
+ case reflect.Struct:
+ data := make([]byte, 0, 1024)
+ for i := 0; i < v.NumField(); i++ {
+ field := v.Field(i)
+ d, err := serializeData(field)
+ if err != nil {
+ return nil, err
+ }
+ data = append(data, d...)
+ }
+ return data, nil
+ }
+ return nil, fmt.Errorf("unsupport type: %v", v.Kind())
+}

go-runtime/zkm_runtime/syscall_mips.s

@@ -0,0 +1,24 @@
+//go:build mips
+// +build mips
+
+TEXT ·SyscallWrite(SB), $0-24
+ MOVW $4004, R2 // #define SYS_write 4004
+ MOVW fd+0(FP), R4
+ MOVW write_buf+4(FP), R5
+ MOVW nbytes+16(FP), R6
+ SYSCALL
+ MOVW R2, ret+0(FP)
+ RET
+
+TEXT ·SyscallHintLen(SB), $0-4
+ MOVW $0xF0, R2 // #define SYS_hint_len 0xF0
+ SYSCALL
+ MOVW R2, ret+0(FP)
+ RET
+
+TEXT ·SyscallHintRead(SB), $0-16
+ MOVW $0xF1, R2 // #define SYS_hint_read 0xF1
+ MOVW ptr+0(FP), R4
+ MOVW len+12(FP), R5
+ SYSCALL
+ RET

prover/examples/README.md

@@ -15,32 +15,37 @@ GOOS=linux GOARCH=mips GOMIPS=softfloat go build hello.go
 ```
 BASEDIR=./emulator/test-vectors RUST_LOG=info ELF_PATH=./emulator/test-vectors/minigeth BLOCK_NO=13284491 SEG_OUTPUT=/tmp/output SEG_SIZE=1024 ARGS="" \
  cargo run --release --example zkmips split
+```
 
-OR
+* Generate proof for specific segment (Set SEG_START_ID to specific segment id and set SEG_NUM to 1)
 
-RUST_LOG=info ELF_PATH=./emulator/test-vectors/hello SEG_OUTPUT=/tmp/output SEG_SIZE=1024 ARGS="" \
- cargo run --release --example zkmips split_without_preimage
+```
+BASEDIR=./emulator/test-vectors RUST_LOG=info BLOCK_NO=13284491 SEG_FILE_DIR="/tmp/output" SEG_START_ID=0 SEG_NUM=1 SEG_SIZE=1024 \
+ cargo run --release --example zkmips prove_segments
 ```
 
-* Generate proof for each segment
+* Aggregate proof all segments (Set SEG_START_ID to 0, and set SEG_NUM to the total segments number)
 
 ```
-BASEDIR=./emulator/test-vectors RUST_LOG=info BLOCK_NO=13284491 SEG_FILE="/tmp/output/0" SEG_SIZE=1024 \
- cargo run --release --example zkmips prove
+BASEDIR=./emulator/test-vectors RUST_LOG=info BLOCK_NO=13284491 SEG_FILE_DIR="/tmp/output" SEG_START_ID=0 SEG_NUM=299 SEG_SIZE=1024 \
+ cargo run --release --example zkmips prove_segments
 ```
 
-* Aggregate proof
+### Prove Go sdk code
+The SDK provide Read and Commit interface to read input and commit output.
+Take add-go for example:
+
+* Build the add-go
 
 ```
-BASEDIR=./emulator/test-vectors RUST_LOG=info BLOCK_NO=13284491 SEG_FILE="/tmp/output/0" SEG_FILE2="/tmp/output/1" SEG_SIZE=1024 \
- cargo run --release --example zkmips aggregate_proof
+cd prover/examples/add-go
+GOOS=linux GOARCH=mips GOMIPS=softfloat go build .
+cd ../../
 ```
-
-* Aggregate proof all
+* Run the host program 
 
 ```
-BASEDIR=./emulator/test-vectors RUST_LOG=info BLOCK_NO=13284491 SEG_FILE_DIR="/tmp/output" SEG_FILE_NUM=299 SEG_SIZE=1024 \
- cargo run --release --example zkmips aggregate_proof_all
+RUST_LOG=info ELF_PATH=examples/add-go/go-add HOST_PROGRAM=add_example SEG_OUTPUT=/tmp/output SEG_SIZE=262144 cargo run --release --example zkmips prove_host_program
 ```
 
 ## Prove the Rust code 
@@ -75,9 +80,9 @@ cargo build --target=mips-unknown-linux-musl
 
 cd ../..
 
-ARGS="711e9609339e92b03ddc0a211827dba421f38f9ed8b9d806e1ffdd8c15ffa03d world!" RUST_LOG=info ELF_PATH=examples/sha2/target/mips-unknown-linux-musl/debug/sha2-bench SEG_OUTPUT=/tmp/output cargo run --release --example zkmips bench
+ARGS="711e9609339e92b03ddc0a211827dba421f38f9ed8b9d806e1ffdd8c15ffa03d world!" RUST_LOG=info ELF_PATH=examples/sha2/target/mips-unknown-linux-musl/debug/sha2-bench HOST_PROGRAM=sha2_bench SEG_OUTPUT=/tmp/output cargo run --release --example zkmips prove_host_program
 
 Or
 
-RUST_LOG=info ELF_PATH=examples/revme/target/mips-unknown-linux-musl/debug/evm JSON_PATH=../emulator/test-vectors/test.json SEG_OUTPUT=/tmp/output SEG_SIZE=262144 cargo run --release --example zkmips revm
+RUST_LOG=info ELF_PATH=examples/revme/target/mips-unknown-linux-musl/debug/evm HOST_PROGRAM=revm JSON_PATH=../emulator/test-vectors/test.json SEG_OUTPUT=/tmp/output SEG_SIZE=262144 cargo run --release --example zkmips prove_host_program
 ```