fix(js-tracer): correctly handle isPrecompiled and slice builtins (#363)

Closes #350
Closes #349

- Fixes `isPrecompiled` built-in to work correctly. Before we were
incorrectly checking `precompiles_registered` flag which caused the fn
to never be injected. Added test for it as well
- Adds `slice` built-in and a test for it

Author: klkvr

src/tracing/js/bindings.rs

@@ -803,11 +803,15 @@ impl EvmDbRef {
 
     fn read_code(&self, address: JsValue, ctx: &mut Context) -> JsResult<JsUint8Array> {
         let acc = self.read_basic(address, ctx)?;
-        let code_hash = acc.map(|acc| acc.code_hash).unwrap_or(KECCAK_EMPTY);
+        let code_hash = acc.as_ref().map(|acc| acc.code_hash).unwrap_or(KECCAK_EMPTY);
         if code_hash == KECCAK_EMPTY {
             return JsUint8Array::from_iter(core::iter::empty(), ctx);
         }
 
+        if let Some(bytecode) = acc.as_ref().and_then(|acc| acc.code.as_ref()) {
+            return to_uint8_array(bytecode.original_bytes().to_vec(), ctx);
+        }
+
         let Some(Ok(bytecode)) = self.inner.db.0.with_inner(|db| db.code_by_hash_ref(code_hash))
         else {
             return Err(JsError::from_native(

src/tracing/js/builtins.rs

@@ -87,6 +87,7 @@ pub(crate) fn register_builtins(ctx: &mut Context) -> JsResult<()> {
         3,
         NativeFunction::from_fn_ptr(to_contract2),
     )?;
+    ctx.register_global_callable(js_string!("slice"), 3, NativeFunction::from_fn_ptr(slice))?;
 
     Ok(())
 }
@@ -307,6 +308,26 @@ fn hex_decode_js_string(js_string: &JsString) -> JsResult<Vec<u8>> {
     }
 }
 
+/// Returns a slice of the given value.
+pub(crate) fn slice(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JsValue> {
+    let val = args.get_or_undefined(0).clone();
+
+    let buf = bytes_from_value(val, ctx)?;
+    let start = args.get_or_undefined(1).to_number(ctx)? as usize;
+    let end = args.get_or_undefined(2).to_number(ctx)? as usize;
+
+    if start > end || end > buf.len() {
+        Err(JsError::from_native(JsNativeError::error().with_message(format!(
+            "Tracer accessed out of bound memory: available {}, start {}, end {}",
+            buf.len(),
+            start,
+            end
+        ))))
+    } else {
+        to_uint8_array_value(buf[start..end].iter().copied(), ctx)
+    }
+}
+
 /// A container for all precompile addresses used for the `isPrecompiled` global callable.
 #[derive(Clone, Debug)]
 pub(crate) struct PrecompileList(pub(crate) HashSet<Address>);

src/tracing/js/mod.rs

@@ -410,7 +410,7 @@ impl JsInspector {
 
     /// Registers the precompiles in the JS context
     fn register_precompiles<CTX: ContextTr<Journal: JournalExt>>(&mut self, context: &mut CTX) {
-        if !self.precompiles_registered {
+        if self.precompiles_registered {
             return;
         }
         let precompiles = PrecompileList(context.journal().precompile_addresses().clone());
@@ -692,7 +692,7 @@ fn js_error_to_revert(err: JsError) -> InterpreterResult {
 mod tests {
     use super::*;
 
-    use alloy_primitives::{hex, Address};
+    use alloy_primitives::{bytes, hex, Address};
     use revm::{
         context::TxEnv,
         database::CacheDB,
@@ -975,4 +975,51 @@ mod tests {
             vec![0, 3, 3]
         );
     }
+
+    #[test]
+    fn test_slice_builtin() {
+        let code = r#"{
+            res: [],
+            step: function(log) {
+                // Test slicing a hex string
+                var hex = '0xdeadbeefcafe';
+                this.res.push(toHex(slice(hex, 0, 2)));
+                this.res.push(toHex(slice(hex, 2, 4)));
+                this.res.push(toHex(slice(hex, 4, 6)));
+                
+                // Test slicing an array
+                var arr = [0x01, 0x02, 0x03, 0x04, 0x05];
+                this.res.push(toHex(slice(arr, 0, 3)));
+                this.res.push(toHex(slice(arr, 1, 4)));
+                
+                // Test slicing a Uint8Array
+                var uint8 = new Uint8Array([0xff, 0xee, 0xdd, 0xcc, 0xbb]);
+                this.res.push(toHex(slice(uint8, 0, 2)));
+                this.res.push(toHex(slice(uint8, 2, 5)));
+            },
+            fault: function() {},
+            result: function() { return this.res }
+        }"#;
+        let res = run_trace(code, Some(bytes!("0x00")), true);
+        assert_eq!(
+            res,
+            json!(["0xdead", "0xbeef", "0xcafe", "0x010203", "0x020304", "0xffee", "0xddccbb"])
+        );
+    }
+
+    #[test]
+    fn test_is_precompiled_builtin() {
+        let code = r#"{
+            res: [],
+            step: function(log) {
+                this.res.push(isPrecompiled("0x01"));
+                this.res.push(isPrecompiled("0x0000000000000000000000000000000000000002"));
+                this.res.push(isPrecompiled("0x0000000000000000000000000000000000000000"));
+            },
+            fault: function() {},
+            result: function() { return this.res }
+        }"#;
+        let res = run_trace(code, Some(bytes!("0x00")), true);
+        assert_eq!(res, json!([true, true, false]));
+    }
 }