Fluent base & rwasm

fn syscall_weierstrass_double_handler<E: EllipticCurve, const POINT_SIZE: usize>(    ctx: &mut impl Store<RuntimeContext>,    params: &[Value],    _result: &mut [Value],) -> Result<(), TrapCode> {    let p_ptr: u32 = params[0].i32().unwrap() as u32;
    let mut p = [0u8; POINT_SIZE];    ctx.memory_read(p_ptr as usize, &mut p)?;
    let result = syscall_weierstrass_double_impl::<E, POINT_SIZE>(p);    ctx.memory_write(p_ptr as usize, &result)?;
    Ok(())}

fn syscall_weierstrass_double_impl<E: EllipticCurve, const POINT_SIZE: usize>(    p: [u8; POINT_SIZE],) -> [u8; POINT_SIZE] {    let (px, py) = p.split_at(p.len() / 2);    let p_affine = AffinePoint::<E>::new(BigUint::from_bytes_le(px), BigUint::from_bytes_le(py));    let result_affine = E::ec_double(&p_affine);    let (rx, ry) = (result_affine.x, result_affine.y);    let mut result = [0u8; POINT_SIZE];    let mut rx = rx.to_bytes_le();    rx.resize(POINT_SIZE / 2, 0);    let mut ry = ry.to_bytes_le();    ry.resize(POINT_SIZE / 2, 0);    result[..POINT_SIZE / 2].copy_from_slice(&rx);    result[POINT_SIZE / 2..].copy_from_slice(&ry);    result}

pub fn sw_double(&self) -> AffinePoint<SwCurve<E>> {            ...            let x_3n = (&slope * &slope + &p + &p - &self_x - &self_x) % &p;            ...        }    }}

/// Reproduces chain halt when doubling an invalid BLS12-381 point with/// x = 0xff..ff (above modulus) and y = 0x0.#[test]fn test_coords_above_modulus_halt() {    // 96-byte affine point: [x || y], each 48 bytes.    let mut coords_above_modulus_point = [0u8; 96];
    // Set x = 0xff..ff (48 bytes of 0xff), y stays all zeros.    coords_above_modulus_point[..48].fill(0xff);
    let _result = syscall_bls12381_double_impl(coords_above_modulus_point);}

---- syscall_handler::weierstrass::weierstrass_double::tests::test_coords_above_modulus_halt stdout ----
thread 'syscall_handler::weierstrass::weierstrass_double::tests::test_coords_above_modulus_halt' panicked at /home/ser/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dashu-int-0.4.1/src/error.rs:20:5:UBig result must not be negativenote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

failures:    syscall_handler::weierstrass::weierstrass_double::tests::test_coords_above_modulus_halt
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 44 filtered out; finished in 0.00s
error: test failed, to rerun pass `--lib`

