Merge branch 'develop' into feat/split_coordinator_cron

common/libzkp/impl/src/utils.rs

@@ -11,6 +11,19 @@ use std::{
 pub(crate) static OUTPUT_DIR: Lazy<Option<String>> =
     Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
 
+/// # Safety
+#[no_mangle]
+pub extern "C" fn free_c_chars(ptr: *mut c_char) {
+    if ptr.is_null() {
+        log::warn!("Try to free an empty pointer!");
+        return;
+    }
+
+    unsafe {
+        let _ = CString::from_raw(ptr);
+    }
+}
+
 pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
     let cstr = unsafe { CStr::from_ptr(c) };
     cstr.to_str().unwrap()

common/libzkp/interface/libzkp.h

@@ -12,3 +12,4 @@ char* gen_chunk_proof(char* block_traces);
 char verify_chunk_proof(char* proof);
 
 char* block_traces_to_chunk_info(char* block_traces);
+void free_c_chars(char* ptr);

prover/core/prover.go

@@ -42,14 +42,14 @@ func NewProverCore(cfg *config.ProverCoreConfig) (*ProverCore, error) {
 
 	var vk string
 	var rawVK *C.char
-	defer C.free(unsafe.Pointer(rawVK))
 	if cfg.ProofType == message.ProofTypeBatch {
 		C.init_batch_prover(paramsPathStr, assetsPathStr)
 		rawVK = C.get_batch_vk()
 	} else if cfg.ProofType == message.ProofTypeChunk {
 		C.init_chunk_prover(paramsPathStr, assetsPathStr)
 		rawVK = C.get_chunk_vk()
 	}
+	defer C.free_c_chars(rawVK)
 
 	if rawVK != nil {
 		vk = C.GoString(rawVK)
@@ -162,7 +162,7 @@ func (p *ProverCore) checkChunkProofs(chunkProofsByt []byte) (bool, error) {
 
 	log.Info("Start to check chunk proofs ...")
 	cResult := C.check_chunk_proofs(chunkProofsStr)
-	defer C.free(unsafe.Pointer(cResult))
+	defer C.free_c_chars(cResult)
 	log.Info("Finish checking chunk proofs!")
 
 	var result CheckChunkProofsResponse
@@ -189,7 +189,7 @@ func (p *ProverCore) proveBatch(chunkInfosByt []byte, chunkProofsByt []byte) ([]
 
 	log.Info("Start to create batch proof ...")
 	bResult := C.gen_batch_proof(chunkInfosStr, chunkProofsStr)
-	defer C.free(unsafe.Pointer(bResult))
+	defer C.free_c_chars(bResult)
 	log.Info("Finish creating batch proof!")
 
 	var result ProofResult
@@ -211,7 +211,7 @@ func (p *ProverCore) proveChunk(tracesByt []byte) ([]byte, error) {
 
 	log.Info("Start to create chunk proof ...")
 	cProof := C.gen_chunk_proof(tracesStr)
-	defer C.free(unsafe.Pointer(cProof))
+	defer C.free_c_chars(cProof)
 	log.Info("Finish creating chunk proof!")
 
 	var result ProofResult
@@ -246,7 +246,7 @@ func (p *ProverCore) tracesToChunkInfo(tracesByt []byte) []byte {
 	defer C.free(unsafe.Pointer(tracesStr))
 
 	cChunkInfo := C.block_traces_to_chunk_info(tracesStr)
-	defer C.free(unsafe.Pointer(cChunkInfo))
+	defer C.free_c_chars(cChunkInfo)
 
 	chunkInfo := C.GoString(cChunkInfo)
 	return []byte(chunkInfo)