@nomicfoundation/edr 0.2.0-alpha.2

package/src/trace.rs

@@ -0,0 +1,168 @@
+use std::{mem, sync::Arc};
+
+use edr_evm::{trace::BeforeMessage, OPCODE_JUMPMAP};
+use napi::{
+    bindgen_prelude::{BigInt, Buffer, Either3},
+    Env, JsBuffer, JsBufferValue,
+};
+use napi_derive::napi;
+
+use crate::result::ExecutionResult;
+
+#[napi(object)]
+pub struct TracingMessage {
+    /// Sender address
+    #[napi(readonly)]
+    pub caller: Buffer,
+
+    /// Recipient address. None if it is a Create message.
+    #[napi(readonly)]
+    pub to: Option<Buffer>,
+
+    /// Transaction gas limit
+    #[napi(readonly)]
+    pub gas_limit: BigInt,
+
+    /// Depth of the message
+    #[napi(readonly)]
+    pub depth: u8,
+
+    /// Input data of the message
+    #[napi(readonly)]
+    pub data: JsBuffer,
+
+    /// Value sent in the message
+    #[napi(readonly)]
+    pub value: BigInt,
+
+    /// Address of the code that is being executed. Can be different from `to`
+    /// if a delegate call is being done.
+    #[napi(readonly)]
+    pub code_address: Option<Buffer>,
+
+    /// Code of the contract that is being executed.
+    #[napi(readonly)]
+    pub code: Option<JsBuffer>,
+}
+
+impl TracingMessage {
+    pub fn new(env: &Env, message: &BeforeMessage) -> napi::Result<Self> {
+        let data = message.data.clone();
+        let data = unsafe {
+            env.create_buffer_with_borrowed_data(
+                data.as_ptr(),
+                data.len(),
+                data,
+                |data: edr_eth::Bytes, _env| {
+                    mem::drop(data);
+                },
+            )
+        }
+        .map(JsBufferValue::into_raw)?;
+
+        let code = message.code.as_ref().map_or(Ok(None), |code| {
+            let code = code.original_bytes();
+
+            unsafe {
+                env.create_buffer_with_borrowed_data(
+                    code.as_ptr(),
+                    code.len(),
+                    code,
+                    |code: edr_eth::Bytes, _env| {
+                        mem::drop(code);
+                    },
+                )
+            }
+            .map(JsBufferValue::into_raw)
+            .map(Some)
+        })?;
+
+        Ok(TracingMessage {
+            caller: Buffer::from(message.caller.as_slice()),
+            to: message.to.map(|to| Buffer::from(to.as_slice())),
+            gas_limit: BigInt::from(message.gas_limit),
+            depth: message.depth as u8,
+            data,
+            value: BigInt {
+                sign_bit: false,
+                words: message.value.into_limbs().to_vec(),
+            },
+            code_address: message
+                .code_address
+                .map(|address| Buffer::from(address.to_vec())),
+            code,
+        })
+    }
+}
+
+#[napi(object)]
+pub struct TracingStep {
+    /// Call depth
+    #[napi(readonly)]
+    pub depth: u8,
+    /// The program counter
+    #[napi(readonly)]
+    pub pc: BigInt,
+    /// The executed op code
+    #[napi(readonly)]
+    pub opcode: String,
+    /// The top entry on the stack. None if the stack is empty.
+    #[napi(readonly)]
+    pub stack_top: Option<BigInt>,
+}
+
+impl TracingStep {
+    pub fn new(step: &edr_evm::trace::Step) -> Self {
+        Self {
+            depth: step.depth as u8,
+            pc: BigInt::from(step.pc),
+            opcode: OPCODE_JUMPMAP[usize::from(step.opcode)]
+                .unwrap_or("")
+                .to_string(),
+            stack_top: step.stack_top.map(|v| BigInt {
+                sign_bit: false,
+                words: v.into_limbs().to_vec(),
+            }),
+        }
+    }
+}
+
+#[napi(object)]
+pub struct TracingMessageResult {
+    /// Execution result
+    #[napi(readonly)]
+    pub execution_result: ExecutionResult,
+}
+
+#[napi]
+pub struct RawTrace {
+    inner: Arc<edr_evm::trace::Trace>,
+}
+
+impl RawTrace {
+    pub fn new(inner: Arc<edr_evm::trace::Trace>) -> Self {
+        Self { inner }
+    }
+}
+
+#[napi]
+impl RawTrace {
+    #[napi]
+    pub fn trace(
+        &self,
+        env: Env,
+    ) -> napi::Result<Vec<Either3<TracingMessage, TracingStep, TracingMessageResult>>> {
+        self.inner
+            .messages
+            .iter()
+            .map(|message| match message {
+                edr_evm::trace::TraceMessage::Before(message) => {
+                    TracingMessage::new(&env, message).map(Either3::A)
+                }
+                edr_evm::trace::TraceMessage::Step(step) => Ok(Either3::B(TracingStep::new(step))),
+                edr_evm::trace::TraceMessage::After(result) => ExecutionResult::new(&env, result)
+                    .map(|execution_result| Either3::C(TracingMessageResult { execution_result })),
+            })
+            .collect::<napi::Result<_>>()
+    }
+}

