feat!: Add prevrandao field to EvmAdvance

feat!: stronger types

split header files into a separate folder
This allows users to build and link without a release installation by
preserving the header files relative path and `-I<cmt-root-dir>/include`
when building.

feat!: rename CMT_ADDRESS_LENGTH to CMT_ABI_ADDRESS_LENGTH
feat!: rename CMT_ABI_WORD_LENGTH to CMT_ABI_U256_LENGTH
feat!: port rust code to new API
refactor: rollup util with stronger types
feat!: update ioctl-echo-loop to stronger types API

rollup-http/rollup-http-server/build.rs

@@ -39,14 +39,14 @@ fn main() {
     };
 
     let header_path = if mock_build {
-        "../../sys-utils/libcmt/src/rollup.h".into()
+        "../../sys-utils/libcmt/include/libcmt/rollup.h".into()
     } else {
         pkg_config::get_variable("libcmt", "includedir").expect("Could not find include directory")
             + "/libcmt/rollup.h"
     };
 
     let include_path = if mock_build {
-        "-I../../sys-utils/libcmt/src".into()
+        "-I../../sys-utils/libcmt/include/libcmt".into()
     } else {
         "-I".to_string()
             + &pkg_config::get_variable("libcmt", "includedir")

rollup-http/rollup-http-server/src/http_service.rs

@@ -213,7 +213,8 @@ async fn finish(finish: Json<FinishRequest>, data: Data<Mutex<Context>>) -> Http
     let context = data.lock().await;
     let rollup_fd = context.rollup_fd.lock().await;
     // Write finish request, read indicator for next request
-    let new_rollup_request = match rollup::perform_rollup_finish_request(&*rollup_fd, accept).await {
+    let new_rollup_request = match rollup::perform_rollup_finish_request(&*rollup_fd, accept).await
+    {
         Ok(finish_request) => {
             // Received new request, process it
             log::info!(

rollup-http/rollup-http-server/src/rollup/mod.rs

@@ -114,6 +114,40 @@ impl From<&mut RollupFinish> for cmt_rollup_finish_t {
     }
 }
 
+impl cmt_abi_u256_t {
+    fn from_hex(hex: &str) -> Result<cmt_abi_u256_t, hex::FromHexError> {
+        let mut value: cmt_abi_u256_t = unsafe { std::mem::zeroed() };
+        let mut binary = hex::decode(hex)?;
+        let rc = unsafe {
+            cmt_abi_encode_uint_nn(
+                binary.len(),
+                binary.as_mut_ptr() as *const u8,
+                value.data.as_mut_ptr()
+            )
+        };
+        if rc != 0 {
+            return Err(hex::FromHexError::InvalidStringLength);
+        }
+        return Ok(value);
+    }
+}
+
+impl cmt_abi_address_t {
+    fn from_hex(hex: &str) -> Result<cmt_abi_address_t, hex::FromHexError> {
+        let value = cmt_abi_u256_t::from_hex(hex)?;
+        let mut address: cmt_abi_address_t = unsafe { std::mem::zeroed() };
+        unsafe {
+            let offset = (CMT_ABI_U256_LENGTH - CMT_ABI_ADDRESS_LENGTH) as usize;
+            std::ptr::copy(
+                value.data.as_ptr().wrapping_add(offset),
+                address.data.as_mut_ptr(),
+                CMT_ABI_ADDRESS_LENGTH as usize,
+            );
+        };
+        return Ok(address);
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Validate)]
 pub struct GIORequest {
     #[validate(range(min = 0x10))] // avoid overlapping with our HTIF_YIELD_MANUAL_REASON_*
@@ -127,23 +161,36 @@ pub struct GIOResponse {
     pub response: String,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
 pub struct AdvanceMetadata {
+    pub chain_id: u64,
+    #[validate(regex = "ETH_ADDR_REGEXP")]
+    pub app_contract: String,
+    #[validate(regex = "ETH_ADDR_REGEXP")]
     pub msg_sender: String,
-    pub input_index: u64,
     pub block_number: u64,
     pub block_timestamp: u64,
+    #[validate(regex = "ETH_U256_REGEXP")]
+    pub prev_randao: String,
+    pub input_index: u64,
 }
 
 impl From<cmt_rollup_advance_t> for AdvanceMetadata {
     fn from(other: cmt_rollup_advance_t) -> Self {
-        let mut address = "0x".to_string();
-        address.push_str(&hex::encode(&other.msg_sender));
+        let mut msg_sender = "0x".to_string();
+        msg_sender.push_str(&hex::encode(&other.msg_sender.data));
+        let mut app_contract = "0x".to_string();
+        app_contract.push_str(&hex::encode(&other.app_contract.data));
+        let mut prev_randao = "0x".to_string();
+        prev_randao.push_str(&hex::encode(&other.prev_randao.data));
         AdvanceMetadata {
-            input_index: other.index,
+            chain_id: other.chain_id,
+            app_contract: app_contract,
+            msg_sender: msg_sender,
             block_timestamp: other.block_timestamp,
             block_number: other.block_number,
-            msg_sender: address,
+            input_index: other.index,
+            prev_randao: prev_randao,
         }
     }
 }
@@ -241,13 +288,30 @@ pub fn rollup_read_advance_state_request(
 ) -> Result<AdvanceRequest, Box<dyn std::error::Error>> {
     let mut advance_request = Box::new(cmt_rollup_advance_t {
         chain_id: 0,
-        msg_sender: Default::default(),
-        app_contract: Default::default(),
+        msg_sender: {
+            cmt_abi_address_t {
+                data: Default::default(),
+            }
+        },
+        app_contract: {
+            cmt_abi_address_t {
+                data: Default::default(),
+            }
+        },
         block_number: 0,
         block_timestamp: 0,
+        prev_randao: {
+            cmt_abi_u256_t {
+                data: Default::default(),
+            }
+        },
         index: 0,
-        payload_length: 0,
-        payload: std::ptr::null::<::std::os::raw::c_uchar>() as *mut c_void,
+        payload: {
+            cmt_abi_bytes_t {
+                length: 0,
+                data: std::ptr::null::<::std::os::raw::c_uchar>() as *mut c_void,
+            }
+        },
     });
 
     let res = unsafe { cmt_rollup_read_advance_state(fd.0, advance_request.as_mut()) };
@@ -259,19 +323,19 @@ pub fn rollup_read_advance_state_request(
         ))));
     }
 
-    if advance_request.payload_length == 0 {
+    if advance_request.payload.length == 0 {
         log::info!("read zero size payload from advance state request");
     }
 
-    let mut payload: Vec<u8> = Vec::with_capacity(advance_request.payload_length as usize);
-    if advance_request.payload_length > 0 {
+    let mut payload: Vec<u8> = Vec::with_capacity(advance_request.payload.length as usize);
+    if advance_request.payload.length > 0 {
         unsafe {
             std::ptr::copy(
-                advance_request.payload,
+                advance_request.payload.data,
                 payload.as_mut_ptr() as *mut c_void,
-                advance_request.payload_length as usize,
+                advance_request.payload.length as usize,
             );
-            payload.set_len(advance_request.payload_length as usize);
+            payload.set_len(advance_request.payload.length as usize);
         }
     }
 
@@ -287,9 +351,10 @@ pub fn rollup_read_inspect_state_request(
     fd: &RollupFd,
 ) -> Result<InspectRequest, Box<dyn std::error::Error>> {
     let mut inspect_request = Box::new(cmt_rollup_inspect_t {
-        payload_length: 0,
-        payload: std::ptr::null::<::std::os::raw::c_uchar>() as *mut c_void,
-    });
+        payload: cmt_abi_bytes_t {
+            length: 0,
+            data: std::ptr::null::<::std::os::raw::c_uchar>() as *mut c_void,
+        }});
 
     let res = unsafe { cmt_rollup_read_inspect_state(fd.0, inspect_request.as_mut()) };
 
@@ -300,23 +365,23 @@ pub fn rollup_read_inspect_state_request(
         ))));
     }
 
