Skip to content

Commit

Permalink
feat!: Add prevrandao field to EvmAdvance
Browse files Browse the repository at this point in the history 
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
  • Loading branch information
@mpolitzer
mpolitzer committed May 28, 2024
1 parent 14a2b86 commit 5a82a6e
Show file tree
Hide file tree
Showing 36 changed files with 559 additions and 434 deletions.
4 changes: 2 additions & 2 deletions rollup-http/rollup-http-server/build.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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")
Expand Down
3 changes: 2 additions & 1 deletion rollup-http/rollup-http-server/src/http_service.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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!(
Expand Down
233 changes: 117 additions & 116 deletions rollup-http/rollup-http-server/src/rollup/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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_*
Expand All @@ -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,
}
}
}
Expand Down Expand Up @@ -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()) };
Expand All @@ -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);
}
}

Expand All @@ -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()) };

Expand All @@ -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);
}
}

Expand All @@ -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!(
Expand All @@ -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 {}",
Expand All @@ -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!(
Expand All @@ -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!(
Expand All @@ -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 {}",
Expand Down Expand Up @@ -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!(
Expand All @@ -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 {}",
Expand Down
Loading

0 comments on commit 5a82a6e

Please sign in to comment.