chore(ffi): Change ffi bindings to explicitly be uint32_t (#197)

Co-authored-by: Mariano A. Nicolini <mariano.nicolini.91@gmail.com>

Author: PatStiles

operator/pkg/operator.go

@@ -214,12 +214,12 @@ func (o *Operator) verify(verificationData VerificationData, results chan bool)
 	case common.SP1:
 		proofBytes := make([]byte, sp1.MaxProofSize)
 		copy(proofBytes, verificationData.Proof)
-		proofLen := (uint)(len(verificationData.Proof))
+		proofLen := (uint32)(len(verificationData.Proof))
 
 		elf := verificationData.VmProgramCode
 		elfBytes := make([]byte, sp1.MaxElfBufferSize)
 		copy(elfBytes, elf)
-		elfLen := (uint)(len(elf))
+		elfLen := (uint32)(len(elf))
 
 		verificationResult := sp1.VerifySp1Proof(([sp1.MaxProofSize]byte)(proofBytes), proofLen, ([sp1.MaxElfBufferSize]byte)(elfBytes), elfLen)
 		o.Logger.Infof("SP1 proof verification result: %t", verificationResult)

operator/risc_zero/lib/risc_zero.h

@@ -1,3 +1,4 @@
 #include <stdbool.h>
+#include <stdint.h>
 
-bool verify_risc_zero_receipt_ffi(unsigned char *receipt_bytes, unsigned int receipt_len, unsigned int *image_id);
+bool verify_risc_zero_receipt_ffi(unsigned char *receipt_bytes, uint32_t receipt_len, uint32_t *image_id);

operator/risc_zero/lib/src/lib.rs

@@ -5,10 +5,10 @@ pub const MAX_RECEIPT_SIZE: usize = 215523;
 #[no_mangle]
 pub extern "C" fn verify_risc_zero_receipt_ffi(
     receipt_bytes: &[u8; MAX_RECEIPT_SIZE],
-    receipt_len: usize,
+    receipt_len: u32,
     image_id: &[u32; 8],
 ) -> bool {
-    if let Ok(receipt) = bincode::deserialize::<Receipt>(&receipt_bytes[..receipt_len]) {
+    if let Ok(receipt) = bincode::deserialize::<Receipt>(&receipt_bytes[..receipt_len as usize]) {
         return receipt.verify(*image_id).is_ok();
     }
     false
@@ -24,7 +24,7 @@ mod tests {
 
     #[test]
     fn verify_risc_zero_receipt_with_image_id_works() {
-        const RECEIPT_SIZE: usize = RECEIPT.len();
+        const RECEIPT_SIZE: u32 = RECEIPT.len() as u32;
         let mut receipt_buffer = [0u8; super::MAX_RECEIPT_SIZE];
         receipt_buffer[..RECEIPT_SIZE].clone_from_slice(RECEIPT);
 
@@ -36,7 +36,7 @@ mod tests {
 
     #[test]
     fn verify_risc_zero_aborts_with_bad_proof() {
-        const RECEIPT_SIZE: usize = RECEIPT.len();
+        const RECEIPT_SIZE: u32 = RECEIPT.len() as u32;
         let mut receipt_buffer = [42u8; super::MAX_RECEIPT_SIZE];
         receipt_buffer[..RECEIPT_SIZE].clone_from_slice(RECEIPT);
 

operator/risc_zero/risc_zero.go

@@ -13,8 +13,8 @@ const (
 	MaxReceiptSize = 215523
 )
 
-func VerifyRiscZeroReceipt(receiptBuffer [MaxReceiptSize]byte, receiptLen uint, imageIdBuffer [8]uint32) bool {
+func VerifyRiscZeroReceipt(receiptBuffer [MaxReceiptSize]byte, receiptLen uint32, imageIdBuffer [8]uint32) bool {
 	receiptPtr := (*C.uchar)(unsafe.Pointer(&receiptBuffer[0]))
-	imageIdPtr := (*C.uint)(unsafe.Pointer(&imageIdBuffer[0]))
-	return (bool)(C.verify_risc_zero_receipt_ffi(receiptPtr, (C.uint)(receiptLen), imageIdPtr))
+	imageIdPtr := (*C.uint32_t)(unsafe.Pointer(&imageIdBuffer[0]))
+	return (bool)(C.verify_risc_zero_receipt_ffi(receiptPtr, (C.uint32_t)(receiptLen), imageIdPtr))
 }

operator/risc_zero/risc_zero_test.go

@@ -21,7 +21,7 @@ func TestFibonacciRiscZeroProofVerifies(t *testing.T) {
 
 	imageId := getImageIdsFromFile(t, "../../task_sender/test_examples/risc_zero/fibonacci_proof_generator/fibonacci_id.txt")
 
-	if !risc_zero.VerifyRiscZeroReceipt(([risc_zero.MaxReceiptSize]byte)(receiptBytes), uint(nReadReceiptBytes), ([8]uint32)(imageId)) {
+	if !risc_zero.VerifyRiscZeroReceipt(([risc_zero.MaxReceiptSize]byte)(receiptBytes), uint32(nReadReceiptBytes), ([8]uint32)(imageId)) {
 		t.Errorf("proof did not verify")
 	}
 }

operator/sp1/lib/sp1.h

@@ -1,4 +1,5 @@
 #include <stdbool.h>
+#include <stdint.h>
 
-bool verify_sp1_proof_ffi(unsigned char *proof_buffer, unsigned int proof_len,
-                          unsigned char *elf_buffer, unsigned int elf_len);
+bool verify_sp1_proof_ffi(unsigned char *proof_buffer, uint32_t proof_len,
+                          unsigned char *elf_buffer, uint32_t elf_len);

operator/sp1/lib/src/lib.rs

@@ -10,13 +10,13 @@ lazy_static! {
 #[no_mangle]
 pub extern "C" fn verify_sp1_proof_ffi(
     proof_bytes: &[u8; MAX_PROOF_SIZE],
-    proof_len: usize,
+    proof_len: u32,
     elf_bytes: &[u8; MAX_ELF_BUFFER_SIZE],
-    elf_len: usize,
+    elf_len: u32,
 ) -> bool {
-    let real_elf = &elf_bytes[0..elf_len];
+    let real_elf = &elf_bytes[0..(elf_len as usize)];
 
-    if let Ok(proof) = bincode::deserialize(&proof_bytes[..proof_len]) {
+    if let Ok(proof) = bincode::deserialize(&proof_bytes[..(proof_len as usize)]) {
         let (_pk, vk) = PROVER_CLIENT.setup(real_elf);
         return PROVER_CLIENT.verify(&proof, &vk).is_ok();
     }
@@ -43,7 +43,7 @@ mod tests {
         let elf_size = ELF.len();
         elf_buffer[..elf_size].clone_from_slice(ELF);
 
-        let result = verify_sp1_proof_ffi(&proof_buffer, proof_size, &elf_buffer, elf_size);
+        let result = verify_sp1_proof_ffi(&proof_buffer, proof_size as u32, &elf_buffer, elf_size as u32);
         assert!(result)
     }
 
@@ -57,7 +57,7 @@ mod tests {
         let elf_size = ELF.len();
         elf_buffer[..elf_size].clone_from_slice(ELF);
 
-        let result = verify_sp1_proof_ffi(&proof_buffer, proof_size - 1, &elf_buffer, elf_size);
+        let result = verify_sp1_proof_ffi(&proof_buffer, (proof_size - 1) as u32, &elf_buffer, elf_size as u32);
         assert!(!result)
     }
 }

operator/sp1/sp1.go

@@ -15,8 +15,8 @@ const MaxProofSize = 2 * 1024 * 1024
 // MaxElfBufferSize 1 MB
 const MaxElfBufferSize = 1024 * 1024
 
-func VerifySp1Proof(proofBuffer [MaxProofSize]byte, proofLen uint, elfBuffer [MaxElfBufferSize]byte, elfLen uint) bool {
+func VerifySp1Proof(proofBuffer [MaxProofSize]byte, proofLen uint32, elfBuffer [MaxElfBufferSize]byte, elfLen uint32) bool {
 	proofPtr := (*C.uchar)(unsafe.Pointer(&proofBuffer[0]))
 	elfPtr := (*C.uchar)(unsafe.Pointer(&elfBuffer[0]))
-	return (bool)(C.verify_sp1_proof_ffi(proofPtr, (C.uint)(proofLen), elfPtr, (C.uint)(elfLen)))
+	return (bool)(C.verify_sp1_proof_ffi(proofPtr, (C.uint32_t)(proofLen), elfPtr, (C.uint32_t)(elfLen)))
 }

operator/sp1/sp1_test.go

@@ -28,7 +28,7 @@ func TestFibonacciSp1ProofVerifies(t *testing.T) {
 		t.Errorf("could not read bytes from file")
 	}
 
-	if !sp1.VerifySp1Proof(([sp1.MaxProofSize]byte)(proofBytes), uint(nReadProofBytes), ([sp1.MaxElfBufferSize]byte)(elfBytes), uint(nReadElfBytes)) {
+	if !sp1.VerifySp1Proof(([sp1.MaxProofSize]byte)(proofBytes), uint32(nReadProofBytes), ([sp1.MaxElfBufferSize]byte)(elfBytes), uint32(nReadElfBytes)) {
 		t.Errorf("proof did not verify")
 	}
 }