simplicity-sys: rename all the C compatibility types

apoelstra · apoelstra · commit ad7a60b998e7 · 2025-07-10T20:50:46.000Z
diff --git a/simplicity-sys/src/c_jets/c_env.rs b/simplicity-sys/src/c_jets/c_env.rs
@@ -28,7 +28,7 @@ pub struct RawOutputData {
 
 #[derive(Debug)]
 #[repr(C)]
-pub struct CRawBuffer {
+pub struct CElementsRawBuffer {
     pub ptr: *const c_uchar,
     pub len: u32,
 }
@@ -56,44 +56,44 @@ pub struct RawTransactionData {
 
 #[derive(Debug)]
 #[repr(C)]
-pub struct CRawOutput {
+pub struct CElementsRawOutput {
     asset: *const c_uchar,
     value: *const c_uchar,
     nonce: *const c_uchar,
-    script_pubkey: CRawBuffer,
-    surjection_proof: CRawBuffer,
-    range_proof: CRawBuffer,
+    script_pubkey: CElementsRawBuffer,
+    surjection_proof: CElementsRawBuffer,
+    range_proof: CElementsRawBuffer,
 }
 
 #[derive(Debug)]
 #[repr(C)]
-pub struct CRawInput {
-    annex: *const CRawBuffer,
+pub struct CElementsRawInput {
+    annex: *const CElementsRawBuffer,
     prev_txid: *const c_uchar,
     pegin: *const c_uchar,
     // issuance
     blinding_nonce: *const c_uchar,
     asset_entropy: *const c_uchar,
     amount: *const c_uchar,
     inflation_keys: *const c_uchar,
-    amount_range_proof: CRawBuffer,
-    inflation_keys_range_proof: CRawBuffer,
+    amount_range_proof: CElementsRawBuffer,
+    inflation_keys_range_proof: CElementsRawBuffer,
     // spent txo
     asset: *const c_uchar,
     value: *const c_uchar,
-    script_pubkey: CRawBuffer,
+    script_pubkey: CElementsRawBuffer,
     // inputs
-    script_sig: CRawBuffer,
+    script_sig: CElementsRawBuffer,
     prev_txout_index: u32,
     sequence: u32,
 }
 
 #[derive(Debug)]
 #[repr(C)]
-pub struct CRawTransaction {
+pub struct CElementsRawTransaction {
     txid: *const c_uchar,
-    inputs: *const CRawInput,
-    outputs: *const CRawOutput,
+    inputs: *const CElementsRawInput,
+    outputs: *const CElementsRawOutput,
     version: u32,
     locktime: u32,
     n_inputs: u32,
@@ -102,7 +102,7 @@ pub struct CRawTransaction {
 
 #[derive(Debug)]
 #[repr(C)]
-pub struct CRawTapEnv {
+pub struct CElementsRawTapEnv {
     control_block: *const c_uchar,
     script_cmr: *const c_uchar,
     branch_len: u8,
@@ -140,47 +140,47 @@ extern "C" {
     pub static c_alignof_rawElementsTapEnv: c_size_t;
     pub static c_alignof_txEnv: c_size_t;
 
-    pub fn c_set_rawElementsBuffer(res: *mut CRawBuffer, buf: *const c_uchar, len: c_uint);
+    pub fn c_set_rawElementsBuffer(res: *mut CElementsRawBuffer, buf: *const c_uchar, len: c_uint);
     pub fn c_set_rawElementsOutput(
-        res: *mut CRawOutput,
+        res: *mut CElementsRawOutput,
         asset: *const c_uchar,
         value: *const c_uchar,
         nonce: *const c_uchar,
-        scriptPubKey: *const CRawBuffer,
-        surjectionProof: *const CRawBuffer,
-        rangeProof: *const CRawBuffer,
+        scriptPubKey: *const CElementsRawBuffer,
+        surjectionProof: *const CElementsRawBuffer,
+        rangeProof: *const CElementsRawBuffer,
     );
     pub fn c_set_rawElementsInput(
-        result: *mut CRawInput,
-        annex: *const CRawBuffer,
+        result: *mut CElementsRawInput,
+        annex: *const CElementsRawBuffer,
         pegin: *const c_uchar,
-        scriptSig: *const CRawBuffer,
+        scriptSig: *const CElementsRawBuffer,
         prevTxid: *const c_uchar,
         prevIx: c_uint,
         asset: *const c_uchar,
         value: *const c_uchar,
-        scriptPubKey: *const CRawBuffer,
+        scriptPubKey: *const CElementsRawBuffer,
         sequence: c_uint,
         blindingNonce: *const c_uchar,
         assetEntropy: *const c_uchar,
         amount: *const c_uchar,
         inflationKeys: *const c_uchar,
-        amountRangePrf: *const CRawBuffer,
-        inflationKeysRangePrf: *const CRawBuffer,
+        amountRangePrf: *const CElementsRawBuffer,
+        inflationKeysRangePrf: *const CElementsRawBuffer,
     );
 
     pub fn c_set_rawElementsTransaction(
-        result: *mut CRawTransaction,
+        result: *mut CElementsRawTransaction,
         version: c_uint,
         txid: *const c_uchar,
-        input: *const CRawInput,
+        input: *const CElementsRawInput,
         numInputs: c_uint,
-        output: *const CRawOutput,
+        output: *const CElementsRawOutput,
         numOutputs: c_uint,
         lockTime: c_uint,
     );
     pub fn c_set_rawElementsTapEnv(
-        result: *mut CRawTapEnv,
+        result: *mut CElementsRawTapEnv,
         controlBlock: *const c_uchar,
         pathLen: c_uchar,
         scriptCMR: *const c_uchar,
@@ -192,9 +192,9 @@ extern "C" {
         genesisHash: *const c_uchar,
         ix: c_uint,
     );
-    pub fn simplicity_elements_mallocTapEnv(rawEnv: *const CRawTapEnv) -> *mut CTapEnv;
+    pub fn simplicity_elements_mallocTapEnv(rawEnv: *const CElementsRawTapEnv) -> *mut CTapEnv;
     pub fn simplicity_elements_mallocTransaction(
-        rawTx: *const CRawTransaction,
+        rawTx: *const CElementsRawTransaction,
     ) -> *mut CTransaction;
     pub fn c_free_transaction(tx: *mut CTransaction);
     pub fn c_free_tapEnv(env: *mut CTapEnv);
@@ -216,10 +216,10 @@ impl Drop for CElementsTxEnv {
     }
 }
 
-impl CRawBuffer {
+impl CElementsRawBuffer {
     pub fn new(buf: &[c_uchar]) -> Self {
         unsafe {
-            let mut raw_buffer = std::mem::MaybeUninit::<CRawBuffer>::uninit();
+            let mut raw_buffer = std::mem::MaybeUninit::<Self>::uninit();
             c_set_rawElementsBuffer(raw_buffer.as_mut_ptr(), buf.as_ptr(), buf.len() as c_uint);
             raw_buffer.assume_init()
         }
@@ -236,14 +236,14 @@ mod tests {
     fn test_sizes() {
         unsafe {
             assert_eq!(size_of::<CFrameItem>(), c_sizeof_frameItem);
-            assert_eq!(size_of::<CRawBuffer>(), c_sizeof_rawElementsBuffer);
-            assert_eq!(size_of::<CRawInput>(), c_sizeof_rawElementsInput);
-            assert_eq!(size_of::<CRawOutput>(), c_sizeof_rawElementsOutput);
+            assert_eq!(size_of::<CElementsRawBuffer>(), c_sizeof_rawElementsBuffer);
+            assert_eq!(size_of::<CElementsRawInput>(), c_sizeof_rawElementsInput);
+            assert_eq!(size_of::<CElementsRawOutput>(), c_sizeof_rawElementsOutput);
             assert_eq!(
-                size_of::<CRawTransaction>(),
+                size_of::<CElementsRawTransaction>(),
                 c_sizeof_rawElementsTransaction
             );
-            assert_eq!(size_of::<CRawTapEnv>(), c_sizeof_rawElementsTapEnv);
+            assert_eq!(size_of::<CElementsRawTapEnv>(), c_sizeof_rawElementsTapEnv);
             assert_eq!(size_of::<CElementsTxEnv>(), c_sizeof_txEnv);
         }
     }
@@ -252,14 +252,23 @@ mod tests {
     fn test_aligns() {
         unsafe {
             assert_eq!(align_of::<CFrameItem>(), c_alignof_frameItem);
-            assert_eq!(align_of::<CRawBuffer>(), c_alignof_rawElementsBuffer);
-            assert_eq!(align_of::<CRawInput>(), c_alignof_rawElementsInput);
-            assert_eq!(align_of::<CRawOutput>(), c_alignof_rawElementsOutput);
             assert_eq!(
-                align_of::<CRawTransaction>(),
+                align_of::<CElementsRawBuffer>(),
+                c_alignof_rawElementsBuffer
+            );
+            assert_eq!(align_of::<CElementsRawInput>(), c_alignof_rawElementsInput);
+            assert_eq!(
+                align_of::<CElementsRawOutput>(),
+                c_alignof_rawElementsOutput
+            );
+            assert_eq!(
+                align_of::<CElementsRawTransaction>(),
                 c_alignof_rawElementsTransaction
             );
-            assert_eq!(align_of::<CRawTapEnv>(), c_alignof_rawElementsTapEnv);
+            assert_eq!(
+                align_of::<CElementsRawTapEnv>(),
+                c_alignof_rawElementsTapEnv
+            );
             assert_eq!(align_of::<CElementsTxEnv>(), c_alignof_txEnv);
         }
     }
diff --git a/simplicity-sys/src/c_jets/mod.rs b/simplicity-sys/src/c_jets/mod.rs
@@ -19,7 +19,10 @@ pub use frame_ffi::CFrameItem;
 // The bindings use elements_ffi instead of jets_ffi.
 pub use jets_ffi as elements_ffi;
 
-use crate::c_jets::c_env::{CRawBuffer, CRawInput, CRawOutput, CRawTapEnv, CRawTransaction};
+use crate::c_jets::c_env::{
+    CElementsRawBuffer, CElementsRawInput, CElementsRawOutput, CElementsRawTapEnv,
+    CElementsRawTransaction,
+};
 
 #[cfg(feature = "test-utils")]
 pub mod exec_ffi;
@@ -38,23 +41,25 @@ pub fn sanity_checks() -> bool {
         }
 
         if std::mem::size_of::<CFrameItem>() != frame_ffi::c_sizeof_frameItem
-            || std::mem::size_of::<CRawBuffer>() != c_env::c_sizeof_rawElementsBuffer
-            || std::mem::size_of::<CRawInput>() != c_env::c_sizeof_rawElementsInput
-            || std::mem::size_of::<CRawOutput>() != c_env::c_sizeof_rawElementsOutput
-            || std::mem::size_of::<CRawTransaction>() != c_env::c_sizeof_rawElementsTransaction
+            || std::mem::size_of::<CElementsRawBuffer>() != c_env::c_sizeof_rawElementsBuffer
+            || std::mem::size_of::<CElementsRawInput>() != c_env::c_sizeof_rawElementsInput
+            || std::mem::size_of::<CElementsRawOutput>() != c_env::c_sizeof_rawElementsOutput
+            || std::mem::size_of::<CElementsRawTransaction>()
+                != c_env::c_sizeof_rawElementsTransaction
             || std::mem::size_of::<CElementsTxEnv>() != c_env::c_sizeof_txEnv
-            || std::mem::size_of::<CRawTapEnv>() != c_env::c_sizeof_rawElementsTapEnv
+            || std::mem::size_of::<CElementsRawTapEnv>() != c_env::c_sizeof_rawElementsTapEnv
         {
             return false;
         }
 
         if std::mem::align_of::<CFrameItem>() != frame_ffi::c_alignof_frameItem
-            || std::mem::align_of::<CRawBuffer>() != c_env::c_alignof_rawElementsBuffer
-            || std::mem::align_of::<CRawInput>() != c_env::c_alignof_rawElementsInput
-            || std::mem::align_of::<CRawOutput>() != c_env::c_alignof_rawElementsOutput
-            || std::mem::align_of::<CRawTransaction>() != c_env::c_alignof_rawElementsTransaction
+            || std::mem::align_of::<CElementsRawBuffer>() != c_env::c_alignof_rawElementsBuffer
+            || std::mem::align_of::<CElementsRawInput>() != c_env::c_alignof_rawElementsInput
+            || std::mem::align_of::<CElementsRawOutput>() != c_env::c_alignof_rawElementsOutput
+            || std::mem::align_of::<CElementsRawTransaction>()
+                != c_env::c_alignof_rawElementsTransaction
             || std::mem::align_of::<CElementsTxEnv>() != c_env::c_alignof_txEnv
-            || std::mem::align_of::<CRawTapEnv>() != c_env::c_alignof_rawElementsTapEnv
+            || std::mem::align_of::<CElementsRawTapEnv>() != c_env::c_alignof_rawElementsTapEnv
         {
             return false;
         }
diff --git a/src/jet/elements/c_env.rs b/src/jet/elements/c_env.rs
@@ -15,18 +15,18 @@ use elements::{
 use simplicity_sys::c_jets::c_env::{
     c_set_rawElementsInput, c_set_rawElementsOutput, c_set_rawElementsTapEnv,
     c_set_rawElementsTransaction, c_set_txEnv, simplicity_elements_mallocTapEnv,
-    simplicity_elements_mallocTransaction, CElementsTxEnv, CRawBuffer, CRawInput, CRawOutput,
-    CRawTapEnv, CRawTransaction, CTapEnv, CTransaction, RawInputData, RawOutputData,
-    RawTransactionData,
+    simplicity_elements_mallocTransaction, CElementsRawBuffer, CElementsRawInput,
+    CElementsRawOutput, CElementsRawTapEnv, CElementsRawTransaction, CElementsTxEnv, CTapEnv,
+    CTransaction, RawInputData, RawOutputData, RawTransactionData,
 };
 
 use crate::merkle::cmr::Cmr;
 
 use super::ElementsUtxo;
 
-fn new_raw_output(out: &elements::TxOut, out_data: &RawOutputData) -> CRawOutput {
+fn new_raw_output(out: &elements::TxOut, out_data: &RawOutputData) -> CElementsRawOutput {
     unsafe {
-        let mut raw_output = std::mem::MaybeUninit::<CRawOutput>::uninit();
+        let mut raw_output = std::mem::MaybeUninit::<CElementsRawOutput>::uninit();
         c_set_rawElementsOutput(
             raw_output.as_mut_ptr(),
             asset_ptr(out.asset, &out_data.asset),
@@ -44,9 +44,9 @@ fn new_raw_input(
     inp: &elements::TxIn,
     in_utxo: &ElementsUtxo,
     inp_data: &RawInputData,
-) -> CRawInput {
+) -> CElementsRawInput {
     unsafe {
-        let mut raw_input = std::mem::MaybeUninit::<CRawInput>::uninit();
+        let mut raw_input = std::mem::MaybeUninit::<CElementsRawInput>::uninit();
 
         let (issue_nonce_ptr, issue_entropy_ptr, issue_amt_ptr, issue_infl_key_ptr) =
             if inp.has_issuance() {
@@ -141,7 +141,7 @@ pub(super) fn new_tx(tx: &elements::Transaction, in_utxos: &[ElementsUtxo]) -> *
         raw_outputs.push(new_raw_output(out, out_data));
     }
     unsafe {
-        let mut raw_tx = std::mem::MaybeUninit::<CRawTransaction>::uninit();
+        let mut raw_tx = std::mem::MaybeUninit::<CElementsRawTransaction>::uninit();
         c_set_rawElementsTransaction(
             raw_tx.as_mut_ptr(),
             tx.version as c_uint,
@@ -159,7 +159,7 @@ pub(super) fn new_tx(tx: &elements::Transaction, in_utxos: &[ElementsUtxo]) -> *
 
 pub(super) fn new_tap_env(control_block: &ControlBlock, script_cmr: Cmr) -> *mut CTapEnv {
     unsafe {
-        let mut raw_tap_env = std::mem::MaybeUninit::<CRawTapEnv>::uninit();
+        let mut raw_tap_env = std::mem::MaybeUninit::<CElementsRawTapEnv>::uninit();
         let cb_ser = control_block.serialize();
         c_set_rawElementsTapEnv(
             raw_tap_env.as_mut_ptr(),
@@ -223,20 +223,20 @@ fn opt_ptr<T>(t: Option<&T>) -> *const T {
     }
 }
 
-fn script_ptr(script: &elements::Script) -> CRawBuffer {
-    CRawBuffer::new(script.as_bytes())
+fn script_ptr(script: &elements::Script) -> CElementsRawBuffer {
+    CElementsRawBuffer::new(script.as_bytes())
 }
 
-fn annex_ptr(annex: &Option<Vec<c_uchar>>) -> Option<CRawBuffer> {
-    annex.as_ref().map(|annex| CRawBuffer::new(annex))
+fn annex_ptr(annex: &Option<Vec<c_uchar>>) -> Option<CElementsRawBuffer> {
+    annex.as_ref().map(|annex| CElementsRawBuffer::new(annex))
 }
 
-fn surjection_proof_ptr(surjection_proof: &[c_uchar]) -> CRawBuffer {
-    CRawBuffer::new(surjection_proof)
+fn surjection_proof_ptr(surjection_proof: &[c_uchar]) -> CElementsRawBuffer {
+    CElementsRawBuffer::new(surjection_proof)
 }
 
-fn range_proof_ptr(rangeproof: &[c_uchar]) -> CRawBuffer {
-    CRawBuffer::new(rangeproof)
+fn range_proof_ptr(rangeproof: &[c_uchar]) -> CElementsRawBuffer {
+    CElementsRawBuffer::new(rangeproof)
 }
 
 fn serialize_rangeproof(rangeproof: &Option<Box<RangeProof>>) -> Vec<c_uchar> {
