feat(svm): removed original solana builtin implementations, corresponding tests and test structures (#150)

* feat(svm): remove original solana builtins and corresponding tests and test structures

* feat(svm): remove 'from' transformation from svm tests

* feat(svm): renamings for consistency

Author: bfdays

contracts/Cargo.toml

@@ -19,9 +19,7 @@ fluentbase-sdk = { path = "../crates/sdk", default-features = false }
 precompile = { path = "../revm/crates/precompile", package = "revm-precompile", default-features = false }
 fluentbase-erc20 = { path = "../crates/erc20", default-features = false }
 fluentbase-evm = { path = "../crates/evm", default-features = false }
-fluentbase-svm = { path = "../crates/svm", default-features = false, features = [
-    #    "enable-solana-original-builtins",
-] }
+fluentbase-svm = { path = "../crates/svm", default-features = false }
 hex-literal = { version = "0.4.1", default-features = false }
 alloy-sol-types = { version = "1.2.0", default-features = false }
 serde = { version = "1.0.203", default-features = false, features = ["derive", "rc"] }

contracts/examples/svm/assets/solana_program_state_usage.so

@@ -79,16 +79,6 @@ macro_rules! impl_hash {
 pub fn sol_keccak256_native(data: &[&[u8]]) -> (ReturnValue, [u8; 32]) {
     impl_hash!(data, sol_keccak256)
 }
-extern "C" {
-    fn sol_sha256_original(
-        values_addr: *const u8,
-        values_len: u64,
-        result_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn sol_sha256_original_native(data: &[&[u8]]) -> (ReturnValue, [u8; 32]) {
-    impl_hash!(data, sol_sha256_original)
-}
 extern "C" {
     fn sol_sha256(values_addr: *const u8, values_len: u64, result_addr: *mut u8) -> ReturnValue;
 }
@@ -127,30 +117,6 @@ pub fn sol_poseidon_native(
     };
     (ret, result)
 }
-extern "C" {
-    fn sol_secp256k1_recover_original(
-        hash_addr: *const u8,
-        recovery_id_val: u64,
-        signature_addr: *const u8,
-        result_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn secp256k1_recover_original_native(
-    hash: &[u8; 32],
-    recovery_id_val: u64,
-    signature: &[u8; 64],
-) -> (ReturnValue, [u8; 64]) {
-    let mut result = [0u8; 64];
-    let ret = unsafe {
-        sol_secp256k1_recover_original(
-            hash.as_ptr(),
-            recovery_id_val,
-            signature.as_ptr(),
-            result.as_mut_ptr(),
-        )
-    };
-    (ret, result)
-}
 extern "C" {
     fn sol_secp256k1_recover(
         hash_addr: *const u8,
@@ -175,37 +141,6 @@ pub fn secp256k1_recover_native(
     };
     (ret, result)
 }
-extern "C" {
-    fn sol_big_mod_exp_original(params_addr: *const u8, return_value_addr: *mut u8) -> ReturnValue;
-}
-pub fn big_mod_exp_original_native<const N: usize>(
-    params: &[u8; size_of::<u64>() * 6],
-) -> (ReturnValue, [u8; N]) {
-    let mut result = [0u8; N];
-    let ret = unsafe { sol_big_mod_exp_original(params.as_ptr(), result.as_mut_ptr()) };
-    (ret, result)
-}
-pub fn big_mod_exp_3_original<const N: usize>(
-    base: &[u8],
-    exponent: &[u8],
-    modulus: &[u8; N],
-) -> (ReturnValue, [u8; N]) {
-    const PARAM_COMPONENT_SIZE: usize = size_of::<u64>();
-    let mut params = [0u8; PARAM_COMPONENT_SIZE * 6];
-    for (idx, param) in [base, exponent, modulus].iter().enumerate() {
-        let param_ptr = param.as_ptr() as u64;
-        let param_len = param.len() as u64;
-        let idx_ptr_base = idx * PARAM_COMPONENT_SIZE * 2;
-        let idx_len_base = idx_ptr_base + PARAM_COMPONENT_SIZE;
-        params[idx_ptr_base..idx_ptr_base + PARAM_COMPONENT_SIZE]
-            .copy_from_slice(&param_ptr.to_le_bytes());
-        params[idx_len_base..idx_len_base + PARAM_COMPONENT_SIZE]
-            .copy_from_slice(&param_len.to_le_bytes());
-    }
-    let mut result = [0u8; N];
-    let ret = unsafe { sol_big_mod_exp_original(params.as_ptr(), result.as_mut_ptr()) };
-    (ret, result)
-}
 extern "C" {
     fn sol_big_mod_exp(params_addr: *const u8, return_value_addr: *mut u8) -> ReturnValue;
 }
@@ -237,44 +172,12 @@ pub fn big_mod_exp_3<const N: usize>(
     let ret = unsafe { sol_big_mod_exp(params.as_ptr(), result.as_mut_ptr()) };
     (ret, result)
 }
-extern "C" {
-    fn sol_curve_validate_point_original(curve_id: u64, point_addr: *const u8) -> ReturnValue;
-}
-pub fn curve_validate_point_original_native(curve_id: u64, point: &[u8; 32]) -> ReturnValue {
-    unsafe { sol_curve_validate_point_original(curve_id, point.as_ptr()) }
-}
 extern "C" {
     fn sol_curve_validate_point(curve_id: u64, point_addr: *const u8) -> ReturnValue;
 }
 pub fn curve_validate_point_native(curve_id: u64, point: &[u8; 32]) -> ReturnValue {
     unsafe { sol_curve_validate_point(curve_id, point.as_ptr()) }
 }
-extern "C" {
-    fn sol_curve_group_op_original(
-        curve_id: u64,
-        group_op: u64,
-        left_input_addr: *const u8,
-        right_input_addr: *const u8,
-        result_point_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn curve_group_op_original_native(
-    curve_id: u64,
-    group_op: u64,
-    left_input: &[u8; 32],
-    right_input: &[u8; 32],
-    result_point: &mut [u8; 32],
-) -> ReturnValue {
-    unsafe {
-        sol_curve_group_op_original(
-            curve_id,
-            group_op,
-            left_input.as_ptr(),
-            right_input.as_ptr(),
-            result_point.as_mut_ptr(),
-        )
-    }
-}
 extern "C" {
     fn sol_curve_group_op(
         curve_id: u64,
@@ -301,31 +204,6 @@ pub fn curve_group_op_native(
         )
     }
 }
-extern "C" {
-    fn sol_curve_multiscalar_mul_original(
-        curve_id: u64,
-        scalars_addr: *const u8,
-        points_addr: *const u8,
-        scalars_points_len: u64,
-        result_point_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn curve_multiscalar_mul_original_native(
-    curve_id: u64,
-    scalars: &[[u8; 32]],
-    points: &[[u8; 32]],
-    result_point: &mut [u8; 32],
-) -> ReturnValue {
-    unsafe {
-        sol_curve_multiscalar_mul_original(
-            curve_id,
-            scalars.as_ptr() as *const u8,
-            points.as_ptr() as *const u8,
-            points.len() as u64,
-            result_point.as_mut_ptr(),
-        )
-    }
-}
 extern "C" {
     fn sol_curve_multiscalar_mul(
         curve_id: u64,
@@ -351,28 +229,6 @@ pub fn curve_multiscalar_mul_native(
         )
     }
 }
-extern "C" {
-    fn sol_alt_bn128_group_op_original(
-        group_op: u64,
-        input_addr: *const u8,
-        input_len: u64,
-        result_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn alt_bn128_group_op_original_native(
-    group_op: u64,
-    input: &[u8],
-    result_point: &mut [u8; 64],
-) -> ReturnValue {
-    unsafe {
-        sol_alt_bn128_group_op_original(
-            group_op,
-            input.as_ptr(),
-            input.len() as u64,
-            result_point.as_mut_ptr(),
-        )
-    }
-}
 extern "C" {
     fn sol_alt_bn128_group_op(
         group_op: u64,
@@ -395,28 +251,6 @@ pub fn alt_bn128_group_op_native(
         )
     }
 }
-extern "C" {
-    fn sol_alt_bn128_compression_original(
-        group_op: u64,
-        input_addr: *const u8,
-        input_len: u64,
-        result_addr: *mut u8,
-    ) -> ReturnValue;
-}
-pub fn alt_bn128_compression_original_native(
-    group_op: u64,
-    input: &[u8],
-    result_point: &mut [u8; 128],
-) -> ReturnValue {
-    unsafe {
-        sol_alt_bn128_compression_original(
-            group_op,
-            input.as_ptr(),
-            input.len() as u64,
-            result_point.as_mut_ptr(),
-        )
-    }
-}
 extern "C" {
     fn sol_alt_bn128_compression(
         group_op: u64,