[pallet-revive] Execution tracer

prdoc/pr_9722.prdoc

@@ -0,0 +1,122 @@
+title: '[pallet-revive] opcode tracer'
+doc:
+- audience: Runtime Dev
+  description: |
+    This PR introduces a **Geth-compatible execution tracer** ([StructLogger](https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers#struct-opcode-logger)) for pallet-revive
+
+    The tracer can be used to capture both EVM opcode and PVM syscall.
+    It can be used with  the same RPC endpoint as Geth StructLogger.
+
+
+    Since it can be quite resource intensive, It can only be queried from the node when the **DebugSettings** are enabled (This is turned on now by default in the dev-node)
+
+    Tested in https://github.com/paritytech/evm-test-suite/pull/138
+
+
+    example:
+
+    ```sh
+    ❯ cast rpc debug_traceTransaction "<TX_HASH>" | jq
+
+    # or with options
+    # See list of options https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers#struct-opcode-logger
+
+     ❯ cast rpc debug_traceTransaction "<TX_HASH>", { "tracer": { "enableMemory": true } } | jq
+    ```
+
+    The response includes additional fields compared to the original Geth debug RPC endpoints:
+
+    For the trace:
+    - `weight_consumed`: same as gas but expressed in Weight
+    - `base_call_weight`: the base cost of the transaction
+
+    For each step:
+    - `weight_cost`: same as gas_cost but expressed in Weight
+
+    For an EVM execution, the output will look like this
+
+    ```json
+    {
+      "gas": 4208049,
+      "weight_consumed": { "ref_time": 126241470000, "proof_size": 4208 },
+      "base_call_weight": { "ref_time": 9000000000, "proof_size": 3000 },
+      "failed": false,
+      "returnValue": "0x",
+      "structLogs": [
+        {
+          "gas": 4109533,
+          "gasCost": 3,
+          "weight_cost": { "ref_time": 90000, "proof_size": 0 },
+          "depth": 1,
+          "pc": 0,
+          "op": "PUSH1",
+          "stack": []
+        },
+        {
+          "gas": 4109530,
+          "gasCost": 3,
+          "weight_cost": { "ref_time": 90000, "proof_size": 0 },
+          "depth": 1,
+          "pc": 2,
+          "op": "PUSH1",
+          "stack": [
+            "0x80"
+          ]
+        },
+        {
+          "gas": 4109527,
+          "gasCost": 3,
+          "weight_cost": { "ref_time": 90000, "proof_size": 0 },
+          "depth": 1,
+          "pc": 4,
+          "op": "MSTORE",
+          "stack": [
+            "0x80",
+            "0x40"
+          ]
+        }]
+    }
+    ```
+
+    For a PVM execution the response will look like this
+
+    ```json
+    {
+      "gas": 97945,
+      "weight_consumed": { "ref_time": 2938350000, "proof_size": 97 },
+      "base_call_weight": { "ref_time": 9000000000, "proof_size": 3000 },
+      "failed": false,
+      "returnValue": "0x",
+      "structLogs": [
+        {
+          "gas": 97108,
+          "gasCost": 131,
+          "weight_cost": { "ref_time": 3930000, "proof_size": 0 },
+          "depth": 1,
+          "op": "call_data_size"
+        },
+        {
+          "gas": 96977,
+          "gasCost": 20,
+          "weight_cost": { "ref_time": 600000, "proof_size": 0 },
+          "depth": 1,
+          "op": "call_data_load"
+        },
+        {
+          "gas": 96957,
+          "gasCost": 7,
+          "weight_cost": { "ref_time": 210000, "proof_size": 0 },
+          "depth": 1,
+          "op": "value_transferred"
+        }]
+    }
+    ```
+crates:
+- name: pallet-revive
+  bump: patch
+- name: pallet-revive-eth-rpc
+  bump: patch
+- name: pallet-revive-proc-macro
+  bump: patch
+- name: revive-dev-runtime
+  bump: patch

substrate/frame/revive/dev-node/node/src/command.rs

@@ -125,6 +125,10 @@ pub fn run_with_args(args: Vec<String>) -> sc_cli::Result<()> {
 			// Enforce dev
 			cli.run.shared_params.dev = true;
 
+			// Increase max_response_size for large trace responses
+			cli.run.rpc_params.rpc_max_response_size =
+				cli.run.rpc_params.rpc_max_response_size.max(50);
+
 			// Pass Default logging settings if none are specified
 			if std::env::var("RUST_LOG").is_err() && cli.run.shared_params.log.is_empty() {
 				cli.run.shared_params.log = "error,sc_rpc_server=info,runtime::revive=debug"

substrate/frame/revive/dev-node/runtime/src/lib.rs

@@ -355,7 +355,7 @@ impl pallet_revive::Config for Runtime {
 	type InstantiateOrigin = EnsureSigned<Self::AccountId>;
 	type Time = Timestamp;
 	type FeeInfo = FeeInfo<Address, Signature, EthExtraImpl>;
-	type DebugEnabled = ConstBool<false>;
+	type DebugEnabled = ConstBool<true>;
 	type GasScale = ConstU32<50000>;
 }
 

substrate/frame/revive/proc-macro/src/lib.rs

@@ -317,12 +317,19 @@ fn expand_env(def: &EnvDef) -> TokenStream2 {
 	let bench_impls = expand_bench_functions(def);
 	let docs = expand_func_doc(def);
 	let all_syscalls = expand_func_list(def);
+	let lookup_syscall = expand_func_lookup(def);
 
 	quote! {
+		/// Returns the list of all syscalls.
 		pub fn list_syscalls() -> &'static [&'static [u8]] {
 			#all_syscalls
 		}
 
+		/// Return the index of a syscall in the `all_syscalls()` list.
+		pub fn lookup_syscall_index(name: &'static str) -> Option<u8> {
+			#lookup_syscall
+		}
+
 		impl<'a, E: Ext, M: PolkaVmInstance<E::T>> Runtime<'a, E, M> {
 			fn handle_ecall(
 				&mut self,
@@ -398,9 +405,13 @@ fn expand_functions(def: &EnvDef) -> TokenStream2 {
 			let trace_fmt_str = format!("{}({}) = {{:?}} weight_consumed: {{:?}}", name, params_fmt_str);
 
 			quote! {
+				crate::tracing::if_tracing(|tracer| tracer.enter_ecall(#name, self));
+
 				// wrap body in closure to make sure the tracing is always executed
 				let result = (|| #body)();
 				::log::trace!(target: "runtime::revive::strace", #trace_fmt_str, #( #trace_fmt_args, )* result, self.ext.frame_meter().weight_consumed());
+
+				crate::tracing::if_tracing(|tracer| tracer.exit_step(self));
 				result
 			}
 		};
@@ -519,3 +530,19 @@ fn expand_func_list(def: &EnvDef) -> TokenStream2 {
 		}
 	}
 }
+
+fn expand_func_lookup(def: &EnvDef) -> TokenStream2 {
+	let arms = def.host_funcs.iter().enumerate().map(|(idx, f)| {
+		let name_str = &f.name;
+		quote! {
+			#name_str => Some(#idx as u8)
+		}
+	});
+
+	quote! {
+		match name {
+			#( #arms, )*
+			_ => None,
+		}
+	}
+}

substrate/frame/revive/rpc/src/apis/debug_apis.rs

@@ -29,7 +29,7 @@ pub trait DebugRpc {
 	async fn trace_block_by_number(
 		&self,
 		block: BlockNumberOrTag,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Vec<TransactionTrace>>;
 
 	/// Returns a transaction's traces by replaying it.
@@ -41,7 +41,7 @@ pub trait DebugRpc {
 	async fn trace_transaction(
 		&self,
 		transaction_hash: H256,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Trace>;
 
 	/// Dry run a call and returns the transaction's traces.
@@ -54,7 +54,7 @@ pub trait DebugRpc {
 		&self,
 		transaction: GenericTransaction,
 		block: BlockNumberOrTagOrHash,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Trace>;
 
 	#[method(name = "debug_getAutomine")]
@@ -94,28 +94,28 @@ impl DebugRpcServer for DebugRpcServerImpl {
 	async fn trace_block_by_number(
 		&self,
 		block: BlockNumberOrTag,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Vec<TransactionTrace>> {
-		let TracerConfig { config, timeout } = tracer_config;
+		let TracerConfig { config, timeout } = tracer_config.unwrap_or_default();
 		with_timeout(timeout, self.client.trace_block_by_number(block, config)).await
 	}
 
 	async fn trace_transaction(
 		&self,
 		transaction_hash: H256,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Trace> {
-		let TracerConfig { config, timeout } = tracer_config;
+		let TracerConfig { config, timeout } = tracer_config.unwrap_or_default();
 		with_timeout(timeout, self.client.trace_transaction(transaction_hash, config)).await
 	}
 
 	async fn trace_call(
 		&self,
 		transaction: GenericTransaction,
 		block: BlockNumberOrTagOrHash,
-		tracer_config: TracerConfig,
+		tracer_config: Option<TracerConfig>,
 	) -> RpcResult<Trace> {
-		let TracerConfig { config, timeout } = tracer_config;
+		let TracerConfig { config, timeout } = tracer_config.unwrap_or_default();
 		with_timeout(timeout, self.client.trace_call(transaction, block, config)).await
 	}
 

substrate/frame/revive/rpc/src/cli.rs

@@ -111,10 +111,12 @@ fn build_client(
 	earliest_receipt_block: Option<SubstrateBlockNumber>,
 	node_rpc_url: &str,
 	database_url: &str,
+	max_request_size: u32,
+	max_response_size: u32,
 	abort_signal: Signals,
 ) -> anyhow::Result<Client> {
 	let fut = async {
-		let (api, rpc_client, rpc) = connect(node_rpc_url).await?;
+		let (api, rpc_client, rpc) = connect(node_rpc_url, max_request_size, max_response_size).await?;
 		let block_provider = SubxtBlockInfoProvider::new( api.clone(), rpc.clone()).await?;
 
 		let (pool, keep_latest_n_blocks) = if database_url == IN_MEMORY_DB {
@@ -213,6 +215,8 @@ pub fn run(cmd: CliCommand) -> anyhow::Result<()> {
 		earliest_receipt_block,
 		&node_rpc_url,
 		&database_url,
+		rpc_config.max_request_size * 1024 * 1024,
+		rpc_config.max_response_size * 1024 * 1024,
 		tokio_runtime.block_on(async { Signals::capture() })?,
 	)?;
 

substrate/frame/revive/rpc/src/client.rs

@@ -209,11 +209,15 @@ async fn get_automine(rpc_client: &RpcClient) -> bool {
 /// clients.
 pub async fn connect(
 	node_rpc_url: &str,
+	max_request_size: u32,
+	max_response_size: u32,
 ) -> Result<(OnlineClient<SrcChainConfig>, RpcClient, LegacyRpcMethods<SrcChainConfig>), ClientError>
 {
 	log::info!(target: LOG_TARGET, "🌐 Connecting to node at: {node_rpc_url} ...");
 	let rpc_client = ReconnectingRpcClient::builder()
 		.retry_policy(ExponentialBackoff::from_millis(100).max_delay(Duration::from_secs(10)))
+		.max_request_size(max_request_size)
+		.max_response_size(max_response_size)
 		.build(node_rpc_url.to_string())
 		.await?;
 	let rpc_client = RpcClient::new(rpc_client);

substrate/frame/revive/rpc/src/tests.rs

@@ -486,7 +486,7 @@ async fn get_evm_block_from_storage(
 
 async fn test_evm_blocks_should_match(client: Arc<WsClient>) -> anyhow::Result<()> {
 	let (node_client, node_rpc_client, _) =
-		client::connect(SharedResources::node_rpc_url()).await.unwrap();
+		client::connect(SharedResources::node_rpc_url(), 1024, 1024).await.unwrap();
 
 	// Deploy a contract to have some interesting blocks
 	let (bytes, _) = pallet_revive_fixtures::compile_module("dummy")?;
@@ -705,7 +705,8 @@ async fn test_mixed_evm_substrate_transactions(client: Arc<WsClient>) -> anyhow:
 	// Prepare substrate transactions (simple remarks)
 	log::trace!(target: LOG_TARGET, "Creating {num_substrate_txs} substrate remark transactions");
 	let alice_signer = subxt_signer::sr25519::dev::alice();
-	let (node_client, _, _) = client::connect(SharedResources::node_rpc_url()).await.unwrap();
+	let (node_client, _, _) =
+		client::connect(SharedResources::node_rpc_url(), 1024, 1024).await.unwrap();
 
 	let substrate_txs =
 		prepare_substrate_transactions(&node_client, &alice_signer, num_substrate_txs).await?;
@@ -736,7 +737,7 @@ async fn test_mixed_evm_substrate_transactions(client: Arc<WsClient>) -> anyhow:
 
 async fn test_runtime_pallets_address_upload_code(client: Arc<WsClient>) -> anyhow::Result<()> {
 	let (node_client, node_rpc_client, _) =
-		client::connect(SharedResources::node_rpc_url()).await?;
+		client::connect(SharedResources::node_rpc_url(), 1024, 1024).await?;
 
 	let (bytecode, _) = pallet_revive_fixtures::compile_module("dummy")?;
 	let signer = Account::default();

substrate/frame/revive/src/debug.rs

@@ -36,6 +36,8 @@ use Debug;
 	Deserialize,
 )]
 pub struct DebugSettings {
+	/// Whether to disable execution tracing.
+	disable_execution_tracing: bool,
 	/// Whether to allow unlimited contract size.
 	allow_unlimited_contract_size: bool,
 	/// Whether to allow bypassing EIP-3607 (allowing transactions coming from contract or
@@ -46,8 +48,20 @@ pub struct DebugSettings {
 }
 
 impl DebugSettings {
-	pub fn new(allow_unlimited_contract_size: bool, bypass_eip_3607: bool, pvm_logs: bool) -> Self {
-		Self { allow_unlimited_contract_size, bypass_eip_3607, pvm_logs }
+	#[cfg(test)]
+	pub fn set_bypass_eip_3607(mut self, value: bool) -> Self {
+		self.bypass_eip_3607 = value;
+		self
+	}
+
+	#[cfg(test)]
+	pub fn set_allow_unlimited_contract_size(mut self, value: bool) -> Self {
+		self.allow_unlimited_contract_size = value;
+		self
+	}
+
+	pub fn is_execution_tracing_enabled<T: Config>() -> bool {
+		T::DebugEnabled::get() && !DebugSettingsOf::<T>::get().disable_execution_tracing
 	}
 
 	/// Returns true if unlimited contract size is allowed.

substrate/frame/revive/src/evm/api/byte.rs

@@ -75,6 +75,17 @@ impl Bytes {
 	pub fn is_empty(&self) -> bool {
 		self.0.is_empty()
 	}
+
+	/// Convert to minimal hex format without padding 0s
+	pub fn to_short_hex(&self) -> alloc::string::String {
+		let word = sp_core::U256::from_big_endian(&self.0);
+		alloc::format!("0x{:x}", word)
+	}
+
+	/// Convert to hex format without "0x" prefix
+	pub fn to_hex_no_prefix(&self) -> alloc::string::String {
+		alloy_core::hex::encode(&self.0)
+	}
 }
 
 impl_hex!(Byte, u8, 0u8);
@@ -83,6 +94,18 @@ impl_hex!(Bytes8, [u8; 8], [0u8; 8]);
 impl_hex!(Bytes32, [u8; 32], [0u8; 32]);
 impl_hex!(Bytes256, [u8; 256], [0u8; 256]);
 
+#[test]
+fn test_to_short_hex() {
+	let bytes = Bytes(crate::U256::from(4).to_big_endian().to_vec());
+	assert_eq!(bytes.to_short_hex(), "0x4");
+}
+
+#[test]
+fn test_to_hex_no_prefix() {
+	let bytes = Bytes(vec![0x12, 0x34, 0x56, 0x78]);
+	assert_eq!(bytes.to_hex_no_prefix(), "12345678");
+}
+
 #[test]
 fn serialize_works() {
 	let a = Byte(42);