Contracts: Refactor test builder (#4158)

- Moved `substrate/frame/contracts/src/tests/builder.rs` into a pub
test_utils module, so we can use that in the
`pallet-contracts-mock-network` tests
- Refactor xcm tests to use XCM builders, and simplify the use case for
xcm-send

substrate/frame/contracts/mock-network/src/lib.rs

@@ -23,6 +23,7 @@ pub mod relay_chain;
 mod tests;
 
 use crate::primitives::{AccountId, UNITS};
+pub use pallet_contracts::test_utils::{ALICE, BOB};
 use sp_runtime::BuildStorage;
 use xcm::latest::prelude::*;
 use xcm_executor::traits::ConvertLocation;
@@ -31,8 +32,6 @@ use xcm_simulator::{decl_test_network, decl_test_parachain, decl_test_relay_chai
 
 // Accounts
 pub const ADMIN: sp_runtime::AccountId32 = sp_runtime::AccountId32::new([0u8; 32]);
-pub const ALICE: sp_runtime::AccountId32 = sp_runtime::AccountId32::new([1u8; 32]);
-pub const BOB: sp_runtime::AccountId32 = sp_runtime::AccountId32::new([2u8; 32]);
 
 // Balances
 pub const INITIAL_BALANCE: u128 = 1_000_000_000 * UNITS;

substrate/frame/contracts/mock-network/src/tests.rs

@@ -22,45 +22,31 @@ use crate::{
 	relay_chain, MockNet, ParaA, ParachainBalances, Relay, ALICE, BOB, INITIAL_BALANCE,
 };
 use codec::{Decode, Encode};
-use frame_support::{
+use frame_support::traits::{fungibles::Mutate, Currency};
-	pallet_prelude::Weight,
+use pallet_contracts::{test_utils::builder::*, Code};
-	traits::{fungibles::Mutate, Currency},
-};
-use pallet_balances::{BalanceLock, Reasons};
-use pallet_contracts::{Code, CollectEvents, DebugInfo, Determinism};
 use pallet_contracts_fixtures::compile_module;
 use pallet_contracts_uapi::ReturnErrorCode;
 use xcm::{v4::prelude::*, VersionedLocation, VersionedXcm};
 use xcm_simulator::TestExt;
 
-type ParachainContracts = pallet_contracts::Pallet<parachain::Runtime>;
-
 macro_rules! assert_return_code {
 	( $x:expr , $y:expr $(,)? ) => {{
 		assert_eq!(u32::from_le_bytes($x.data[..].try_into().unwrap()), $y as u32);
 	}};
 }
 
+fn bare_call(dest: sp_runtime::AccountId32) -> BareCallBuilder<parachain::Runtime> {
+	BareCallBuilder::<parachain::Runtime>::bare_call(ALICE, dest)
+}
+
 /// Instantiate the tests contract, and fund it with some balance and assets.
 fn instantiate_test_contract(name: &str) -> AccountId {
 	let (wasm, _) = compile_module::<Runtime>(name).unwrap();
 
 	// Instantiate contract.
 	let contract_addr = ParaA::execute_with(|| {
-		ParachainContracts::bare_instantiate(
+		BareInstantiateBuilder::<parachain::Runtime>::bare_instantiate(ALICE, Code::Upload(wasm))
-			ALICE,
+			.build_and_unwrap_account_id()
-			0,
-			Weight::MAX,
-			None,
-			Code::Upload(wasm),
-			vec![],
-			vec![],
-			DebugInfo::UnsafeDebug,
-			CollectEvents::Skip,
-		)
-		.result
-		.unwrap()
-		.account_id
 	});
 
 	// Funds contract account with some balance and assets.
@@ -85,27 +71,18 @@ fn test_xcm_execute() {
 	// Execute XCM instructions through the contract.
 	ParaA::execute_with(|| {
 		let amount: u128 = 10 * CENTS;
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: BOB.clone().into() };
 
 		// The XCM used to transfer funds to Bob.
-		let message: Xcm<()> = Xcm(vec![
+		let message: Xcm<()> = Xcm::builder_unsafe()
-			WithdrawAsset(vec![(Here, amount).into()].into()),
+			.withdraw_asset(assets.clone())
-			DepositAsset {
+			.deposit_asset(assets, beneficiary)
-				assets: All.into(),
+			.build();
-				beneficiary: AccountId32 { network: None, id: BOB.clone().into() }.into(),
-			},
-		]);
 
-		let result = ParachainContracts::bare_call(
+		let result = bare_call(contract_addr.clone())
-			ALICE,
+			.data(VersionedXcm::V4(message).encode().encode())
-			contract_addr.clone(),
+			.build();
-			0,
-			Weight::MAX,
-			None,
-			VersionedXcm::V4(message).encode().encode(),
-			DebugInfo::UnsafeDebug,
-			CollectEvents::UnsafeCollect,
-			Determinism::Enforced,
-		);
 
 		assert_eq!(result.gas_consumed, result.gas_required);
 		assert_return_code!(&result.result.unwrap(), ReturnErrorCode::Success);
@@ -127,29 +104,22 @@ fn test_xcm_execute_incomplete() {
 
 	// Execute XCM instructions through the contract.
 	ParaA::execute_with(|| {
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: BOB.clone().into() };
+
 		// The XCM used to transfer funds to Bob.
-		let message: Xcm<()> = Xcm(vec![
+		let message: Xcm<()> = Xcm::builder_unsafe()
-			WithdrawAsset(vec![(Here, amount).into()].into()),
+			.withdraw_asset(assets.clone())
 			// This will fail as the contract does not have enough balance to complete both
 			// withdrawals.
-			WithdrawAsset(vec![(Here, INITIAL_BALANCE).into()].into()),
+			.withdraw_asset((Here, INITIAL_BALANCE))
-			DepositAsset {
+			.buy_execution(assets.clone(), Unlimited)
-				assets: All.into(),
+			.deposit_asset(assets, beneficiary)
-				beneficiary: AccountId32 { network: None, id: BOB.clone().into() }.into(),
+			.build();
-			},
-		]);
 
-		let result = ParachainContracts::bare_call(
+		let result = bare_call(contract_addr.clone())
-			ALICE,
+			.data(VersionedXcm::V4(message).encode().encode())
-			contract_addr.clone(),
+			.build();
-			0,
-			Weight::MAX,
-			None,
-			VersionedXcm::V4(message).encode().encode(),
-			DebugInfo::UnsafeDebug,
-			CollectEvents::UnsafeCollect,
-			Determinism::Enforced,
-		);
 
 		assert_eq!(result.gas_consumed, result.gas_required);
 		assert_return_code!(&result.result.unwrap(), ReturnErrorCode::XcmExecutionFailed);
@@ -175,28 +145,16 @@ fn test_xcm_execute_reentrant_call() {
 		});
 
 		// The XCM used to transfer funds to Bob.
-		let message: Xcm<parachain::RuntimeCall> = Xcm(vec![
+		let message: Xcm<parachain::RuntimeCall> = Xcm::builder_unsafe()
-			Transact {
+			.transact(OriginKind::Native, 1_000_000_000, transact_call.encode())
-				origin_kind: OriginKind::Native,
+			.expect_transact_status(MaybeErrorCode::Success)
-				require_weight_at_most: 1_000_000_000.into(),
+			.build();
-				call: transact_call.encode().into(),
-			},
-			ExpectTransactStatus(MaybeErrorCode::Success),
-		]);
 
-		let result = ParachainContracts::bare_call(
+		let result = bare_call(contract_addr.clone())
-			ALICE,
+			.data(VersionedXcm::V4(message).encode().encode())
-			contract_addr.clone(),
+			.build_and_unwrap_result();
-			0,
-			Weight::MAX,
-			None,
-			VersionedXcm::V4(message).encode().encode(),
-			DebugInfo::UnsafeDebug,
-			CollectEvents::UnsafeCollect,
-			Determinism::Enforced,
-		);
 
-		assert_return_code!(&result.result.unwrap(), ReturnErrorCode::XcmExecutionFailed);
+		assert_return_code!(&result, ReturnErrorCode::XcmExecutionFailed);
 
 		// Funds should not change hands as the XCM transact failed.
 		assert_eq!(ParachainBalances::free_balance(BOB), INITIAL_BALANCE);
@@ -207,40 +165,36 @@ fn test_xcm_execute_reentrant_call() {
 fn test_xcm_send() {
 	MockNet::reset();
 	let contract_addr = instantiate_test_contract("xcm_send");
+	let amount = 1_000 * CENTS;
 	let fee = parachain::estimate_message_fee(4); // Accounts for the `DescendOrigin` instruction added by `send_xcm`
 
-	// Send XCM instructions through the contract, to lock some funds on the relay chain.
+	// Send XCM instructions through the contract, to transfer some funds from the contract
+	// derivative account to Alice on the relay chain.
 	ParaA::execute_with(|| {
-		let dest = Location::from(Parent);
+		let dest = VersionedLocation::V4(Parent.into());
-		let dest = VersionedLocation::V4(dest);
+		let assets: Asset = (Here, amount).into();
+		let beneficiary = AccountId32 { network: None, id: ALICE.clone().into() };
 
-		let message: Xcm<()> = Xcm(vec![
+		let message: Xcm<()> = Xcm::builder()
-			WithdrawAsset((Here, fee).into()),
+			.withdraw_asset(assets.clone())
-			BuyExecution { fees: (Here, fee).into(), weight_limit: WeightLimit::Unlimited },
+			.buy_execution((Here, fee), Unlimited)
-			LockAsset { asset: (Here, 5 * CENTS).into(), unlocker: (Parachain(1)).into() },
+			.deposit_asset(assets, beneficiary)
-		]);
+			.build();
-		let message = VersionedXcm::V4(message);
-		let exec = ParachainContracts::bare_call(
-			ALICE,
-			contract_addr.clone(),
-			0,
-			Weight::MAX,
-			None,
-			(dest, message.encode()).encode(),
-			DebugInfo::UnsafeDebug,
-			CollectEvents::UnsafeCollect,
-			Determinism::Enforced,
-		);
 
-		let mut data = &exec.result.unwrap().data[..];
+		let result = bare_call(contract_addr.clone())
+			.data((dest, VersionedXcm::V4(message).encode()).encode())
+			.build_and_unwrap_result();
+
+		let mut data = &result.data[..];
 		XcmHash::decode(&mut data).expect("Failed to decode xcm_send message_id");
 	});
 
 	Relay::execute_with(|| {
-		// Check if the funds are locked on the relay chain.
+		let derived_contract_addr = &parachain_account_sovereign_account_id(1, contract_addr);
 		assert_eq!(
-			relay_chain::Balances::locks(&parachain_account_sovereign_account_id(1, contract_addr)),
+			INITIAL_BALANCE - amount,
-			vec![BalanceLock { id: *b"py/xcmlk", amount: 5 * CENTS, reasons: Reasons::All }]
+			relay_chain::Balances::free_balance(derived_contract_addr)
 		);
+		assert_eq!(INITIAL_BALANCE + amount - fee, relay_chain::Balances::free_balance(ALICE));
 	});
 }

substrate/frame/contracts/src/lib.rs

@@ -101,6 +101,7 @@ mod wasm;
 pub mod chain_extension;
 pub mod debug;
 pub mod migration;
+pub mod test_utils;
 pub mod weights;
 
 #[cfg(test)]

substrate/frame/contracts/src/test_utils.rs

@@ -0,0 +1,30 @@
+// 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.
+
+//! Shared utilities for testing contracts.
+//! This is not part of the tests module because it is made public for other crates to use.
+#![cfg(feature = "std")]
+use frame_support::weights::Weight;
+pub use sp_runtime::AccountId32;
+
+pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
+pub const BOB: AccountId32 = AccountId32::new([2u8; 32]);
+pub const CHARLIE: AccountId32 = AccountId32::new([3u8; 32]);
+pub const DJANGO: AccountId32 = AccountId32::new([4u8; 32]);
+
+pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 1024);
+pub mod builder;

substrate/frame/contracts/src/test_utils/builder.rs

@@ -0,0 +1,220 @@
+// 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.
+
+use super::GAS_LIMIT;
+use crate::{
+	AccountIdLookupOf, AccountIdOf, BalanceOf, Code, CodeHash, CollectEvents, Config,
+	ContractExecResult, ContractInstantiateResult, DebugInfo, Determinism, EventRecordOf,
+	ExecReturnValue, InstantiateReturnValue, OriginFor, Pallet, Weight,
+};
+use codec::{Encode, HasCompact};
+use core::fmt::Debug;
+use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+use paste::paste;
+use scale_info::TypeInfo;
+
+/// Helper macro to generate a builder for contract API calls.
+macro_rules! builder {
+	// Entry point to generate a builder for the given method.
+	(
+		$method:ident($($field:ident: $type:ty,)*) -> $result:ty;
+        $($extra:item)*
+	) => {
+		paste!{
+			builder!([< $method:camel Builder >], $method($($field: $type,)* ) -> $result; $($extra)*);
+		}
+	};
+	// Generate the builder struct and its methods.
+	(
+		$name:ident,
+		$method:ident($($field:ident: $type:ty,)*) -> $result:ty;
+        $($extra:item)*
+	) => {
+		#[doc = concat!("A builder to construct a ", stringify!($method), " call")]
+		pub struct $name<T: Config> {
+			$($field: $type,)*
+		}
+
+		#[allow(dead_code)]
+		impl<T: Config> $name<T>
+		where
+			<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
+		{
+			$(
+				#[doc = concat!("Set the ", stringify!($field))]
+				pub fn $field(mut self, value: $type) -> Self {
+					self.$field = value;
+					self
+				}
+			)*
+
+			#[doc = concat!("Build the ", stringify!($method), " call")]
+			pub fn build(self) -> $result {
+				Pallet::<T>::$method(
+					$(self.$field,)*
+				)
+			}
+
+            $($extra)*
+		}
+	}
+}
+
+builder!(
+	instantiate_with_code(
+		origin: OriginFor<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		code: Vec<u8>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create an [`InstantiateWithCodeBuilder`] with default values.
+	pub fn instantiate_with_code(origin: OriginFor<T>, code: Vec<u8>) -> Self {
+		Self {
+			origin: origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code,
+			data: vec![],
+			salt: vec![],
+		}
+	}
+);
+
+builder!(
+	instantiate(
+		origin: OriginFor<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		code_hash: CodeHash<T>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create an [`InstantiateBuilder`] with default values.
+	pub fn instantiate(origin: OriginFor<T>, code_hash: CodeHash<T>) -> Self {
+		Self {
+			origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code_hash,
+			data: vec![],
+			salt: vec![],
+		}
+	}
+);
+
+builder!(
+	bare_instantiate(
+		origin: AccountIdOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		code: Code<CodeHash<T>>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+	) -> ContractInstantiateResult<AccountIdOf<T>, BalanceOf<T>, EventRecordOf<T>>;
+
+	/// Build the instantiate call and unwrap the result.
+	pub fn build_and_unwrap_result(self) -> InstantiateReturnValue<AccountIdOf<T>> {
+		self.build().result.unwrap()
+	}
+
+	/// Build the instantiate call and unwrap the account id.
+	pub fn build_and_unwrap_account_id(self) -> AccountIdOf<T> {
+		self.build().result.unwrap().account_id
+	}
+
+	pub fn bare_instantiate(origin: AccountIdOf<T>, code: Code<CodeHash<T>>) -> Self {
+		Self {
+			origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code,
+			data: vec![],
+			salt: vec![],
+			debug: DebugInfo::Skip,
+			collect_events: CollectEvents::Skip,
+		}
+	}
+);
+
+builder!(
+	call(
+		origin: OriginFor<T>,
+		dest: AccountIdLookupOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		data: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create a [`CallBuilder`] with default values.
+	pub fn call(origin: OriginFor<T>, dest: AccountIdLookupOf<T>) -> Self {
+		CallBuilder {
+			origin,
+			dest,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			data: vec![],
+		}
+	}
+);
+
+builder!(
+	bare_call(
+		origin: AccountIdOf<T>,
+		dest: AccountIdOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		data: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+		determinism: Determinism,
+	) -> ContractExecResult<BalanceOf<T>, EventRecordOf<T>>;
+
+	/// Build the call and unwrap the result.
+	pub fn build_and_unwrap_result(self) -> ExecReturnValue {
+		self.build().result.unwrap()
+	}
+
+	/// Create a [`BareCallBuilder`] with default values.
+	pub fn bare_call(origin: AccountIdOf<T>, dest: AccountIdOf<T>) -> Self {
+		Self {
+			origin,
+			dest,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			data: vec![],
+			debug: DebugInfo::Skip,
+			collect_events: CollectEvents::Skip,
+			determinism: Determinism::Enforced,
+		}
+	}
+);

substrate/frame/contracts/src/tests.rs

@@ -15,7 +15,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod builder;
 mod pallet_dummy;
 mod test_debug;
 
@@ -98,7 +97,6 @@ macro_rules! assert_refcount {
 }
 
 pub mod test_utils {
-
 	use super::{Contracts, DepositPerByte, DepositPerItem, Hash, SysConfig, Test};
 	use crate::{
 		exec::AccountIdOf, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo,
@@ -166,6 +164,38 @@ pub mod test_utils {
 	}
 }
 
+mod builder {
+	use super::Test;
+	use crate::{
+		test_utils::{builder::*, AccountId32, ALICE},
+		tests::RuntimeOrigin,
+		AccountIdLookupOf, Code, CodeHash,
+	};
+
+	pub fn bare_instantiate(code: Code<CodeHash<Test>>) -> BareInstantiateBuilder<Test> {
+		BareInstantiateBuilder::<Test>::bare_instantiate(ALICE, code)
+	}
+
+	pub fn bare_call(dest: AccountId32) -> BareCallBuilder<Test> {
+		BareCallBuilder::<Test>::bare_call(ALICE, dest)
+	}
+
+	pub fn instantiate_with_code(code: Vec<u8>) -> InstantiateWithCodeBuilder<Test> {
+		InstantiateWithCodeBuilder::<Test>::instantiate_with_code(
+			RuntimeOrigin::signed(ALICE),
+			code,
+		)
+	}
+
+	pub fn instantiate(code_hash: CodeHash<Test>) -> InstantiateBuilder<Test> {
+		InstantiateBuilder::<Test>::instantiate(RuntimeOrigin::signed(ALICE), code_hash)
+	}
+
+	pub fn call(dest: AccountIdLookupOf<Test>) -> CallBuilder<Test> {
+		CallBuilder::<Test>::call(RuntimeOrigin::signed(ALICE), dest)
+	}
+}
+
 impl Test {
 	pub fn set_unstable_interface(unstable_interface: bool) {
 		UNSTABLE_INTERFACE.with(|v| *v.borrow_mut() = unstable_interface);
@@ -2439,14 +2469,7 @@ fn failed_deposit_charge_should_roll_back_call() {
 				transfer_proxy_call,
 			);
 
-			<Pallet<Test>>::call(
+			builder::call(addr_caller).data(data.encode()).build()
-				RuntimeOrigin::signed(ALICE),
-				addr_caller.clone(),
-				0,
-				GAS_LIMIT,
-				None,
-				data.encode(),
-			)
 		})
 	};
 

substrate/frame/contracts/src/tests/builder.rs

@@ -1,219 +0,0 @@
-// 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.
-
-use super::{AccountId32, Test, ALICE, GAS_LIMIT};
-use crate::{
-	tests::RuntimeOrigin, AccountIdLookupOf, AccountIdOf, BalanceOf, Code, CodeHash, CollectEvents,
-	ContractExecResult, ContractInstantiateResult, DebugInfo, Determinism, EventRecordOf,
-	ExecReturnValue, OriginFor, Pallet, Weight,
-};
-use codec::Compact;
-use frame_support::pallet_prelude::DispatchResultWithPostInfo;
-use paste::paste;
-
-/// Helper macro to generate a builder for contract API calls.
-macro_rules! builder {
-	// Entry point to generate a builder for the given method.
-	(
-		$method:ident($($field:ident: $type:ty,)*) -> $result:ty
-	) => {
-		paste!{
-			builder!([< $method:camel Builder >], $method($($field: $type,)* ) -> $result);
-		}
-	};
-	// Generate the builder struct and its methods.
-	(
-		$name:ident,
-		$method:ident(
-			$($field:ident: $type:ty,)*
-		) -> $result:ty
-	) => {
-		#[doc = concat!("A builder to construct a ", stringify!($method), " call")]
-		pub struct $name {
-			$($field: $type,)*
-		}
-
-		#[allow(dead_code)]
-		impl $name
-		{
-			$(
-				#[doc = concat!("Set the ", stringify!($field))]
-				pub fn $field(mut self, value: $type) -> Self {
-					self.$field = value;
-					self
-				}
-			)*
-
-			#[doc = concat!("Build the ", stringify!($method), " call")]
-			pub fn build(self) -> $result {
-				Pallet::<Test>::$method(
-					$(self.$field,)*
-				)
-			}
-		}
-	}
-}
-
-builder!(
-	instantiate_with_code(
-		origin: OriginFor<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		code: Vec<u8>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	instantiate(
-		origin: OriginFor<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		code_hash: CodeHash<Test>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	bare_instantiate(
-		origin: AccountIdOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<BalanceOf<Test>>,
-		code: Code<CodeHash<Test>>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-		debug: DebugInfo,
-		collect_events: CollectEvents,
-	) -> ContractInstantiateResult<AccountIdOf<Test>, BalanceOf<Test>, EventRecordOf<Test>>
-);
-
-builder!(
-	call(
-		origin: OriginFor<Test>,
-		dest: AccountIdLookupOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		data: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	bare_call(
-		origin: AccountIdOf<Test>,
-		dest: AccountIdOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<BalanceOf<Test>>,
-		data: Vec<u8>,
-		debug: DebugInfo,
-		collect_events: CollectEvents,
-		determinism: Determinism,
-	) -> ContractExecResult<BalanceOf<Test>, EventRecordOf<Test>>
-);
-
-/// Create a [`BareInstantiateBuilder`] with default values.
-pub fn bare_instantiate(code: Code<CodeHash<Test>>) -> BareInstantiateBuilder {
-	BareInstantiateBuilder {
-		origin: ALICE,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code,
-		data: vec![],
-		salt: vec![],
-		debug: DebugInfo::Skip,
-		collect_events: CollectEvents::Skip,
-	}
-}
-
-impl BareInstantiateBuilder {
-	/// Build the instantiate call and unwrap the result.
-	pub fn build_and_unwrap_result(self) -> crate::InstantiateReturnValue<AccountIdOf<Test>> {
-		self.build().result.unwrap()
-	}
-
-	/// Build the instantiate call and unwrap the account id.
-	pub fn build_and_unwrap_account_id(self) -> AccountIdOf<Test> {
-		self.build().result.unwrap().account_id
-	}
-}
-
-/// Create a [`BareCallBuilder`] with default values.
-pub fn bare_call(dest: AccountId32) -> BareCallBuilder {
-	BareCallBuilder {
-		origin: ALICE,
-		dest,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		data: vec![],
-		debug: DebugInfo::Skip,
-		collect_events: CollectEvents::Skip,
-		determinism: Determinism::Enforced,
-	}
-}
-
-impl BareCallBuilder {
-	/// Build the call and unwrap the result.
-	pub fn build_and_unwrap_result(self) -> ExecReturnValue {
-		self.build().result.unwrap()
-	}
-}
-
-/// Create an [`InstantiateWithCodeBuilder`] with default values.
-pub fn instantiate_with_code(code: Vec<u8>) -> InstantiateWithCodeBuilder {
-	InstantiateWithCodeBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code,
-		data: vec![],
-		salt: vec![],
-	}
-}
-
-/// Create an [`InstantiateBuilder`] with default values.
-pub fn instantiate(code_hash: CodeHash<Test>) -> InstantiateBuilder {
-	InstantiateBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code_hash,
-		data: vec![],
-		salt: vec![],
-	}
-}
-
-/// Create a [`CallBuilder`] with default values.
-pub fn call(dest: AccountIdLookupOf<Test>) -> CallBuilder {
-	CallBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		dest,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		data: vec![],
-	}
-}