Skip to content

Commit

Permalink
[rust] update EVM precompiles API to return values
Browse files Browse the repository at this point in the history
  • Loading branch information
@Vindaar
Vindaar committed Jul 2, 2024
1 parent 3799d9a commit 9884158
Showing 1 changed file with 113 additions and 129 deletions.
242 changes: 113 additions & 129 deletions constantine-rust/constantine-ethereum-evm-precompiles/src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,38 +18,44 @@ use ::core::mem::MaybeUninit;
#[inline]
pub fn evm_sha256(message: &[u8]) -> Result<[u8; 32], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 32]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_sha256(
result.as_mut_ptr() as *mut byte,
32,
message.as_ptr() as *const byte,
message.len() as isize,
);
unsafe {
let status = ctt_eth_evm_sha256(
result.as_mut_ptr() as *mut byte,
32,
message.as_ptr() as *const byte,
message.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status)
_ => Err(status),
}
}
}


/// TODO: We want an extra proc in C to return the size of the return buffer needed.
/// so we can preallocate before calling evm_modexp itself.
#[inline]
pub fn evm_modexp(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_modexp(inputs: &[u8]) -> Result<Vec<u8>, ctt_evm_status> {
// Call Nim function to determine correct size to allocate for `result`
unsafe {
let status = ctt_eth_evm_modexp(
let mut size = 0u64;
let status = ctt_modexp_result_size(
&mut size,
inputs.as_ptr() as *const byte,
inputs.len() as usize,
);
if status != ctt_evm_status::cttEVM_Success {
return Err(status);
}

let mut result = vec![0u8; size as usize];
let status = ctt_eth_evm_modexp(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
result.len() as usize,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result),
_ => Err(status),
}
}
}
Expand All @@ -59,31 +65,31 @@ pub fn evm_bn254_g1add(inputs: &[u8]) -> Result<[u8; 64], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 64]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bn254_g1add(
result.as_mut_ptr() as *mut byte,
64,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
result.as_mut_ptr() as *mut byte,
64,
inputs.as_ptr() as *const byte,
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status)
}
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bn254_g1mul(inputs: &[u8]) -> Result<[u8; 64], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 64]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bn254_g1mul(
let status = ctt_eth_evm_bn254_g1mul(
result.as_mut_ptr() as *mut byte,
64,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status)
_ => Err(status),
}
}
}
Expand All @@ -92,189 +98,167 @@ pub fn evm_bn254_g1mul(inputs: &[u8]) -> Result<[u8; 64], ctt_evm_status> {
pub fn evm_bn254_ec_pairing_check(inputs: &[u8]) -> Result<[u8; 32], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 32]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bn254_ecpairingcheck(
let status = ctt_eth_evm_bn254_ecpairingcheck(
result.as_mut_ptr() as *mut byte,
32,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status)
_ => Err(status),
}
}
}

//
// TODO: takeover from here
//

#[inline]
pub fn evm_bls12381_g1add(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g1add(inputs: &[u8]) -> Result<[u8; 128], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 128]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g1add(
let status = ctt_eth_evm_bls12381_g1add(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
128,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_g1mul(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g1mul(inputs: &[u8]) -> Result<[u8; 128], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 128]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g1mul(
let status = ctt_eth_evm_bls12381_g1mul(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
128,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_g1msm(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g1msm(inputs: &[u8]) -> Result<[u8; 128], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 128]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g1msm(
let status = ctt_eth_evm_bls12381_g1msm(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
128,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_g2add(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g2add(inputs: &[u8]) -> Result<[u8; 256], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 256]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g2add(
let status = ctt_eth_evm_bls12381_g2add(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
256,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_g2mul(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g2mul(inputs: &[u8]) -> Result<[u8; 256], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 256]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g2mul(
let status = ctt_eth_evm_bls12381_g2mul(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
256,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_g2msm(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_g2msm(inputs: &[u8]) -> Result<[u8; 256], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 256]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_g2msm(
let status = ctt_eth_evm_bls12381_g2msm(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
256,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_pairing_check(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_pairing_check(inputs: &[u8]) -> Result<[u8; 32], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 32]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_pairingcheck(
let status = ctt_eth_evm_bls12381_pairingcheck(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
32,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

#[inline]
pub fn evm_bls12381_map_fp_to_g1(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_map_fp_to_g1(inputs: &[u8]) -> Result<[u8; 128], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 128]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_map_fp_to_g1(
let status = ctt_eth_evm_bls12381_map_fp_to_g1(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
128,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

pub fn evm_bls12381_map_fp2_to_g2(
result: &mut [u8],
inputs: &[u8]
) -> Result<(), ctt_evm_status> {
pub fn evm_bls12381_map_fp2_to_g2(inputs: &[u8]) -> Result<[u8; 256], ctt_evm_status> {
let mut result: MaybeUninit<[u8; 256]> = MaybeUninit::uninit();
unsafe {
let status = ctt_eth_evm_bls12381_map_fp2_to_g2(
let status = ctt_eth_evm_bls12381_map_fp2_to_g2(
result.as_mut_ptr() as *mut byte,
result.len() as isize,
128,
inputs.as_ptr() as *const byte,
inputs.len() as isize,
);
inputs.len() as usize,
);
match status {
ctt_evm_status::cttEVM_Success => Ok(()),
_ => Err(status)
ctt_evm_status::cttEVM_Success => Ok(result.assume_init()),
_ => Err(status),
}
}
}

0 comments on commit 9884158

Please sign in to comment.