ink_sandbox/

macros.rs

use std::time::SystemTime;

use frame_support::{
    sp_runtime::{
        BuildStorage,
        traits::{
            Header,
            One,
        },
    },
    traits::Hooks,
};
use frame_system::pallet_prelude::BlockNumberFor;
use sp_io::TestExternalities;

/// Asserts that a contract call succeeded without reverting.
///
/// This macro follows FRAME's `assert_ok!` convention for consistency across
/// the Polkadot ecosystem. It verifies that a contract call completed successfully
/// and did not revert. If the call reverted, the macro panics with a detailed
/// error message extracted from the call trace.
///
/// # Behavior
///
/// - Takes a `CallResult` as input
/// - Checks if `dry_run.did_revert()` is `false`
/// - Panics with error details if the call reverted
/// - Returns the `CallResult` for further inspection if successful
///
/// # Examples
///
/// ```ignore
/// let result = client.call(&alice, &transfer).submit().await?;
/// assert_ok!(result);
/// ```
#[macro_export]
macro_rules! assert_ok {
    ($result:expr) => {{
        let result = $result;
        if result.dry_run.did_revert() {
            panic!(
                "Expected call to succeed but it reverted.\nError: {:?}",
                result.extract_error()
            );
        }
        result
    }};
    ($result:expr, $($msg:tt)+) => {{
        let result = $result;
        if result.dry_run.did_revert() {
            panic!(
                "{}\nExpected call to succeed but it reverted.\nError: {:?}",
                format_args!($($msg)+),
                result.extract_error()
            );
        }
        result
    }};
}

/// Asserts that a contract call reverted with a specific error.
///
/// This macro follows FRAME's `assert_noop!` convention, which stands for
/// "assert no operation" - meaning the call should fail without changing state.
/// It verifies that a contract call reverted and that the revert reason matches
/// the expected error string.
///
/// # Behavior
///
/// - Takes a `CallResult` and an expected error string as input
/// - Checks if `dry_run.did_revert()` is `true`
/// - Panics if the call succeeded (did not revert)
/// - Extracts the error from the call trace using `extract_error()`
/// - Panics if the actual error doesn't match the expected error
/// - Returns the `CallResult` if both checks pass
///
/// # Examples
///
/// ```ignore
/// let result = client.call(&alice, &insufficient_transfer).submit().await?;
/// assert_noop!(result, "BalanceLow");
/// ```
#[macro_export]
macro_rules! assert_noop {
    ($result:expr, $expected_error:expr) => {{
        let result = $result;
        if !result.dry_run.did_revert() {
            panic!(
                "Expected call to revert with '{}' but it succeeded",
                $expected_error
            );
        }

        let actual_error = result.extract_error();
        if actual_error != Some($expected_error.to_string()) {
            panic!(
                "Expected error '{}' but got {:?}",
                $expected_error,
                actual_error
            );
        }

        result
    }};
    ($result:expr, $expected_error:expr, $($msg:tt)+) => {{
        let result = $result;
        if !result.dry_run.did_revert() {
            panic!(
                "{}\nExpected call to revert with '{}' but it succeeded",
                format_args!($($msg)+),
                $expected_error
            );
        }

        let actual_error = result.extract_error();
        if actual_error != Some($expected_error.to_string()) {
            panic!(
                "{}\nExpected error '{}' but got {:?}",
                format_args!($($msg)+),
                $expected_error,
                actual_error
            );
        }

        result
    }};
}

/// Asserts that the latest contract event matches an expected event.
///
/// This macro verifies that the last emitted contract event from the sandbox
/// matches the provided expected event.
///
/// # Parameters
/// - `client` - Mutable reference to the sandbox client
/// - `event` - The expected event
#[macro_export]
macro_rules! assert_last_event {
    ($client:expr, $event:expr $(,)?) => {
        $crate::client::assert_last_contract_event_inner($client, $event)
    };
}

/// A helper struct for initializing and finalizing blocks.
pub struct BlockBuilder<T>(std::marker::PhantomData<T>);

impl<
    T: pallet_balances::Config
        + pallet_timestamp::Config<Moment = u64>
        + pallet_revive::Config,