-    if inspect_request.payload_length == 0 {
+    if inspect_request.payload.length == 0 {
         log::info!("read zero size payload from inspect state request");
     }
 
     println!(
         "inspect_request.payload_length: {}",
-        inspect_request.payload_length
+        inspect_request.payload.length
     );
-    let mut payload: Vec<u8> = Vec::with_capacity(inspect_request.payload_length as usize);
-    if inspect_request.payload_length > 0 {
+    let mut payload: Vec<u8> = Vec::with_capacity(inspect_request.payload.length as usize);
+    if inspect_request.payload.length > 0 {
         unsafe {
             std::ptr::copy(
-                inspect_request.payload,
+                inspect_request.payload.data,
                 payload.as_mut_ptr() as *mut c_void,
-                inspect_request.payload_length as usize,
+                inspect_request.payload.length as usize,
             );
-            payload.set_len(inspect_request.payload_length as usize);
+            payload.set_len(inspect_request.payload.length as usize);
         }
     }
 
@@ -333,7 +398,7 @@ pub fn rollup_write_notice(
 ) -> Result<u64, Box<dyn std::error::Error>> {
     print_notice(notice);
 
-    let binary_payload = match hex::decode(&notice.payload[2..]) {
+    let mut binary_payload = match hex::decode(&notice.payload[2..]) {
         Ok(payload) => payload,
         Err(_err) => {
             return Err(Box::new(RollupError::new(&format!(
@@ -342,25 +407,14 @@ pub fn rollup_write_notice(
         }
     };
 
-    let mut buffer: Vec<u8> = Vec::with_capacity(binary_payload.len());
-    let length = binary_payload.len() as u64;
     let mut notice_index: std::os::raw::c_ulong = 0;
-
-    let res = unsafe {
-        std::ptr::copy(
-            binary_payload.as_ptr(),
-            buffer.as_mut_ptr(),
-            binary_payload.len(),
-        );
-
-        cmt_rollup_emit_notice(
-            fd.0,
-            length as u32,
-            buffer.as_mut_ptr() as *mut c_void,
-            &mut notice_index,
-        )
+    let payload = cmt_abi_bytes_t {
+        data: binary_payload.as_mut_ptr() as *mut c_void,
+        length: binary_payload.len(),
     };
 
+    let res = unsafe { cmt_rollup_emit_notice(fd.0, &payload, &mut notice_index) };
+
     if res != 0 {
         return Err(Box::new(RollupError::new(&format!(
             "IOCTL_ROLLUP_WRITE_NOTICE returned error {}",
@@ -379,64 +433,24 @@ pub fn rollup_write_voucher(
 ) -> Result<u64, Box<dyn std::error::Error>> {
     print_voucher(voucher);
 
-    let binary_payload = match hex::decode(&voucher.payload[2..]) {
+    let mut binary_payload = match hex::decode(&voucher.payload[2..]) {
         Ok(payload) => payload,
         Err(_err) => {
             return Err(Box::new(RollupError::new(&format!(
                 "Error decoding voucher payload, it must be in Ethereum hex binary format"
             ))));
         }
     };
-    let mut payload_buffer: Vec<u8> = Vec::with_capacity(binary_payload.len());
-    let payload_data = payload_buffer.as_mut_ptr();
-    let payload_length = binary_payload.len();
-
-    let binary_value = match hex::decode(&voucher.value[2..]) {
-        Ok(data) => data,
-        Err(_err) => {
-            return Err(Box::new(RollupError::new(&format!(
-                "Error decoding voucher value, it must be in Ethereum hex binary format"
-            ))));
-        }
-    };
-    let mut value_buffer: Vec<u8> = Vec::with_capacity(binary_value.len());
-    let value_data = value_buffer.as_mut_ptr();
-    let value_length = binary_value.len();
-
-    let address_c = match hex::decode(&voucher.destination[2..]) {
-        Ok(res) => res,
-        Err(e) => {
-            return Err(Box::new(RollupError::new(&format!(
-                "address not valid: {}",
-                e
-            ))));
-        }
+    let value = cmt_abi_u256_t::from_hex(&voucher.value[2..])?;
+    let address = cmt_abi_address_t::from_hex(&voucher.destination[2..])?;
+    let payload = cmt_abi_bytes_t {
+        data: binary_payload.as_mut_ptr() as *mut c_void,
+        length: binary_payload.len(),
     };
 
     let mut voucher_index: std::os::raw::c_ulong = 0;
-    let res = unsafe {
-        std::ptr::copy(
-            binary_payload.as_ptr(),
-            payload_buffer.as_mut_ptr(),
-            binary_payload.len(),
-        );
-        std::ptr::copy(
-            binary_value.as_ptr(),
-            value_buffer.as_mut_ptr(),
-            binary_value.len(),
-        );
-
-        cmt_rollup_emit_voucher(
-            fd.0,
-            address_c.len() as u32,
-            address_c.as_ptr() as *const c_void,
-            value_length as u32,
-            value_data as *mut c_void,
-            payload_length as u32,
-            payload_data as *mut c_void,
-            &mut voucher_index,
-        )
-    };
+    let res =
+        unsafe { cmt_rollup_emit_voucher(fd.0, &address, &value, &payload, &mut voucher_index) };
 
     if res != 0 {
         return Err(Box::new(RollupError::new(&format!(
@@ -456,7 +470,7 @@ pub fn rollup_write_report(
 ) -> Result<(), Box<dyn std::error::Error>> {
     print_report(report);
 
-    let binary_payload = match hex::decode(&report.payload[2..]) {
+    let mut binary_payload = match hex::decode(&report.payload[2..]) {
         Ok(payload) => payload,
         Err(_err) => {
             return Err(Box::new(RollupError::new(&format!(
@@ -465,20 +479,13 @@ pub fn rollup_write_report(
         }
     };
 
-    let mut buffer: Vec<u8> = Vec::with_capacity(binary_payload.len());
-
-    let data = buffer.as_mut_ptr() as *mut c_void;
-    let length = binary_payload.len();
-
-    let res = unsafe {
-        std::ptr::copy(
-            binary_payload.as_ptr(),
-            buffer.as_mut_ptr(),
-            binary_payload.len(),
-        );
-        cmt_rollup_emit_report(fd.0, length as u32, data)
+    let payload = cmt_abi_bytes_t {
+        data: binary_payload.as_mut_ptr() as *mut c_void,
+        length: binary_payload.len(),
     };
 
+    let res = unsafe { cmt_rollup_emit_report(fd.0, &payload) };
+
     if res != 0 {
         return Err(Box::new(RollupError::new(&format!(
             "IOCTL_ROLLUP_WRITE_REPORT returned error {}",
@@ -562,7 +569,7 @@ pub fn rollup_throw_exception(
 ) -> Result<(), Box<dyn std::error::Error>> {
     print_exception(exception);
 
-    let binary_payload = match hex::decode(&exception.payload[2..]) {
+    let mut binary_payload = match hex::decode(&exception.payload[2..]) {
         Ok(payload) => payload,
         Err(_err) => {
             return Err(Box::new(RollupError::new(&format!(
@@ -571,18 +578,12 @@ pub fn rollup_throw_exception(
         }
     };
 
-    let mut buffer: Vec<u8> = Vec::with_capacity(binary_payload.len());
-    let length = binary_payload.len();
-    let data = buffer.as_mut_ptr() as *mut c_void;
-
-    let res = unsafe {
-        std::ptr::copy(
-            binary_payload.as_ptr(),
-            buffer.as_mut_ptr(),
-            binary_payload.len(),
-        );
-        cmt_rollup_emit_exception(fd.0, length as u32, data)
+    let payload = cmt_abi_bytes_t {
+        data: binary_payload.as_mut_ptr() as *mut c_void,
+        length: binary_payload.len(),
     };
+
+    let res = unsafe { cmt_rollup_emit_exception(fd.0, &payload) };
     if res != 0 {
         return Err(Box::new(RollupError::new(&format!(
             "IOCTL_ROLLUP_THROW_EXCEPTION returned error {}",