Update outbound channel interval (#73)

Author: vovac12

pallets/substrate-channel/Cargo.toml

@@ -62,6 +62,7 @@ runtime-benchmarks = [
     "frame-benchmarking",
     "frame-support/runtime-benchmarks",
     "frame-system/runtime-benchmarks",
+    "pallet-timestamp/runtime-benchmarks",
     "hex-literal",
     "rlp",
 ]

pallets/substrate-channel/src/outbound/benchmarking.rs

@@ -37,6 +37,7 @@ use frame_benchmarking::benchmarks;
 use frame_support::traits::OnInitialize;
 use frame_system::EventRecord;
 use frame_system::RawOrigin;
+use sp_runtime::traits::One;
 use sp_std::prelude::*;
 
 const BASE_NETWORK_ID: SubNetworkId = SubNetworkId::Mainnet;
@@ -56,57 +57,6 @@ benchmarks! {
         where crate::outbound::Event::<T>: Into<<T as frame_system::Config>::RuntimeEvent>
     }
 
-    // Benchmark `on_initialize` under worst case conditions, i.e. messages
-    // in queue are committed.
-    on_initialize {
-        let m in 1 .. T::MaxMessagesPerCommit::get();
-        let p in 0 .. T::MaxMessagePayloadSize::get();
-
-        for _ in 0 .. m {
-            let payload: Vec<u8> = (0..).take(p as usize).collect();
-            MessageQueues::<T>::try_append(
-                BASE_NETWORK_ID, BridgeMessage {
-                payload: payload.try_into().unwrap(),
-                timepoint: Default::default(),
-            }).unwrap();
-        }
-
-        let block_number = 0u32.into();
-
-    }: { BridgeOutboundChannel::<T>::on_initialize(block_number) }
-    verify {
-        assert_eq!(<MessageQueues<T>>::get(BASE_NETWORK_ID).len(), 0);
-    }
-
-    // Benchmark 'on_initialize` for the best case, i.e. nothing is done
-    // because it's not a commitment interval.
-    on_initialize_non_interval {
-        MessageQueues::<T>::take(BASE_NETWORK_ID);
-        let payload: Vec<u8> = (0..).take(10).collect();
-        MessageQueues::<T>::try_append(
-            BASE_NETWORK_ID, BridgeMessage {
-            payload: payload.try_into().unwrap(),
-            timepoint: Default::default(),
-        }).unwrap();
-
-        let interval: T::BlockNumber = 10u32.into();
-        Interval::<T>::put(interval);
-        let block_number: T::BlockNumber = 12u32.into();
-
-    }: { BridgeOutboundChannel::<T>::on_initialize(block_number) }
-    verify {
-        assert_eq!(<MessageQueues<T>>::get(BASE_NETWORK_ID).len(), 1);
-    }
-
-    // Benchmark 'on_initialize` for the case where it is a commitment interval
-    // but there are no messages in the queue.
-    on_initialize_no_messages {
-        MessageQueues::<T>::take(BASE_NETWORK_ID);
-
-        let block_number = Interval::<T>::get();
-
-    }: { BridgeOutboundChannel::<T>::on_initialize(block_number) }
-
     submit {
 
     }: {
@@ -120,9 +70,20 @@ benchmarks! {
         }.into());
     }
 
+    update_interval {
+
+    }: {
+        BridgeOutboundChannel::<T>::update_interval(RawOrigin::Root.into(), One::one()).unwrap()
+    }
+    verify {
+        assert_last_event::<T>(crate::outbound::Event::<T>::IntervalUpdated {
+            interval: One::one()
+        }.into());
+    }
+
     impl_benchmark_test_suite!(
         BridgeOutboundChannel,
-        crate::outbound::test::new_tester(),
-        crate::outbound::test::Test,
+        crate::outbound::mock::new_tester(),
+        crate::outbound::mock::Test,
     );
 }

pallets/substrate-channel/src/outbound/mock.rs