> BlockBuilder<T>
{
    /// Create a new externalities with the given balances.
    pub fn new_ext(
        balances: Vec<(T::AccountId, <T as pallet_balances::Config>::Balance)>,
    ) -> TestExternalities {
        let mut storage = frame_system::GenesisConfig::<T>::default()
            .build_storage()
            .unwrap();

        pallet_balances::GenesisConfig::<T> {
            balances,
            dev_accounts: None,
        }
        .assimilate_storage(&mut storage)
        .unwrap();

        let mut ext = TestExternalities::new(storage);

        ext.execute_with(|| {
            Self::initialize_block(BlockNumberFor::<T>::one(), Default::default())
        });
        ext
    }

    /// Initialize a new block at particular height.
    pub fn initialize_block(
        height: frame_system::pallet_prelude::BlockNumberFor<T>,
        parent_hash: <T as frame_system::Config>::Hash,
    ) {
        frame_system::Pallet::<T>::reset_events();
        frame_system::Pallet::<T>::initialize(&height, &parent_hash, &Default::default());
        pallet_balances::Pallet::<T>::on_initialize(height);
        pallet_timestamp::Pallet::<T>::set_timestamp(
            SystemTime::now()
                .duration_since(SystemTime::UNIX_EPOCH)
                .expect("Time went backwards")
                .as_secs(),
        );
        pallet_timestamp::Pallet::<T>::on_initialize(height);
        pallet_revive::Pallet::<T>::on_initialize(height);
        frame_system::Pallet::<T>::note_finished_initialize();
    }

    /// Finalize a block at particular height.
    pub fn finalize_block(
        height: frame_system::pallet_prelude::BlockNumberFor<T>,
    ) -> <T as frame_system::Config>::Hash {
        pallet_revive::Pallet::<T>::on_finalize(height);
        use sp_core::Get;
        let minimum_period = <T as pallet_timestamp::Config>::MinimumPeriod::get();
        let now = pallet_timestamp::Pallet::<T>::get()
            .checked_add(minimum_period)
            .unwrap();
        pallet_timestamp::Pallet::<T>::set_timestamp(now);
        pallet_timestamp::Pallet::<T>::on_finalize(height);
        pallet_balances::Pallet::<T>::on_finalize(height);
        frame_system::Pallet::<T>::finalize().hash()
    }
}