fn div_mod_64_by_32(hi: u32, lo: u32, d: u32) -> (u32, u32) {            let mut q = 0u32;            let mut r = 0u32;            for i in (0..64).rev() {                // shift the remainder left, bring the next dividend bit                r <<= 1;                r |= if i >= 32 {                    (hi >> (i - 32)) & 1                } else {                    (lo >> i) & 1                };                if r >= d {                    r -= d;                    if i >= 32 {                        q |= 1 << (i - 32);                    } else {                        q |= 1 << i;                    }                }            }            (q, r)        }

fn rem_64_by_32(hi: u32, lo: u32, d: u32) -> u32 {            let mut r = 0u32;            for i in (0..64).rev() {                r <<= 1;                r |= if i >= 32 {                    (hi >> (i - 32)) & 1                } else {                    (lo >> i) & 1                };                if r >= d {                    r -= d;                }            }            r        }

(module  (type (;0;) (func (param i64 i64) (result i64)))  (export "test" (func 0))  (func (;0;) (type 0) (param i64 i64) (result i64)    local.get 0    local.get 1    i64.div_u  ))

rwasm: [I64(2155872256)]wasmtime: [I64(2487540446)]

(module  (type (;0;) (func (param i64 i64) (result i64)))  (export "test" (func 0))  (func (;0;) (type 0) (param i64 i64) (result i64)    local.get 0    local.get 1    i64.rem_u  ))

rwasm: [I64(8388607)]wasmtime: [I64(2132322525)]

#[test]fn test_div_u() {    let numerator = 1108274683692540257u64;    let denominator = 4083285857u64;    // split numerator and denominator    let n_lo = (numerator & 0xffffffff) as u32;    let n_hi = (numerator >> 32) as u32;    let d_lo = (denominator & 0xffffffff) as u32;    let d_hi = (denominator >> 32) as u32;    assert_eq!(i64_div_u(n_lo, n_hi, d_lo, d_hi), numerator / denominator);}

use rwasm::{    always_failing_syscall_handler, CompilationConfig, ExecutionEngine, FuelConfig, ImportLinker,    RwasmModule, RwasmStore,};use std::time::Instant;
/// Empty function: (module (func (export "main")))const EMPTY_WASM: &[u8] = &[    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version    0x01, 0x04, 0x01, 0x60, 0x00, 0x00,             // type section: () -> ()    0x03, 0x02, 0x01, 0x00,                         // function section: 1 func, type 0    0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, // export "main"    0x0a, 0x04, 0x01, 0x02, 0x00, 0x0b,             // code section: body_size=2, 0 locals, end];
/// 4096 i64 locals (4096 = 0x80 0x20 LEB128) - max before StackOverflow/// Body: 1 local decl (1) + count leb128 (2) + type (1) + end (1) = 5 bytes/// Section: func_count (1) + body_size (1) + body (5) = 7 bytesconst LOCALS_4096_WASM: &[u8] = &[    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version    0x01, 0x04, 0x01, 0x60, 0x00, 0x00,             // type section: () -> ()    0x03, 0x02, 0x01, 0x00,                         // function section: 1 func, type 0    0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, // export "main"    0x0a, 0x07, 0x01, 0x05, 0x01, 0x80, 0x20, 0x7e, 0x0b, // code: 4096 i64 locals];
/// 32767 i64 locals (32767 = 0xFF 0xFF 0x01 LEB128) - max before DropKeepOutOfBounds/// Body: 1 local decl (1) + count leb128 (3) + type (1) + end (1) = 6 bytes/// Section: func_count (1) + body_size (1) + body (6) = 8 bytesconst LOCALS_32767_WASM: &[u8] = &[    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version    0x01, 0x04, 0x01, 0x60, 0x00, 0x00,             // type section: () -> ()    0x03, 0x02, 0x01, 0x00,                         // function section: 1 func, type 0    0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, // export "main"    0x0a, 0x08, 0x01, 0x06, 0x01, 0xff, 0xff, 0x01, 0x7e, 0x0b, // code: 32767 i64 locals];
fn compile(wasm: &[u8]) -> RwasmModule {    let config = CompilationConfig::default()        .with_entrypoint_name("main".into())        .with_consume_fuel(true);    RwasmModule::compile(config, wasm).expect("compile").0}
fn execute(module: &RwasmModule) -> u64 {    let engine = ExecutionEngine::new();    let mut store = RwasmStore::new(        ImportLinker::default().into(),        (),        always_failing_syscall_handler,        FuelConfig::default(),    );    let _ = engine.execute(&mut store, module, &[], &mut []);    store.fuel_consumed()}
fn benchmark(module: &RwasmModule, iterations: u32) -> std::time::Duration {    let engine = ExecutionEngine::new();    let mut store = RwasmStore::<()>::default();
    // Warmup    for _ in 0..10 {        let _ = engine.execute(&mut store, module, &[], &mut []);    }
    // Timed runs    let start = Instant::now();    for _ in 0..iterations {        let _ = engine.execute(&mut store, module, &[], &mut []);    }    start.elapsed()}
#[test]fn test_locals_fuel_and_runtime() {    const ITERATIONS: u32 = 1000;
    let empty = compile(EMPTY_WASM);    let loc4k = compile(LOCALS_4096_WASM);    let loc32k = compile(LOCALS_32767_WASM);
    let empty_fuel = execute(&empty);    let loc4k_fuel = execute(&loc4k);    let loc32k_fuel = execute(&loc32k);
    let empty_time = benchmark(&empty, ITERATIONS) / ITERATIONS;    let loc4k_time = benchmark(&loc4k, ITERATIONS) / ITERATIONS;    let loc32k_time = benchmark(&loc32k, ITERATIONS) / ITERATIONS;
    eprintln!("\n=== Locals Fuel & Runtime ===");    eprintln!("0 locals:     fuel={}, time={:?}", empty_fuel, empty_time);    eprintln!("4096 locals:  fuel={}, time={:?}", loc4k_fuel, loc4k_time);    eprintln!("32767 locals: fuel={}, time={:?}", loc32k_fuel, loc32k_time);
    eprintln!("Slowdown: {:.0}x",        loc4k_time.as_nanos() as f64 / empty_time.as_nanos() as f64);}

=== Locals Fuel & Runtime ===0 locals:     fuel=1, time=11ns4096 locals:  fuel=1, time=22.344µs32767 locals: fuel=1, time=11nsSlowdown: 2031xtest test_locals_fuel_and_runtime ... ok

PRECOMPILE_BLS12_381_G1_ADD => {            ...            let p_aff = G1Affine::from_uncompressed(&p).unwrap_or(G1Affine::identity());            let q_aff = G1Affine::from_uncompressed(&q).unwrap_or(G1Affine::identity());
            let result = p_aff.add_affine(&q_aff);            let result_bytes = result.to_uncompressed();
            // Convert output from runtime format to EVM format            let out = convert_g1_output_to_evm(&result_bytes);            Ok(out.into())        }        PRECOMPILE_BLS12_381_G2_ADD => {            ...            let p_aff = G2Affine::from_uncompressed(&p).unwrap_or(G2Affine::identity());            let q_aff = G2Affine::from_uncompressed(&q).unwrap_or(G2Affine::identity());
            let result = G2Projective::from(p_aff) + G2Projective::from(q_aff);            let result_aff = G2Affine::from(result);            let result_bytes = result_aff.to_uncompressed();
            // Encode output: 256 bytes (x0||x1||y0||y1), each limb is 64-byte BE padded (16 zeros + 48 value)            let out = convert_g2_output_to_evm_rwasm(&result_bytes);            Ok(out.into())        }

/// Serializes this element into uncompressed form. See [`notes::serialization`](crate::notes::serialization)    /// for details about how group elements are serialized.    pub fn to_uncompressed(&self) -> [u8; 96] {        let mut res = [0; 96];
        res[0..48].copy_from_slice(            &Fp::conditional_select(&self.x, &Fp::zero(), self.infinity).to_bytes()[..],        );        res[48..96].copy_from_slice(            &Fp::conditional_select(&self.y, &Fp::zero(), self.infinity).to_bytes()[..],        );
        // Is this point at infinity? If so, set the second-most significant bit.        res[0] |= u8::conditional_select(&0u8, &(1u8 << 6), self.infinity);
        res    }

// Check if the result is identity            let out = if result.is_identity().unwrap_u8() == 1 {                [0u8; ...] // set padding size to G1 or G2            } else {                ... // return the correctly encoded point            };

let p_aff = G1Affine::from_uncompressed(&p).unwrap_or(G1Affine::identity());

/// Attempts to deserialize an uncompressed element. See [`notes::serialization`](crate::notes::serialization)    /// for details about how group elements are serialized.    pub fn from_uncompressed(bytes: &[u8; 96]) -> CtOption<Self> {        Self::from_uncompressed_unchecked(bytes)            .and_then(|p| CtOption::new(p, p.is_on_curve() & p.is_torsion_free()))    }

/// Helper function to convert scalar from BE format to rwasm-patches Scalar#[inline(always)]fn convert_scalar_be_to_rwasm_patches(scalar_be: &[u8; SCALAR_SIZE]) -> Scalar {    // Convert from BE bytes to LE bytes, then to Scalar    let mut bytes = [0u8; 32];    bytes.copy_from_slice(scalar_be);    bytes.reverse(); // Convert BE to LE    Scalar::from_bytes(&bytes).unwrap_or(Scalar::zero())}

/// Attempts to convert a little-endian byte representation of    /// a scalar into a `Scalar`, failing if the input is not canonical.    pub fn from_bytes(bytes: &[u8; 32]) -> CtOption<Scalar> {        let mut tmp = Scalar([0, 0, 0, 0]);
        tmp.0[0] = u64::from_le_bytes(<[u8; 8]>::try_from(&bytes[0..8]).unwrap());        tmp.0[1] = u64::from_le_bytes(<[u8; 8]>::try_from(&bytes[8..16]).unwrap());        tmp.0[2] = u64::from_le_bytes(<[u8; 8]>::try_from(&bytes[16..24]).unwrap());        tmp.0[3] = u64::from_le_bytes(<[u8; 8]>::try_from(&bytes[24..32]).unwrap());
        // Try to subtract the modulus        let (_, borrow) = sbb(tmp.0[0], MODULUS.0[0], 0);        let (_, borrow) = sbb(tmp.0[1], MODULUS.0[1], borrow);        let (_, borrow) = sbb(tmp.0[2], MODULUS.0[2], borrow);        let (_, borrow) = sbb(tmp.0[3], MODULUS.0[3], borrow);
        // If the element is smaller than MODULUS then the        // subtraction will underflow, producing a borrow value        // of 0xffff...ffff. Otherwise, it'll be zero.        let is_some = (borrow as u8) & 1;
        // Convert to Montgomery form by computing        // (a.R^0 * R^2) / R = a.R        tmp *= &R2;
        CtOption::new(tmp, Choice::from(is_some))    }

if inject_fuel_check {    self.op_local_get(1); // n    self.op_i32_const(MEMORY_BYTES_PER_FUEL_LOG2); // 2^6=64    self.op_i32_shr_u(); // delta/64    self.op_consume_fuel_stack();}

if inject_fuel_check {      self.op_local_get(1); // n+     self.op_i32_const((1 << MEMORY_BYTES_PER_FUEL_LOG2) - 1);+     self.op_i32_add();      self.op_i32_const(MEMORY_BYTES_PER_FUEL_LOG2); // 2^6=64      self.op_i32_shr_u(); // delta/64      self.op_consume_fuel_stack();  }

const GENESIS_CONTRACTS: &[(Address, fluentbase_contracts::BuildOutput)] = &[    (fluentbase_sdk::PRECOMPILE_BIG_MODEXP, fluentbase_contracts::FLUENTBASE_CONTRACTS_MODEXP),    (fluentbase_sdk::PRECOMPILE_BLAKE2F, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLAKE2F),    (fluentbase_sdk::PRECOMPILE_BN256_ADD, fluentbase_contracts::FLUENTBASE_CONTRACTS_BN256),    (fluentbase_sdk::PRECOMPILE_BN256_MUL, fluentbase_contracts::FLUENTBASE_CONTRACTS_BN256),    (fluentbase_sdk::PRECOMPILE_BN256_PAIR, fluentbase_contracts::FLUENTBASE_CONTRACTS_BN256),    (fluentbase_sdk::PRECOMPILE_UNIVERSAL_TOKEN_RUNTIME, fluentbase_contracts::FLUENTBASE_UNIVERSAL_TOKEN),    (fluentbase_sdk::PRECOMPILE_EIP2935, fluentbase_contracts::FLUENTBASE_CONTRACTS_EIP2935),    (fluentbase_sdk::PRECOMPILE_EVM_RUNTIME, fluentbase_contracts::FLUENTBASE_CONTRACTS_EVM),    #[cfg(feature="svm")]    (fluentbase_sdk::PRECOMPILE_SVM_RUNTIME, fluentbase_contracts::FLUENTBASE_CONTRACTS_SVM),    (fluentbase_sdk::PRECOMPILE_FAIRBLOCK_VERIFIER, fluentbase_contracts::FLUENTBASE_CONTRACTS_FAIRBLOCK),    (fluentbase_sdk::PRECOMPILE_IDENTITY, fluentbase_contracts::FLUENTBASE_CONTRACTS_IDENTITY),    (fluentbase_sdk::PRECOMPILE_KZG_POINT_EVALUATION, fluentbase_contracts::FLUENTBASE_CONTRACTS_KZG),    (fluentbase_sdk::PRECOMPILE_BLS12_381_G1_ADD, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_G1_MSM, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_G2_ADD, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_G2_MSM, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_PAIRING, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_MAP_G1, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_BLS12_381_MAP_G2, fluentbase_contracts::FLUENTBASE_CONTRACTS_BLS12381),    (fluentbase_sdk::PRECOMPILE_NATIVE_MULTICALL, fluentbase_contracts::FLUENTBASE_CONTRACTS_MULTICALL),    (fluentbase_sdk::PRECOMPILE_NITRO_VERIFIER, fluentbase_contracts::FLUENTBASE_CONTRACTS_NITRO),    (fluentbase_sdk::PRECOMPILE_OAUTH2_VERIFIER, fluentbase_contracts::FLUENTBASE_CONTRACTS_OAUTH2),    (fluentbase_sdk::PRECOMPILE_RIPEMD160, fluentbase_contracts::FLUENTBASE_CONTRACTS_RIPEMD160),    (fluentbase_sdk::PRECOMPILE_WASM_RUNTIME, fluentbase_contracts::FLUENTBASE_CONTRACTS_WASM),    (fluentbase_sdk::PRECOMPILE_SECP256K1_RECOVER, fluentbase_contracts::FLUENTBASE_CONTRACTS_ECRECOVER),    (fluentbase_sdk::PRECOMPILE_SHA256, fluentbase_contracts::FLUENTBASE_CONTRACTS_SHA256),    (fluentbase_sdk::PRECOMPILE_WEBAUTHN_VERIFIER, fluentbase_contracts::FLUENTBASE_CONTRACTS_WEBAUTHN),];...fn compile_all_contracts() -> HashMap<&'static [u8], (B256, Bytes)> {    ...    let config = default_compilation_config()        .with_consume_fuel(false)        .with_builtins_consume_fuel(false);    for (_, contract) in GENESIS_CONTRACTS {        i...        let rwasm_bytecode =            compile_wasm_to_rwasm_with_config(contract.wasm_bytecode, config.clone())                .expect(format!("failed to compile ({}), because of: ", contract.name).as_str());        ...    }    ...}

pub const unsafe fn unreachable_unchecked() -> ! {    ub_checks::assert_unsafe_precondition!(        check_language_ub,        "hint::unreachable_unchecked must never be reached",        () => false    );    // SAFETY: the safety contract for `intrinsics::unreachable` must    // be upheld by the caller.    unsafe { intrinsics::unreachable() }}

#[test]fn test_locals_amplification_find_limit() {    //let mut ctx = EvmTestingContext::default().with_full_genesis();    let owner: Address = Address::ZERO;
    // Test various function counts to find limits    try_deploy(owner, 16);    try_deploy(owner, 17);}
fn try_deploy(owner: Address, num_funcs: u32) {    let wasm = build_max_locals_module(num_funcs);    let wasm_len = wasm.len();
    // Create fresh context for each test to avoid state interference    let mut ctx = EvmTestingContext::default().with_full_genesis();
    match ctx.deploy_evm_tx_with_gas_result(owner, wasm.into()) {        Ok((addr, gas)) => {            let size = ctx.get_code(addr).unwrap().len();            println!("funcs #{:>2}: initcode {:>4} bytes; {:>12} gas; deployed {:>9} bytes; OK", num_funcs, wasm_len, gas, size);
        }        Err(result) => {            println!("funcs #{}: initcode {:>12} bytes; {:>12} gas; deployed {:>12} bytes; Err", num_funcs, wasm_len, "-", 0);        }    }}
fn leb128(mut n: u32) -> Vec<u8> {    let mut out = Vec::new();    loop {        let mut byte = (n & 0x7F) as u8;        n >>= 7;        if n != 0 {            byte |= 0x80;        }        out.push(byte);        if n == 0 {            break;        }    }    out}
/// Build WASM module with N functions, each with 32767 i64 localsfn build_max_locals_module(num_funcs: u32) -> Vec<u8> {    let num_funcs_leb = leb128(num_funcs);
    let func_section_size = num_funcs_leb.len() + num_funcs as usize;    let func_section_size_leb = leb128(func_section_size as u32);
    // Each function body: size=6, 1 local decl, 32767 (0xFF 0xFF 0x01), i64, end    let body: &[u8] = &[0x06, 0x01, 0xff, 0xff, 0x01, 0x7e, 0x0b];    let code_section_size = num_funcs_leb.len() + (num_funcs as usize * body.len());    let code_section_size_leb = leb128(code_section_size as u32);
    let mut wasm = vec![        0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version        0x01, 0x04, 0x01, 0x60, 0x00, 0x00, // type section: () -> ()    ];
    // Function section    wasm.push(0x03);    wasm.extend_from_slice(&func_section_size_leb);    wasm.extend_from_slice(&num_funcs_leb);    for _ in 0..num_funcs {        wasm.push(0x00);    }
    // Export section (export first func as "main")    wasm.extend_from_slice(&[        0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00,    ]);
    // Code section    wasm.push(0x0a);    wasm.extend_from_slice(&code_section_size_leb);    wasm.extend_from_slice(&num_funcs_leb);    for _ in 0..num_funcs {        wasm.extend_from_slice(body);    }
    wasm}
/// Single function with 32767 i64 localsconst SINGLE_FUNC_MAX_LOCALS_WASM: &[u8] = &[    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, // magic + version    0x01, 0x04, 0x01, 0x60, 0x00, 0x00, // type section: () -> ()    0x03, 0x02, 0x01, 0x00, // function section: 1 func, type 0    0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, // export "main"    0x0a, 0x08, 0x01, 0x06, 0x01, 0xff, 0xff, 0x01, 0x7e, 0x0b, // code: 32767 i64 locals];

running 1 testfuncs #16: initcode  158 bytes; 55250 gas; deployed 12583233 bytes; OKoutput: 0x756e7361666520707265636f6e646974696f6e2873292076696f6c617465643a2068696e743a3a756e726561636861626c655f756e636865636b6564206d757374206e6576657220626520726561636865640a0a5468697320696e6469636174657320612062756720696e207468652070726f6772616d2e205468697320556e646566696e6564204265686176696f7220636865636b206973206f7074696f6e616c2c20616e642063616e6e6f742062652072656c696564206f6e20666f72207361666574792e (unsafe precondition(s) violated: hint::unreachable_unchecked must never be reached
This indicates a bug in the program. This Undefined Behavior check is optional, and cannot be relied on for safety.)funcs #17: initcode  166 bytes;     - gas; deployed        0 bytes; Errtest deployer::test_locals_amplification_find_limit ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 62 filtered out; finished in 38.17s

/// Generates the [`unreachable`] instruction, which causes an unconditional [trap].////// This function is safe to call and immediately aborts the execution.////// [`unreachable`]: https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-control/// [trap]: https://webassembly.github.io/spec/core/intro/overview.html#trap#[cfg_attr(test, assert_instr(unreachable))]#[inline]#[stable(feature = "unreachable_wasm32", since = "1.37.0")]pub fn unreachable() -> ! {    crate::intrinsics::abort()}

pub(super) fn remove_fp_padding(input: &[u8]) -> Result<&[u8; FP_LENGTH], PrecompileError> {    ...    let (padding, unpadded) = input.split_at(FP_PAD_BY);    if !padding.iter().all(|&x| x == 0) {        return Err(PrecompileError::Other(format!(            "{FP_PAD_BY} top bytes of input are not zero",        )));    }    Ok(unpadded.try_into().unwrap())}

SYSCALL_ID_METADATA_COPY => {            ...            let offset = LittleEndian::read_u32(&input[20..24]);            let length = LittleEndian::read_u32(&input[24..28]);            // take min            let length = length.min(ownable_account_bytecode.metadata.len() as u32);            let metadata = ownable_account_bytecode                .metadata                .slice(offset as usize..(offset + length) as usize);            return_result!(metadata, Ok)        }

fn call<    WIRE: InterpreterTypes<Extend = InterruptionExtension, Stack = Stack>,    H: Host + HostWrapper + ?Sized,>(    context: InstructionContext<'_, H, WIRE>,) {    ...    interrupt_into_action(context, |context, sdk| {        let input = global_memory_from_shared_buffer(&context, in_range);        // TODO(dmitry123): I know that wrapping mul works here, but why?        let fuel_limit = Some(local_gas_limit.wrapping_mul(FUEL_DENOM_RATE));        sdk.call(to, value, input.as_ref(), fuel_limit)    });}

let mut gas_limit = min(                frame.interpreter.gas.remaining_63_of_64_parts(),                inputs.syscall_params.fuel_limit / FUEL_DENOM_RATE,            );

fn verify_attestation_doc(doc: &AttestationDoc, root_certificate: &Certificate) {    let mut chain = Vec::new();    assert!(!doc.cabundle.is_empty());    assert_eq!(doc.cabundle[0], root_certificate.to_der().unwrap());    for cert in &doc.cabundle {        chain.push(Certificate::from_der(cert).unwrap());    }    chain.push(Certificate::from_der(&doc.certificate).unwrap());    for i in 0..chain.len() - 1 {        verify_certificate(&chain[i + 1], &chain[i]);    }}

pub const SIG_ALLOWANCE: EvmExitCode = derive_keccak256_id!("allowance(address)");

/// Returns the ERC-20 `symbol()` as a short string stored at `SYMBOL_STORAGE_SLOT`.fn erc20_symbol_handler<SDK: SharedAPI>(    sdk: &mut SDK,    _input: &[u8],) -> Result<EvmExitCode, ExitCode> {    let value = sdk.storage_short_string(&SYMBOL_STORAGE_SLOT)?;    sdk.write(value.as_bytes());    Ok(0)}
/// Returns the ERC-20 `name()` as a short string stored at `NAME_STORAGE_SLOT`.fn erc20_name_handler<SDK: SharedAPI>(    sdk: &mut SDK,    _input: &[u8],) -> Result<EvmExitCode, ExitCode> {    let value = sdk.storage_short_string(&NAME_STORAGE_SLOT)?;    sdk.write(value.as_bytes());    Ok(0)}

cast abi-encode "foo(string)" "hello"
0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000

0x0000000000000000000000000000000000000000000000000000000000000020 # offset to start0x0000000000000000000000000000000000000000000000000000000000000005 # length in bytes0x68656c6c6f000000000000000000000000000000000000000000000000000000 # data

let s = String::from("hello");
assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());

let user_requested_block_number = U256::try_from_le_slice(&input[..U256::BYTES]).unwrap();let block_number = sdk.context().block_number();if block_number <= 0 {    sdk.native_exit(ExitCode::Panic);}let block_number = U256::from(block_number);let block_number_prev = block_number - U256::from(1);if user_requested_block_number > block_number_prev {    sdk.native_exit(ExitCode::Panic);  // <--- This panic will trigger}