feat(ffi): ffi refactors (#1092)

Author: PatStiles

batcher/aligned-batcher/gnark/verifier.go

@@ -15,15 +15,21 @@ import "C"
 
 import (
 	"bytes"
+	"log"
+	"unsafe"
+
 	"github.com/consensys/gnark-crypto/ecc"
 	"github.com/consensys/gnark/backend/groth16"
 	"github.com/consensys/gnark/backend/plonk"
 	"github.com/consensys/gnark/backend/witness"
-	"log"
-	"unsafe"
 )
 
 func listRefToBytes(listRef C.ListRef) []byte {
+
+	if listRef.len == 0 {
+		return []byte{}
+	}
+
 	return C.GoBytes(unsafe.Pointer(listRef.ptr), C.int(listRef.len))
 }
 

operator/halo2ipa/halo2ipa.go

@@ -10,9 +10,9 @@ import "C"
 import "unsafe"
 
 func VerifyHalo2IpaProof(
-	proofBuffer []byte, proofLen uint32,
-	paramsBuffer []byte, paramsLen uint32,
-	publicInputBuffer []byte, publicInputLen uint32,
+	proofBuffer []byte,
+	paramsBuffer []byte,
+	publicInputBuffer []byte,
 ) bool {
 	/*
 		For Halo2 the `paramsBuffer` contains the serialized cs, vk, and params with there respective sizes serialized as u32 values (4 bytes) => 3 * 4 bytes = 12 followed by the concatenated variable length buffers:
@@ -28,8 +28,8 @@ func VerifyHalo2IpaProof(
 	publicInputPtr := (*C.uchar)(unsafe.Pointer(&publicInputBuffer[0]))
 
 	return (bool)(C.verify_halo2_ipa_proof_ffi(
-		proofPtr, (C.uint32_t)(proofLen),
-		paramsPtr, (C.uint32_t)(paramsLen),
-		publicInputPtr, (C.uint32_t)(publicInputLen),
+		proofPtr, (C.uint32_t)(len(proofBuffer)),
+		paramsPtr, (C.uint32_t)(len(paramsBuffer)),
+		publicInputPtr, (C.uint32_t)(len(publicInputBuffer)),
 	))
 }

operator/halo2ipa/halo2ipa_test.go

@@ -7,55 +7,32 @@ import (
 	"github.com/yetanotherco/aligned_layer/operator/halo2ipa"
 )
 
-const MaxProofSize = 8 * 1024
-
-const MaxParamsSize = 8 * 1024
-
-const MaxPublicInputSize = 4 * 1024
-
 const ProofFilePath = "../../scripts/test_files/halo2_ipa/proof.bin"
 
 const PublicInputPath = "../../scripts/test_files/halo2_ipa/pub_input.bin"
 
 const ParamsFilePath = "../../scripts/test_files/halo2_ipa/params.bin"
 
 func TestHalo2IpaProofVerifies(t *testing.T) {
-	proofFile, err := os.Open(ProofFilePath)
+	proofBytes, err := os.ReadFile(ProofFilePath)
 	if err != nil {
 		t.Errorf("could not open proof file: %s", err)
 	}
-	proofBytes := make([]byte, MaxProofSize)
-	nReadProofBytes, err := proofFile.Read(proofBytes)
-	if err != nil {
-		t.Errorf("could not read bytes from file")
-	}
-	defer proofFile.Close()
 
-	paramsFile, err := os.Open(ParamsFilePath)
+	paramsBytes, err := os.ReadFile(ParamsFilePath)
 	if err != nil {
-		t.Errorf("could not open proof file: %s", err)
+		t.Errorf("could not open params file: %s", err)
 	}
-	paramsBytes := make([]byte, MaxParamsSize)
-	nReadParamsBytes, err := paramsFile.Read(paramsBytes)
-	if err != nil {
-		t.Errorf("could not read bytes from file")
-	}
-	defer paramsFile.Close()
 
-	publicInputFile, err := os.Open(PublicInputPath)
-	if err != nil {
-		t.Errorf("could not open proof file: %s", err)
-	}
-	publicInputBytes := make([]byte, MaxPublicInputSize)
-	nReadPublicInputBytes, err := publicInputFile.Read(publicInputBytes)
+	publicInputBytes, err := os.ReadFile(PublicInputPath)
 	if err != nil {
-		t.Errorf("could not read bytes from file")
+		t.Errorf("could not open public input file: %s", err)
 	}
 
 	if !halo2ipa.VerifyHalo2IpaProof(
-		([]byte)(proofBytes), uint32(nReadProofBytes),
-		([]byte)(paramsBytes), uint32(nReadParamsBytes),
-		([]byte)(publicInputBytes), uint32(nReadPublicInputBytes),
+		([]byte)(proofBytes),
+		([]byte)(paramsBytes),
+		([]byte)(publicInputBytes),
 	) {
 		t.Errorf("proof did not verify")
 	}

operator/halo2kzg/halo2kzg.go

@@ -9,9 +9,9 @@ import "C"
 import "unsafe"
 
 func VerifyHalo2KzgProof(
-	proofBuffer []byte, proofLen uint32,
-	paramsBuffer []byte, paramsLen uint32,
-	publicInputBuffer []byte, publicInputLen uint32,
+	proofBuffer []byte,
+	paramsBuffer []byte,
+	publicInputBuffer []byte,
 ) bool {
 	/*
 		For Halo2 the `paramsBuffer` contains the serialized cs, vk, and params with there respective sizes serialized as u32 values (4 bytes) => 3 * 4 bytes = 12 followed by the concatenated variable length buffers:
@@ -27,8 +27,8 @@ func VerifyHalo2KzgProof(
 	publicInputPtr := (*C.uchar)(unsafe.Pointer(&publicInputBuffer[0]))
 
 	return (bool)(C.verify_halo2_kzg_proof_ffi(
-		proofPtr, (C.uint32_t)(proofLen),
-		paramsPtr, (C.uint32_t)(paramsLen),
-		publicInputPtr, (C.uint32_t)(publicInputLen),
+		proofPtr, (C.uint32_t)(len(proofBuffer)),
+		paramsPtr, (C.uint32_t)(len(paramsBuffer)),
+		publicInputPtr, (C.uint32_t)(len(publicInputBuffer)),
 	))
 }

operator/halo2kzg/halo2kzg_test.go

@@ -7,58 +7,32 @@ import (
 	"github.com/yetanotherco/aligned_layer/operator/halo2kzg"
 )
 
-// MaxProofSize 4KB
-const MaxProofSize = 8 * 1024
-
-// MaxProofSize 4KB
-const MaxParamsSize = 8 * 1024
-
-// MaxPublicInputSize 4KB
-const MaxPublicInputSize = 4 * 1024
-
 const ProofFilePath = "../../scripts/test_files/halo2_kzg/proof.bin"
 
 const PublicInputPath = "../../scripts/test_files/halo2_kzg/pub_input.bin"
 
 const ParamsFilePath = "../../scripts/test_files/halo2_kzg/params.bin"
 
 func TestHalo2KzgProofVerifies(t *testing.T) {
-	proofFile, err := os.Open(ProofFilePath)
+	proofBytes, err := os.ReadFile(ProofFilePath)
 	if err != nil {
 		t.Errorf("could not open proof file: %s", err)
 	}
-	proofBytes := make([]byte, MaxProofSize)
-	nReadProofBytes, err := proofFile.Read(proofBytes)
-	if err != nil {
-		t.Errorf("could not read bytes from file")
-	}
-	defer proofFile.Close()
 
-	paramsFile, err := os.Open(ParamsFilePath)
+	paramsBytes, err := os.ReadFile(ParamsFilePath)
 	if err != nil {
-		t.Errorf("could not open proof file: %s", err)
+		t.Errorf("could not open params file: %s", err)
 	}
-	paramsBytes := make([]byte, MaxParamsSize)
-	nReadParamsBytes, err := paramsFile.Read(paramsBytes)
-	if err != nil {
-		t.Errorf("could not read bytes from file")
-	}
-	defer paramsFile.Close()
 
-	publicInputFile, err := os.Open(PublicInputPath)
-	if err != nil {
-		t.Errorf("could not open proof file: %s", err)
-	}
-	publicInputBytes := make([]byte, MaxPublicInputSize)
-	nReadPublicInputBytes, err := publicInputFile.Read(publicInputBytes)
+	publicInputBytes, err := os.ReadFile(PublicInputPath)
 	if err != nil {
-		t.Errorf("could not read bytes from file")
+		t.Errorf("could not open public input file: %s", err)
 	}
 
 	if !halo2kzg.VerifyHalo2KzgProof(
-		([]byte)(proofBytes), uint32(nReadProofBytes),
-		([]byte)(paramsBytes), uint32(nReadParamsBytes),
-		([]byte)(publicInputBytes), uint32(nReadPublicInputBytes),
+		([]byte)(proofBytes),
+		([]byte)(paramsBytes),
+		([]byte)(publicInputBytes),
 	) {
 		t.Errorf("proof did not verify")
 	}

operator/merkle_tree/lib/test_files/merkle_root.bin

@@ -1 +1 @@
-e0a3761a514a2a7873350869e699bbd87c9cbf53ba963caae0a232cb6d698b1b
+715181f01c095618472a72cd06e384d92f02eadc4ea28bf097181b17fdc57f28

operator/merkle_tree/lib/test_files/merkle_tree_batch.bin

@@ -9,12 +9,12 @@ package merkle_tree
 import "C"
 import "unsafe"
 
-func VerifyMerkleTreeBatch(batchBuffer []byte, batchLen uint, merkleRootBuffer [32]byte) bool {
+func VerifyMerkleTreeBatch(batchBuffer []byte, merkleRootBuffer [32]byte) bool {
 	if len(batchBuffer) == 0 {
 		return false
 	}
 
 	batchPtr := (*C.uchar)(unsafe.Pointer(&batchBuffer[0]))
 	merkleRootPtr := (*C.uchar)(unsafe.Pointer(&merkleRootBuffer[0]))
-	return (bool)(C.verify_merkle_tree_batch_ffi(batchPtr, (C.uint)(batchLen), merkleRootPtr))
+	return (bool)(C.verify_merkle_tree_batch_ffi(batchPtr, (C.uint)(len(batchBuffer)), merkleRootPtr))
 }

operator/merkle_tree/merkle_tree.go

@@ -3,28 +3,21 @@ package merkle_tree
 import (
 	"encoding/hex"
 	"fmt"
-	"io"
 	"os"
 	"testing"
 )
 
-func TestVerifyMerkleTreeBatch(t *testing.T) {
-	batchFile, err := os.Open("lib/test_files/merkle_tree_batch.bin")
-	if err != nil {
-		t.Fatalf("Error opening batch file: %v", err)
-	}
+const BatchFilePath = "lib/test_files/merkle_tree_batch.bin"
 
-	batchByteValue, err := io.ReadAll(batchFile)
-	if err != nil {
-		t.Fatalf("Error reading batch file: %v", err)
-	}
+const RootFilePath = "lib/test_files/merkle_root.bin"
 
-	rootFile, err := os.Open("lib/test_files/merkle_root.bin")
+func TestVerifyMerkleTreeBatch(t *testing.T) {
+	batchByteValue, err := os.ReadFile(BatchFilePath)
 	if err != nil {
-		t.Fatalf("Error opening batch file: %v", err)
+		t.Fatalf("Error reading batch file: %v", err)
 	}
 
-	rootByteValue, err := io.ReadAll(rootFile)
+	rootByteValue, err := os.ReadFile(RootFilePath)
 	if err != nil {
 		t.Fatalf("Error reading batch file: %v", err)
 	}
@@ -39,7 +32,7 @@ func TestVerifyMerkleTreeBatch(t *testing.T) {
 	var merkleRoot [32]byte
 	copy(merkleRoot[:], merkle_root)
 
-	if !VerifyMerkleTreeBatch(batchByteValue, uint(len(batchByteValue)), merkleRoot) {
+	if !VerifyMerkleTreeBatch(batchByteValue, merkleRoot) {
 		t.Errorf("Batch did not verify Merkle Root")
 	}
 

operator/merkle_tree/merkle_tree_test.go

@@ -9,12 +9,12 @@ package merkle_tree_old
 import "C"
 import "unsafe"
 
-func VerifyMerkleTreeBatchOld(batchBuffer []byte, batchLen uint, merkleRootBuffer [32]byte) bool {
+func VerifyMerkleTreeBatchOld(batchBuffer []byte, merkleRootBuffer [32]byte) bool {
 	if len(batchBuffer) == 0 {
 		return false
 	}
 
 	batchPtr := (*C.uchar)(unsafe.Pointer(&batchBuffer[0]))
 	merkleRootPtr := (*C.uchar)(unsafe.Pointer(&merkleRootBuffer[0]))
-	return (bool)(C.verify_merkle_tree_batch_ffi_old(batchPtr, (C.uint)(batchLen), merkleRootPtr))
+	return (bool)(C.verify_merkle_tree_batch_ffi_old(batchPtr, (C.uint)(len(batchBuffer)), merkleRootPtr))
 }