/// Macro creating a minimal runtime with the given name.
///
/// The new macro will automatically implement `crate::Sandbox`.
#[macro_export]
macro_rules! create_sandbox {
    ($name:ident) => {
        $crate::paste::paste! {
            $crate::create_sandbox!($name, [<$name Runtime>], (), {});
        }
    };
    ($name:ident, $debug: ty) => {
        $crate::paste::paste! {
            $crate::create_sandbox!($name, [<$name Runtime>], $debug, {});
        }
    };
    ($name:ident, $debug: ty, { $( $pallet_name:tt : $pallet:ident ),* $(,)? }) => {
        $crate::paste::paste! {
            $crate::create_sandbox!($name, [<$name Runtime>], $debug, {
                $(
                    $pallet_name : $pallet,
                )*
            });
        }
    };
    ($sandbox:ident, $runtime:ident, $debug: ty, { $( $pallet_name:tt : $pallet:ident ),* $(,)? }) => {

// Put all the boilerplate into an auxiliary module
mod construct_runtime {

    // Bring some common types into the scope
    use $crate::frame_support::{
        construct_runtime,
        derive_impl,
        parameter_types,
        sp_runtime::{
            traits::Convert,
            AccountId32, Perbill,
            FixedU128,
        },
        traits::{ConstBool, ConstU8, ConstU128, ConstU32, ConstU64, Currency},
        weights::{Weight, IdentityFee},
    };

    use $crate::pallet_transaction_payment::{FungibleAdapter};

    use $crate::Snapshot;

    pub type Balance = u128;

    // Define the runtime type as a collection of pallets
    construct_runtime!(
        pub enum $runtime {
            System: $crate::frame_system,
            Balances: $crate::pallet_balances,
            Timestamp: $crate::pallet_timestamp,
            Assets: $crate::pallet_assets::<Instance1>,
            Revive: $crate::pallet_revive,
            TransactionPayment: $crate::pallet_transaction_payment,
            $(
                $pallet_name: $pallet,
            )*
        }
    );

    #[derive_impl($crate::frame_system::config_preludes::SolochainDefaultConfig as $crate::frame_system::DefaultConfig)]
    impl $crate::frame_system::Config for $runtime {
        type Block = $crate::frame_system::mocking::MockBlockU32<$runtime>;
        type Version = ();
        type BlockHashCount = ConstU32<250>;
        type AccountData = $crate::pallet_balances::AccountData<<$runtime as $crate::pallet_balances::Config>::Balance>;
    }

    impl $crate::pallet_balances::Config for $runtime {
        type RuntimeEvent = RuntimeEvent;
        type WeightInfo = ();
        type Balance = Balance;
        type DustRemoval = ();
        type ExistentialDeposit = ConstU128<1>;
        type AccountStore = System;
        type ReserveIdentifier = [u8; 8];
        type FreezeIdentifier = ();
        type MaxLocks = ();
        type MaxReserves = ();
        type MaxFreezes = ();
        type RuntimeHoldReason = RuntimeHoldReason;
        type RuntimeFreezeReason = RuntimeFreezeReason;
        type DoneSlashHandler = ();
    }

    impl $crate::pallet_timestamp::Config for $runtime {
        type Moment = u64;
        type OnTimestampSet = ();
        type MinimumPeriod = ConstU64<1>;
        type WeightInfo = ();
    }

    // Configure pallet-assets (Instance1 for Trust Backed Assets)
    pub type TrustBackedAssetsInstance = $crate::pallet_assets::Instance1;
    pub type AssetIdForTrustBackedAssets = u32;

    impl $crate::pallet_assets::Config<TrustBackedAssetsInstance> for $runtime {
        type RuntimeEvent = RuntimeEvent;
        type Balance = Balance;
        type AssetId = AssetIdForTrustBackedAssets;
        type AssetIdParameter = $crate::scale::Compact<AssetIdForTrustBackedAssets>;
        type Currency = Balances;
        type CreateOrigin = $crate::frame_support::traits::AsEnsureOriginWithArg<$crate::frame_system::EnsureSigned<AccountId32>>;
        type ForceOrigin = $crate::frame_system::EnsureRoot<AccountId32>;
        type AssetDeposit = ConstU128<1>;
        type AssetAccountDeposit = ConstU128<1>;
        type MetadataDepositBase = ConstU128<1>;
        type MetadataDepositPerByte = ConstU128<1>;
        type ApprovalDeposit = ConstU128<1>;
        type StringLimit = ConstU32<50>;
        type Freezer = ();
        type Holder = ();
        type Extra = ();
        type WeightInfo = ();
        type CallbackHandle = $crate::pallet_assets::AutoIncAssetId<$runtime, TrustBackedAssetsInstance>;
        type RemoveItemsLimit = ConstU32<1000>;
    }

    impl $crate::pallet_transaction_payment::Config for $runtime {
        type RuntimeEvent = RuntimeEvent;
        type OnChargeTransaction = FungibleAdapter<Balances, ()>;
        type OperationalFeeMultiplier = ConstU8<5>;
        type WeightToFee = $crate::pallet_revive::evm::fees::BlockRatioFee<1, 1, Self>;
        type LengthToFee = IdentityFee<Balance>;
        type FeeMultiplierUpdate = ();
        type WeightInfo = $crate::pallet_transaction_payment::weights::SubstrateWeight<$runtime>;
    }

    // Configure `pallet-revive`
    type BalanceOf = <Balances as Currency<AccountId32>>::Balance;
    impl Convert<Weight, BalanceOf> for $runtime {
        fn convert(w: Weight) -> BalanceOf {
            w.ref_time().into()
        }
    }

    // Unit = the base number of indivisible units for balances
    const UNIT: Balance = 1_000_000_000_000;
    const MILLIUNIT: Balance = 1_000_000_000;

    const fn deposit(items: u32, bytes: u32) -> Balance {
        (items as Balance * UNIT + (bytes as Balance) * (5 * MILLIUNIT / 100)) / 10
    }

    parameter_types! {
        pub CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
        pub const MaxEthExtrinsicWeight: FixedU128 = FixedU128::from_rational(1,2);
        pub const DepositPerChildTrieItem: Balance = deposit(1, 0) / 100;
    }

    impl $crate::pallet_revive::Config for $runtime {
        type AddressMapper = $crate::pallet_revive::AccountId32Mapper<Self>;
        type ChainId = ConstU64<1>;
        type NativeToEthRatio = ConstU32<100_000_000>;
        type Time = Timestamp;
        type Balance = Balance;
        type Currency = Balances;
        type RuntimeEvent = RuntimeEvent;
        type RuntimeCall = RuntimeCall;
        type RuntimeOrigin = RuntimeOrigin;
        type DepositPerItem = ConstU128<1>;
        type DepositPerChildTrieItem = DepositPerChildTrieItem;
        type DepositPerByte = ConstU128<1>;
        type WeightInfo = ();
        type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>;
        type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>;
        type UnsafeUnstableInterface = ConstBool<true>;
        type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
        type RuntimeHoldReason = RuntimeHoldReason;
        type UploadOrigin = $crate::frame_system::EnsureSigned<Self::AccountId>;
        type InstantiateOrigin = $crate::frame_system::EnsureSigned<Self::AccountId>;
        type FindAuthor = ();
        type Precompiles = (
            $crate::pallet_assets_precompiles::ERC20<Self, $crate::pallet_assets_precompiles::InlineIdConfig<{ 0x0120 }>, TrustBackedAssetsInstance>,
            // todo add `PoolAssetsInstance`
        );
        type AllowEVMBytecode = ConstBool<false>;
        type FeeInfo = ();
        type MaxEthExtrinsicWeight = MaxEthExtrinsicWeight;
        type DebugEnabled = ConstBool<false>;
    }

    /// Default initial balance for the default account.
    pub const INITIAL_BALANCE: u128 = 1_000_000_000_000_000;
    pub const DEFAULT_ACCOUNT: AccountId32 = AccountId32::new([1u8; 32]);

    pub struct $sandbox {
        ext: $crate::TestExternalities,
    }

    impl ::std::default::Default for $sandbox {
        fn default() -> Self {
            let ext = $crate::macros::BlockBuilder::<$runtime>::new_ext(vec![(
                DEFAULT_ACCOUNT,
                INITIAL_BALANCE,
            )]);
            Self { ext }
        }
    }

    // Implement `crate::Sandbox` trait
    impl $crate::Sandbox for $sandbox {
        type Runtime = $runtime;

        fn execute_with<T>(&mut self, execute: impl FnOnce() -> T) -> T {
            self.ext.execute_with(execute)
        }

        fn dry_run<T>(&mut self, action: impl FnOnce(&mut Self) -> T) -> T {
            // Make a backup of the backend.
            let backend_backup = self.ext.as_backend();
            // Run the action, potentially modifying storage. Ensure, that there are no pending changes
            // that would affect the reverted backend.
            let result = action(self);
            self.ext.commit_all().expect("Failed to commit changes");

            // Restore the backend.
            self.ext.backend = backend_backup;
            result
        }

        fn register_extension<E: ::core::any::Any + $crate::Extension>(&mut self, ext: E) {
            self.ext.register_extension(ext);
        }

        fn initialize_block(
            height: $crate::frame_system::pallet_prelude::BlockNumberFor<Self::Runtime>,
            parent_hash: <Self::Runtime as $crate::frame_system::Config>::Hash,
        ) {
            $crate::macros::BlockBuilder::<Self::Runtime>::initialize_block(height, parent_hash)
        }

        fn finalize_block(
            height: $crate::frame_system::pallet_prelude::BlockNumberFor<Self::Runtime>,
        ) -> <Self::Runtime as $crate::frame_system::Config>::Hash {
            $crate::macros::BlockBuilder::<Self::Runtime>::finalize_block(height)
        }

        fn default_actor() -> $crate::AccountIdFor<Self::Runtime> {
            DEFAULT_ACCOUNT
        }

        fn get_metadata() -> $crate::RuntimeMetadataPrefixed {
            Self::Runtime::metadata()
        }

        fn convert_account_to_origin(
            account: $crate::AccountIdFor<Self::Runtime>,
        ) -> <<Self::Runtime as $crate::frame_system::Config>::RuntimeCall as $crate::frame_support::sp_runtime::traits::Dispatchable>::RuntimeOrigin {
            Some(account).into()
        }

        fn take_snapshot(&mut self) -> Snapshot {
            let mut backend = self.ext.as_backend().clone();
            let raw_key_values = backend
                .backend_storage_mut()
                .drain()
                .into_iter()
                .filter(|(_, (_, r))| *r > 0)
                .collect::<Vec<(Vec<u8>, (Vec<u8>, i32))>>();
            let root = backend.root().to_owned();
            Snapshot {
                storage: raw_key_values,
                storage_root: root,
            }
        }

        fn restore_snapshot(&mut self, snapshot: Snapshot) {
            self.ext = $crate::TestExternalities::from_raw_snapshot(
                snapshot.storage,
                snapshot.storage_root,
                Default::default(),
            );
        }
    }
}

// Export runtime type itself, pallets and useful types from the auxiliary module
pub use construct_runtime::{
    $sandbox, $runtime, Assets, AssetIdForTrustBackedAssets, Balances, Revive, PalletInfo,
    RuntimeCall, RuntimeEvent, RuntimeHoldReason, RuntimeOrigin, System, Timestamp,
    TrustBackedAssetsInstance,
};
    };
}

create_sandbox!(DefaultSandbox);