[pallet-revive] fix call-trace create calls (#8781)

Fix call-traces for CREATE calls.

these types of calls have a "CREATE" and "CREATE2" type see
https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers#call-tracer

The input of these trace, should also contain the bytecode or code hash.

fixes paritytech/contract-issues#96

---------

Co-authored-by: cmd[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: 2 people

prdoc/pr_8781.prdoc

@@ -0,0 +1,14 @@
+title: '[pallet-revive] fix call-trace create calls'
+doc:
+- audience: Runtime Dev
+  description: |-
+    Fix call-traces for CREATE calls.
+
+    fixes https://github.com/paritytech/contract-issues/issues/96
+crates:
+- name: pallet-revive-fixtures
+  bump: patch
+- name: pallet-revive
+  bump: patch
+- name: pallet-revive-eth-rpc
+  bump: patch

substrate/frame/revive/fixtures/contracts/create2_with_value.rs

@@ -0,0 +1,49 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![no_std]
+#![no_main]
+include!("../panic_handler.rs");
+
+use uapi::{input, HostFn, HostFnImpl as api};
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+	input!(128, code_hash: [u8],);
+
+	let mut value = [0; 32];
+	api::value_transferred(&mut value);
+
+	// Deploy the contract with salt (equivalent to create2).
+	let salt = [1u8; 32];
+	api::instantiate(
+		u64::MAX,
+		u64::MAX,
+		&[u8::MAX; 32],
+		&value,
+		code_hash,
+		None,
+		None,
+		Some(&salt),
+	)
+	.unwrap();
+}

substrate/frame/revive/rpc/revive_chain.metadata

@@ -113,11 +113,10 @@ impl RuntimeApi {
 		transaction_index: u32,
 		tracer_type: crate::TracerType,
 	) -> Result<Trace, ClientError> {
-		let payload = subxt_client::apis().revive_api().trace_tx(
-			block.into(),
-			transaction_index,
-			tracer_type.into(),
-		);
+		let payload = subxt_client::apis()
+			.revive_api()
+			.trace_tx(block.into(), transaction_index, tracer_type.into())
+			.unvalidated();
 
 		let trace = self.0.call(payload).await?.ok_or(ClientError::EthExtrinsicNotFound)?.0;
 		Ok(trace)
@@ -132,8 +131,10 @@ impl RuntimeApi {
 		>,
 		tracer_type: crate::TracerType,
 	) -> Result<Vec<(u32, Trace)>, ClientError> {
-		let payload =
-			subxt_client::apis().revive_api().trace_block(block.into(), tracer_type.into());
+		let payload = subxt_client::apis()
+			.revive_api()
+			.trace_block(block.into(), tracer_type.into())
+			.unvalidated();
 
 		let traces = self.0.call(payload).await?.into_iter().map(|(idx, t)| (idx, t.0)).collect();
 		Ok(traces)
@@ -147,7 +148,8 @@ impl RuntimeApi {
 	) -> Result<Trace, ClientError> {
 		let payload = subxt_client::apis()
 			.revive_api()
-			.trace_call(transaction.into(), tracer_type.into());
+			.trace_call(transaction.into(), tracer_type.into())
+			.unvalidated();
 
 		let trace = self.0.call(payload).await?.map_err(|err| ClientError::TransactError(err.0))?;
 		Ok(trace.0)

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

@@ -159,6 +159,10 @@ pub enum CallType {
 	StaticCall,
 	/// A delegate call.
 	DelegateCall,
+	/// A create call.
+	Create,
+	/// A create2 call.
+	Create2,
 }
 
 /// A Trace

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

@@ -18,7 +18,7 @@ use crate::{
 	evm::{decode_revert_reason, CallLog, CallTrace, CallTracerConfig, CallType},
 	primitives::ExecReturnValue,
 	tracing::Tracing,
-	DispatchError, Weight,
+	Code, DispatchError, Weight,
 };
 use alloc::{format, string::ToString, vec::Vec};
 use sp_core::{H160, H256, U256};
@@ -32,14 +32,22 @@ pub struct CallTracer<Gas, GasMapper> {
 	traces: Vec<CallTrace<Gas>>,
 	/// Stack of indices to the current active traces.
 	current_stack: Vec<usize>,
+	/// The code and salt used to instantiate the next contract.
+	code_with_salt: Option<(Code, bool)>,
 	/// The tracer configuration.
 	config: CallTracerConfig,
 }
 
 impl<Gas, GasMapper> CallTracer<Gas, GasMapper> {
 	/// Create a new [`CallTracer`] instance.
 	pub fn new(config: CallTracerConfig, gas_mapper: GasMapper) -> Self {
-		Self { gas_mapper, traces: Vec::new(), current_stack: Vec::new(), config }
+		Self {
+			gas_mapper,
+			traces: Vec::new(),
+			code_with_salt: None,
+			current_stack: Vec::new(),
+			config,
+		}
 	}
 
 	/// Collect the traces and return them.
@@ -49,6 +57,10 @@ impl<Gas, GasMapper> CallTracer<Gas, GasMapper> {
 }
 
 impl<Gas: Default, GasMapper: Fn(Weight) -> Gas> Tracing for CallTracer<Gas, GasMapper> {
+	fn instantiate_code(&mut self, code: &Code, salt: Option<&[u8; 32]>) {
+		self.code_with_salt = Some((code.clone(), salt.is_some()));
+	}
+
 	fn enter_child_span(
 		&mut self,
 		from: H160,
@@ -60,20 +72,36 @@ impl<Gas: Default, GasMapper: Fn(Weight) -> Gas> Tracing for CallTracer<Gas, Gas
 		gas_left: Weight,
 	) {
 		if self.traces.is_empty() || !self.config.only_top_call {
-			let call_type = if is_read_only {
-				CallType::StaticCall
-			} else if is_delegate_call {
-				CallType::DelegateCall
-			} else {
-				CallType::Call
+			let (call_type, input) = match self.code_with_salt.take() {
+				Some((Code::Upload(v), salt)) => (
+					if salt { CallType::Create2 } else { CallType::Create },
+					v.into_iter().chain(input.to_vec().into_iter()).collect::<Vec<_>>(),
+				),
+				Some((Code::Existing(v), salt)) => (
+					if salt { CallType::Create2 } else { CallType::Create },
+					v.to_fixed_bytes()
+						.into_iter()
+						.chain(input.to_vec().into_iter())
+						.collect::<Vec<_>>(),
+				),
+				None => {
+					let call_type = if is_read_only {
+						CallType::StaticCall
+					} else if is_delegate_call {
+						CallType::DelegateCall
+					} else {
+						CallType::Call
+					};
+					(call_type, input.to_vec())
+				},
 			};
 
 			self.traces.push(CallTrace {
 				from,
 				to,
 				value: if is_read_only { None } else { Some(value) },
 				call_type,
-				input: input.to_vec().into(),
+				input: input.into(),
 				gas: (self.gas_mapper)(gas_left),
 				..Default::default()
 			});
@@ -102,6 +130,8 @@ impl<Gas: Default, GasMapper: Fn(Weight) -> Gas> Tracing for CallTracer<Gas, Gas
 	}
 
 	fn exit_child_span(&mut self, output: &ExecReturnValue, gas_used: Weight) {
+		self.code_with_salt = None;
+
 		// Set the output of the current trace
 		let current_index = self.current_stack.pop().unwrap();
 
@@ -126,6 +156,8 @@ impl<Gas: Default, GasMapper: Fn(Weight) -> Gas> Tracing for CallTracer<Gas, Gas
 		}
 	}
 	fn exit_child_span_with_error(&mut self, error: DispatchError, gas_used: Weight) {
+		self.code_with_salt = None;
+
 		// Set the output of the current trace
 		let current_index = self.current_stack.pop().unwrap();
 

substrate/frame/revive/src/evm/tracing/call_tracing.rs

@@ -1690,6 +1690,7 @@ where
 			self.is_read_only(),
 		)?;
 		let address = T::AddressMapper::to_address(&self.top_frame().account_id);
+		if_tracing(|t| t.instantiate_code(&crate::Code::Existing(code_hash), salt));
 		self.run(executable.expect(FRAME_ALWAYS_EXISTS_ON_INSTANTIATE), input_data, BumpNonce::Yes)
 			.map(|_| address)
 	}

substrate/frame/revive/src/exec.rs

@@ -50,6 +50,7 @@ use crate::{
 	exec::{AccountIdOf, ExecError, Executable, Key, Stack as ExecStack},
 	gas::GasMeter,
 	storage::{meter::Meter as StorageMeter, ContractInfo, DeletionQueueManager},
+	tracing::if_tracing,
 	vm::{CodeInfo, ContractBlob, RuntimeCosts},
 };
 use alloc::{boxed::Box, format, vec};
@@ -1113,6 +1114,8 @@ where
 
 		let try_instantiate = || {
 			let instantiate_account = T::InstantiateOrigin::ensure_origin(origin.clone())?;
+
+			if_tracing(|t| t.instantiate_code(&code, salt.as_ref()));
 			let (executable, upload_deposit) = match code {
 				Code::Upload(code) => {
 					let upload_account = T::UploadOrigin::ensure_origin(origin)?;

substrate/frame/revive/src/lib.rs

@@ -4220,6 +4220,66 @@ fn call_tracing_works() {
 	});
 }
 
+#[test]
+fn create_call_tracing_works() {
+	use crate::evm::*;
+	let (code, code_hash) = compile_module("create2_with_value").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 100_000_000);
+
+		let mut tracer = CallTracer::new(Default::default(), |_| U256::zero());
+
+		let Contract { addr, .. } = trace(&mut tracer, || {
+			builder::bare_instantiate(Code::Upload(code.clone()))
+				.value(100)
+				.salt(None)
+				.build_and_unwrap_contract()
+		});
+
+		let call_trace = tracer.collect_trace().unwrap();
+		assert_eq!(
+			call_trace,
+			CallTrace {
+				from: ALICE_ADDR,
+				to: addr,
+				value: Some(100.into()),
+				input: Bytes(code.clone()),
+				call_type: CallType::Create,
+				..Default::default()
+			}
+		);
+
+		let mut tracer = CallTracer::new(Default::default(), |_| U256::zero());
+		let data = b"garbage";
+		let input = (code_hash, data).encode();
+		trace(&mut tracer, || {
+			assert_ok!(builder::call(addr).data(input.clone()).build());
+		});
+
+		let call_trace = tracer.collect_trace().unwrap();
+		let child_addr = crate::address::create2(&addr, &code, data, &[1u8; 32]);
+
+		assert_eq!(
+			call_trace,
+			CallTrace {
+				from: ALICE_ADDR,
+				to: addr,
+				value: Some(0.into()),
+				input: input.clone().into(),
+				calls: vec![CallTrace {
+					from: addr,
+					input: input.clone().into(),
+					to: child_addr,
+					value: Some(0.into()),
+					call_type: CallType::Create2,
+					..Default::default()
+				},],
+				..Default::default()
+			}
+		);
+	});
+}
+
 #[test]
 fn prestate_tracing_works() {
 	use crate::evm::*;

substrate/frame/revive/src/tests.rs

@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{primitives::ExecReturnValue, DispatchError, Key, Weight};
+use crate::{primitives::ExecReturnValue, Code, DispatchError, Key, Weight};
 use alloc::vec::Vec;
 use environmental::environmental;
 use sp_core::{H160, H256, U256};
@@ -57,6 +57,10 @@ pub trait Tracing {
 		_gas: Weight,
 	) {
 	}
+
+	/// Record the next code and salt to be instantiated.
+	fn instantiate_code(&mut self, _code: &Code, _salt: Option<&[u8; 32]>) {}
+
 	/// Called when a balance is read
 	fn balance_read(&mut self, _addr: &H160, _value: U256) {}