Skip to content

Commit 4fe4a2f

Browse files
gabrielbosiogabrielbosio
committed
Fix Mina FFI tests
1 parent 279aa75 commit 4fe4a2f

File tree

5 files changed

+107
-140
lines changed

5 files changed

+107
-140
lines changed

‎operator/mina/lib/mina_verifier.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
#include <stdbool.h>
2+
#include <stdint.h>
23

3-
bool verify_mina_state_ffi(unsigned char *proof_buffer,
4-
unsigned int proof_len,
5-
unsigned char *pub_input_buffer,
6-
unsigned int pub_input_len);
4+
int32_t verify_mina_state_ffi(unsigned char *proof_buffer, uint32_t proof_len,
5+
unsigned char *pub_input_buffer,
6+
uint32_t pub_input_len);

‎operator/mina/lib/src/lib.rs‎

Lines changed: 47 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -37,9 +37,25 @@ lazy_static! {
3737
#[no_mangle]
3838
pub extern "C" fn verify_mina_state_ffi(
3939
proof_bytes: *const u8,
40-
proof_len: usize,
40+
proof_len: u32,
4141
pub_input_bytes: *const u8,
42-
pub_input_len: usize,
42+
pub_input_len: u32,
43+
) -> i32 {
44+
let result = std::panic::catch_unwind(|| {
45+
inner_verify_mina_state_ffi(proof_bytes, proof_len, pub_input_bytes, pub_input_len)
46+
});
47+
48+
match result {
49+
Ok(v) => v as i32,
50+
Err(_) => -1,
51+
}
52+
}
53+
54+
fn inner_verify_mina_state_ffi(
55+
proof_bytes: *const u8,
56+
proof_len: u32,
57+
pub_input_bytes: *const u8,
58+
pub_input_len: u32,
4359
) -> bool {
4460
if proof_bytes.is_null() || pub_input_bytes.is_null() {
4561
error!("Input buffer null");
@@ -233,105 +249,51 @@ mod test {
233249

234250
#[test]
235251
fn valid_mina_state_proof_verifies() {
236-
let mut proof_buffer = [0u8; PROOF_BYTES.len()];
237-
let proof_size = PROOF_BYTES.len();
238-
assert!(proof_size <= proof_buffer.len());
239-
proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
240-
241-
let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
242-
let pub_input_size = PUB_INPUT_BYTES.len();
243-
assert!(pub_input_size <= pub_input_buffer.len());
244-
pub_input_buffer[..pub_input_size].clone_from_slice(PUB_INPUT_BYTES);
245-
246-
let result =
247-
verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
248-
assert!(result);
252+
let result = verify_mina_state_ffi(
253+
PROOF_BYTES.as_ptr(),
254+
PROOF_BYTES.len() as u32,
255+
PUB_INPUT_BYTES.as_ptr(),
256+
PUB_INPUT_BYTES.len() as u32,
257+
);
258+
assert_eq!(result, 1);
249259
}
250260

251261
#[test]
252262
fn mina_state_proof_with_bad_bridge_tip_hash_does_not_verify() {
253-
let mut proof_buffer = [0u8; PROOF_BYTES.len()];
254-
let proof_size = PROOF_BYTES.len();
255-
assert!(proof_size <= proof_buffer.len());
256-
proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
257-
258-
let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
259-
let pub_input_size = BAD_HASH_PUB_INPUT_BYTES.len();
260-
assert!(pub_input_size <= pub_input_buffer.len());
261-
pub_input_buffer[..pub_input_size].clone_from_slice(BAD_HASH_PUB_INPUT_BYTES);
262-
263-
let result =
264-
verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
265-
assert!(!result);
263+
let result = verify_mina_state_ffi(
264+
PROOF_BYTES.as_ptr(),
265+
PROOF_BYTES.len() as u32,
266+
BAD_HASH_PUB_INPUT_BYTES.as_ptr(),
267+
BAD_HASH_PUB_INPUT_BYTES.len() as u32,
268+
);
269+
assert_eq!(result, 0);
266270
}
267271

268272
#[test]
269273
fn empty_mina_state_proof_does_not_verify() {
270-
let proof_buffer = [0u8; PROOF_BYTES.len()];
271-
let proof_size = PROOF_BYTES.len();
272-
273-
let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
274-
let pub_input_size = PUB_INPUT_BYTES.len();
275-
assert!(pub_input_size <= pub_input_buffer.len());
276-
pub_input_buffer[..pub_input_size].clone_from_slice(PUB_INPUT_BYTES);
277-
278-
let result =
279-
verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
280-
assert!(!result);
281-
}
282-
283-
#[test]
284-
fn valid_mina_state_proof_with_empty_pub_input_does_not_verify() {
285-
let mut proof_buffer = [0u8; PROOF_BYTES.len()];
286-
let proof_size = PROOF_BYTES.len();
287-
assert!(proof_size <= proof_buffer.len());
288-
proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
289-
290-
let pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
291-
let pub_input_size = PUB_INPUT_BYTES.len();
292-
293-
let result =
294-
verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
295-
assert!(!result);
296-
}
297-
298-
#[test]
299-
fn valid_mina_state_proof_with_greater_proof_size_does_not_verify() {
300-
let mut proof_buffer = [0u8; PROOF_BYTES.len()];
301-
let wrong_proof_size = PROOF_BYTES.len() + 1;
302-
proof_buffer[..PROOF_BYTES.len()].clone_from_slice(PROOF_BYTES);
303-
304-
let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
305-
let pub_input_size = PUB_INPUT_BYTES.len();
306-
assert!(pub_input_size <= pub_input_buffer.len());
307-
pub_input_buffer[..pub_input_size].clone_from_slice(PUB_INPUT_BYTES);
274+
const PROOF_SIZE: usize = PROOF_BYTES.len();
275+
let empty_proof_buffer = [0u8; PROOF_SIZE];
308276

309277
let result = verify_mina_state_ffi(
310-
&proof_buffer,
311-
wrong_proof_size,
312-
&pub_input_buffer,
313-
pub_input_size,
278+
empty_proof_buffer.as_ptr(),
279+
PROOF_SIZE as u32,
280+
PUB_INPUT_BYTES.as_ptr(),
281+
PUB_INPUT_BYTES.len() as u32,
314282
);
315-
assert!(!result);
283+
assert_eq!(result, 0);
316284
}
317285

318286
#[test]
319-
fn valid_mina_state_proof_with_greater_pub_input_size_does_not_verify() {
320-
let mut proof_buffer = [0u8; PROOF_BYTES.len()];
321-
let proof_size = PROOF_BYTES.len();
322-
assert!(proof_size <= proof_buffer.len());
323-
proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
324-
325-
let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
326-
let wrong_pub_input_size = MAX_PUB_INPUT_SIZE + 1;
327-
pub_input_buffer[..PUB_INPUT_BYTES.len()].clone_from_slice(PUB_INPUT_BYTES);
287+
fn valid_mina_state_proof_with_empty_pub_input_does_not_verify() {
288+
const PUB_INPUT_SIZE: usize = PUB_INPUT_BYTES.len();
289+
let empty_pub_input_buffer = [0u8; PUB_INPUT_SIZE];
328290

329291
let result = verify_mina_state_ffi(
330-
&proof_buffer,
331-
proof_size,
332-
&pub_input_buffer,
333-
wrong_pub_input_size,
292+
PROOF_BYTES.as_ptr(),
293+
PROOF_BYTES.len() as u32,
294+
empty_pub_input_buffer.as_ptr(),
295+
PUB_INPUT_SIZE as u32,
334296
);
335-
assert!(!result);
297+
assert_eq!(result, 0);
336298
}
337299
}

‎operator/mina/mina.go‎

Lines changed: 24 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -9,25 +9,36 @@ package mina
99
import "C"
1010
import (
1111
"fmt"
12-
"time"
1312
"unsafe"
1413
)
1514

16-
func timer() func() {
17-
start := time.Now()
18-
return func() {
19-
fmt.Printf("Mina block verification took %v\n", time.Since(start))
20-
}
21-
}
22-
23-
func VerifyMinaState(proofBuffer []byte, proofLen uint, pubInputBuffer []byte, pubInputLen uint) bool {
24-
defer timer()()
25-
15+
func VerifyMinaState(proofBuffer []byte, pubInputBuffer []byte) (isVerified bool, err error) {
16+
// Here we define the return value on failure
17+
isVerified = false
18+
err = nil
2619
if len(proofBuffer) == 0 || len(pubInputBuffer) == 0 {
27-
return false
20+
return isVerified, err
2821
}
2922

23+
// This will catch any go panic
24+
defer func() {
25+
rec := recover()
26+
if rec != nil {
27+
err = fmt.Errorf("Panic was caught while verifying sp1 proof: %s", rec)
28+
}
29+
}()
30+
3031
proofPtr := (*C.uchar)(unsafe.Pointer(&proofBuffer[0]))
3132
pubInputPtr := (*C.uchar)(unsafe.Pointer(&pubInputBuffer[0]))
32-
return (bool)(C.verify_mina_state_ffi(proofPtr, (C.uint)(proofLen), pubInputPtr, (C.uint)(pubInputLen)))
33+
34+
r := (C.int32_t)(C.verify_mina_state_ffi(proofPtr, (C.uint32_t)(len(proofBuffer)), pubInputPtr, (C.uint32_t)(len(pubInputBuffer))))
35+
36+
if r == -1 {
37+
err = fmt.Errorf("Panic happened on FFI while verifying Mina proof")
38+
return isVerified, err
39+
}
40+
41+
isVerified = (r == 1)
42+
43+
return isVerified, err
3344
}

‎operator/mina/mina_test.go‎

Lines changed: 31 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1,77 +1,71 @@
11
package mina_test
22

33
import (
4-
"fmt"
54
"os"
65
"testing"
76

87
"github.com/yetanotherco/aligned_layer/operator/mina"
98
)
109

10+
const ProofFilePath = "../../scripts/test_files/mina/mina_state.proof"
11+
12+
const PubInputFilePath = "../../scripts/test_files/mina/mina_state.pub"
13+
1114
func TestMinaStateProofVerifies(t *testing.T) {
12-
fmt.Println(os.Getwd())
13-
proofFile, err := os.Open("../../scripts/test_files/mina/mina_state.proof")
15+
proofBytes, err := os.ReadFile(ProofFilePath)
1416
if err != nil {
1517
t.Errorf("could not open mina state proof file")
1618
}
1719

18-
proofBuffer := make([]byte, mina.MAX_PROOF_SIZE)
19-
proofLen, err := proofFile.Read(proofBuffer)
20-
if err != nil {
21-
t.Errorf("could not read bytes from mina state proof file")
22-
}
23-
24-
pubInputFile, err := os.Open("../../scripts/test_files/mina/mina_state.pub")
25-
if err != nil {
26-
t.Errorf("could not open mina state hash file")
27-
}
28-
pubInputBuffer := make([]byte, mina.MAX_PUB_INPUT_SIZE)
29-
pubInputLen, err := pubInputFile.Read(pubInputBuffer)
20+
pubInputBytes, err := os.ReadFile(PubInputFilePath)
3021
if err != nil {
31-
t.Errorf("could not read bytes from mina state hash")
22+
t.Errorf("could not open mina state pub input file")
3223
}
3324

34-
if !mina.VerifyMinaState(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), uint(proofLen), ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), uint(pubInputLen)) {
25+
verified, err := mina.VerifyMinaState(proofBytes, pubInputBytes)
26+
if err != nil || !verified {
3527
t.Errorf("proof did not verify")
3628
}
3729
}
3830

3931
func TestEmptyMinaStateProofDoesNotVerify(t *testing.T) {
40-
fmt.Println(os.Getwd())
41-
42-
proofBuffer := make([]byte, mina.MAX_PROOF_SIZE)
43-
44-
pubInputFile, err := os.Open("../../scripts/test_files/mina/mina_state.pub")
32+
proofBytes, err := os.ReadFile(ProofFilePath)
4533
if err != nil {
46-
t.Errorf("could not open mina state hash file")
34+
t.Errorf("could not open mina state proof file")
4735
}
48-
pubInputBuffer := make([]byte, mina.MAX_PUB_INPUT_SIZE)
49-
pubInputLen, err := pubInputFile.Read(pubInputBuffer)
36+
emptyProofBuffer := make([]byte, len(proofBytes))
37+
38+
pubInputBytes, err := os.ReadFile(PubInputFilePath)
5039
if err != nil {
51-
t.Errorf("could not read bytes from mina state hash")
40+
t.Errorf("could not open mina state pub input file")
5241
}
5342

54-
if mina.VerifyMinaState(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), mina.MAX_PROOF_SIZE, ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), uint(pubInputLen)) {
55-
t.Errorf("empty proof should not verify but it did")
43+
verified, err := mina.VerifyMinaState(emptyProofBuffer, pubInputBytes)
44+
if err != nil {
45+
t.Errorf("verification failed with error")
46+
}
47+
if verified {
48+
t.Errorf("proof should not verify")
5649
}
5750
}
5851

5952
func TestMinaStateProofWithEmptyPubInputDoesNotVerify(t *testing.T) {
60-
fmt.Println(os.Getwd())
61-
proofFile, err := os.Open("../../scripts/test_files/mina/mina_state.proof")
53+
proofBytes, err := os.ReadFile(ProofFilePath)
6254
if err != nil {
6355
t.Errorf("could not open mina state proof file")
6456
}
6557

66-
proofBuffer := make([]byte, mina.MAX_PROOF_SIZE)
67-
proofLen, err := proofFile.Read(proofBuffer)
58+
pubInputBytes, err := os.ReadFile(PubInputFilePath)
6859
if err != nil {
69-
t.Errorf("could not read bytes from mina state proof file")
60+
t.Errorf("could not open mina state pub input file")
7061
}
62+
emptyPubInputBuffer := make([]byte, len(pubInputBytes))
7163

72-
pubInputBuffer := make([]byte, mina.MAX_PUB_INPUT_SIZE)
73-
74-
if mina.VerifyMinaState(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), uint(proofLen), ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), mina.MAX_PUB_INPUT_SIZE) {
75-
t.Errorf("proof with no public inputs should not verify but it did")
64+
verified, err := mina.VerifyMinaState(proofBytes, emptyPubInputBuffer)
65+
if err != nil {
66+
t.Errorf("verification failed with error")
67+
}
68+
if verified {
69+
t.Errorf("proof should not verify")
7670
}
7771
}

‎operator/sp1/sp1.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
package sp1
22

33
/*
4-
#cgo linux LDFLAGS: ${SRCDIR}/lib/libsp1_verifier_ffi.so -ldl -lrt -lm -lssl -lcrypto -Wl,--allow-multiple-definition
54
#cgo darwin LDFLAGS: -L./lib -lsp1_verifier_ffi
5+
#cgo linux LDFLAGS: ${SRCDIR}/lib/libsp1_verifier_ffi.so -ldl -lrt -lm -lssl -lcrypto -Wl,--allow-multiple-definition
66
77
#include "lib/sp1.h"
88
*/

0 commit comments

Comments
 (0)