package/test/provider.ts

@@ -0,0 +1,104 @@
+import chai, { assert } from "chai";
+import chaiAsPromised from "chai-as-promised";
+import {
+  ContractAndFunctionName,
+  EdrContext,
+  MineOrdering,
+  Provider,
+  SpecId,
+  SubscriptionEvent,
+} from "..";
+
+chai.use(chaiAsPromised);
+
+function getEnv(key: string): string | undefined {
+  const variable = process.env[key];
+  if (variable === undefined || variable === "") {
+    return undefined;
+  }
+
+  const trimmed = variable.trim();
+
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
+const ALCHEMY_URL = getEnv("ALCHEMY_URL");
+
+describe("Provider", () => {
+  const context = new EdrContext();
+  const providerConfig = {
+    allowBlocksWithSameTimestamp: false,
+    allowUnlimitedContractSize: true,
+    bailOnCallFailure: false,
+    bailOnTransactionFailure: false,
+    blockGasLimit: 300_000_000n,
+    chainId: 123n,
+    chains: [],
+    coinbase: Buffer.from("0000000000000000000000000000000000000000", "hex"),
+    genesisAccounts: [],
+    hardfork: SpecId.Latest,
+    initialBlobGas: {
+      gasUsed: 0n,
+      excessGas: 0n,
+    },
+    initialParentBeaconBlockRoot: Buffer.from(
+      "0000000000000000000000000000000000000000000000000000000000000000",
+      "hex"
+    ),
+    minGasPrice: 0n,
+    mining: {
+      autoMine: true,
+      memPool: {
+        order: MineOrdering.Priority,
+      },
+    },
+    networkId: 123n,
+  };
+
+  const loggerConfig = {
+    enable: false,
+    decodeConsoleLogInputsCallback: (inputs: Buffer[]): string[] => {
+      return [];
+    },
+    getContractAndFunctionNameCallback: (
+      _code: Buffer,
+      _calldata?: Buffer
+    ): ContractAndFunctionName => {
+      return {
+        contractName: "",
+      };
+    },
+    printLineCallback: (message: string, replace: boolean) => {},
+  };
+
+  it("initialize local", async function () {
+    const provider = Provider.withConfig(
+      context,
+      providerConfig,
+      loggerConfig,
+      (_event: SubscriptionEvent) => {}
+    );
+
+    await assert.isFulfilled(provider);
+  });
+
+  it("initialize remote", async function () {
+    if (ALCHEMY_URL === undefined) {
+      this.skip();
+    }
+
+    const provider = Provider.withConfig(
+      context,
+      {
+        fork: {
+          jsonRpcUrl: ALCHEMY_URL,
+        },
+        ...providerConfig,
+      },
+      loggerConfig,
+      (_event: SubscriptionEvent) => {}
+    );
+
+    await assert.isFulfilled(provider);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../config/typescript/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./build-test",
+    "rootDirs": [
+      "./test"
+    ],
+    "composite": true
+  },
+  "include": [
+    "./*.ts",
+    "./test/**/*.ts"
+  ],
+  "exclude": [
+    "./node_modules"
+  ]
+}