@@ -0,0 +1,204 @@
+use super::*;
+use bridge_types::GenericNetworkId;
+use codec::{Decode, Encode, MaxEncodedLen};
+use currencies::BasicCurrencyAdapter;
+
+use bridge_types::traits::TimepointProvider;
+use frame_support::traits::{Everything, GenesisBuild};
+use frame_support::{parameter_types, Deserialize, Serialize};
+use scale_info::TypeInfo;
+use sp_core::H256;
+use sp_keyring::AccountKeyring as Keyring;
+use sp_runtime::testing::Header;
+use sp_runtime::traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify};
+use sp_runtime::{AccountId32, MultiSignature};
+use sp_std::convert::From;
+use traits::parameter_type_with_key;
+
+use crate::outbound as bridge_outbound_channel;
+
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+pub const BASE_NETWORK_ID: SubNetworkId = SubNetworkId::Mainnet;
+
+frame_support::construct_runtime!(
+    pub enum Test where
+        Block = Block,
+        NodeBlock = Block,
+        UncheckedExtrinsic = UncheckedExtrinsic,
+    {
+        System: frame_system::{Pallet, Call, Storage, Event<T>},
+        Timestamp: pallet_timestamp::{Pallet, Call, Storage},
+        Tokens: tokens::{Pallet, Call, Config<T>, Storage, Event<T>},
+        Currencies: currencies::{Pallet, Call, Storage},
+        Balances: pallet_balances::{Pallet, Call, Storage, Event<T>},
+        BridgeOutboundChannel: bridge_outbound_channel::{Pallet, Config<T>, Storage, Event<T>},
+    }
+);
+
+pub type Signature = MultiSignature;
+pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
+
+#[derive(
+    Encode,
+    Decode,
+    PartialEq,
+    Eq,
+    Debug,
+    Clone,
+    Copy,
+    MaxEncodedLen,
+    TypeInfo,
+    PartialOrd,
+    Ord,
+    Serialize,
+    Deserialize,
+)]
+pub enum AssetId {
+    XOR,
+    ETH,
+    DAI,
+}
+
+pub type Balance = u128;
+pub type Amount = i128;
+
+parameter_types! {
+    pub const BlockHashCount: u64 = 250;
+}
+
+impl frame_system::Config for Test {
+    type BaseCallFilter = Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type RuntimeCall = RuntimeCall;
+    type Index = u64;
+    type BlockNumber = u64;
+    type Hash = H256;
+    type Hashing = BlakeTwo256;
+    type AccountId = AccountId;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Header = Header;
+    type RuntimeEvent = RuntimeEvent;
+    type BlockHashCount = BlockHashCount;
+    type DbWeight = ();
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<Balance>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<65536>;
+}
+
+parameter_types! {
+    pub const ExistentialDeposit: u128 = 0;
+}
+
+parameter_type_with_key! {
+    pub ExistentialDeposits: |_currency_id: AssetId| -> Balance {
+        0
+    };
+}
+
+impl pallet_balances::Config for Test {
+    type Balance = Balance;
+    type RuntimeEvent = RuntimeEvent;
+    type DustRemoval = ();
+    type ExistentialDeposit = ExistentialDeposit;
+    type AccountStore = System;
+    type WeightInfo = ();
+    type MaxLocks = ();
+    type MaxReserves = ();
+    type ReserveIdentifier = ();
+}
+
+impl tokens::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type Balance = Balance;
+    type Amount = Amount;
+    type CurrencyId = AssetId;
+    type WeightInfo = ();
+    type ExistentialDeposits = ExistentialDeposits;
+    type CurrencyHooks = ();
+    type MaxLocks = ();
+    type MaxReserves = ();
+    type ReserveIdentifier = ();
+    type DustRemovalWhitelist = Everything;
+}
+
+impl currencies::Config for Test {
+    type MultiCurrency = Tokens;
+    type NativeCurrency = BasicCurrencyAdapter<Test, Balances, Amount, u64>;
+    type GetNativeCurrencyId = GetBaseAssetId;
+    type WeightInfo = ();
+}
+parameter_types! {
+    pub const GetBaseAssetId: AssetId = AssetId::XOR;
+    pub GetTeamReservesAccountId: AccountId = AccountId32::from([0; 32]);
+    pub GetFeeAccountId: AccountId = AccountId32::from([1; 32]);
+    pub GetTreasuryAccountId: AccountId = AccountId32::from([2; 32]);
+}
+
+parameter_types! {
+    pub const MaxMessagePayloadSize: u32 = 128;
+    pub const MaxMessagesPerCommit: u32 = 5;
+    pub const ThisNetworkId: GenericNetworkId = GenericNetworkId::Sub(SubNetworkId::Mainnet);
+}
+
+pub struct GenericTimepointProvider;
+
+impl TimepointProvider for GenericTimepointProvider {
+    fn get_timepoint() -> bridge_types::GenericTimepoint {
+        bridge_types::GenericTimepoint::Sora(System::block_number() as u32)
+    }
+}
+
+impl bridge_outbound_channel::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type MaxMessagePayloadSize = MaxMessagePayloadSize;
+    type MaxMessagesPerCommit = MaxMessagesPerCommit;
+    type MessageStatusNotifier = ();
+    type AuxiliaryDigestHandler = ();
+    type AssetId = ();
+    type Balance = u128;
+    type WeightInfo = ();
+    type TimepointProvider = GenericTimepointProvider;
+    type ThisNetworkId = ThisNetworkId;
+}
+
+impl pallet_timestamp::Config for Test {
+    type Moment = u64;
+    type OnTimestampSet = ();
+    type MinimumPeriod = ();
+    type WeightInfo = ();
+}
+
+pub fn new_tester() -> sp_io::TestExternalities {
+    let mut storage = frame_system::GenesisConfig::default()
+        .build_storage::<Test>()
+        .unwrap();
+
+    let config: bridge_outbound_channel::GenesisConfig<Test> =
+        bridge_outbound_channel::GenesisConfig {
+            interval: 10u32.into(),
+        };
+    config.assimilate_storage(&mut storage).unwrap();
+
+    let bob: AccountId = Keyring::Bob.into();
+
+    pallet_balances::GenesisConfig::<Test> {
+        balances: vec![(bob, 1u32.into())],
+    }
+    .assimilate_storage(&mut storage)
+    .unwrap();
+
+    let mut ext: sp_io::TestExternalities = storage.into();
+
+    ext.execute_with(|| System::set_block_number(1));
+    ext
+}