The Ambassador Program

cumulus/parachains/common/src/polkadot.rs

@@ -27,6 +27,10 @@ pub mod account {
  /// It is used as a temporarily place to deposit a slashed imbalance
  /// before the teleport to the Treasury.
  pub const REFERENDA_PALLET_ID: PalletId = PalletId(*b"py/refer");
+ /// Ambassador Referenda pallet ID.
+ /// It is used as a temporarily place to deposit a slashed imbalance
+ /// before the teleport to the Treasury.
+ pub const AMBASSADOR_REFERENDA_PALLET_ID: PalletId = PalletId(*b"py/amref");
 }
 
 /// Consensus-related.

cumulus/parachains/integration-tests/emulated/collectives/collectives-polkadot/Cargo.toml

@@ -15,6 +15,7 @@ sp-runtime = { path = "../../../../../../substrate/primitives/runtime", default-
 frame-support = { path = "../../../../../../substrate/frame/support", default-features = false}
 sp-core = { path = "../../../../../../substrate/primitives/core", default-features = false}
 pallet-assets = { path = "../../../../../../substrate/frame/assets", default-features = false}
+pallet-balances = { path = "../../../../../../substrate/frame/balances", default-features = false}
 pallet-core-fellowship = { path = "../../../../../../substrate/frame/core-fellowship", default-features = false}
 pallet-salary = { path = "../../../../../../substrate/frame/salary", default-features = false}
 

cumulus/parachains/integration-tests/emulated/collectives/collectives-polkadot/src/tests/ambassador.rs

@@ -0,0 +1,66 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Cumulus.
+
+// Cumulus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Cumulus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Cumulus. If not, see <http://www.gnu.org/licenses/>.
+
+//! Integration tests concerning the Fellowship.
+
+use crate::*;
+use collectives_polkadot_runtime::ambassador::AmbassadorSalaryPaymaster;
+use frame_support::traits::{fungible::Mutate, tokens::Pay};
+use sp_core::crypto::Ss58Codec;
+use xcm_emulator::TestExt;
+
+#[test]
+fn pay_salary() {
+ let pay_from: AccountId =
+ <AccountId as Ss58Codec>::from_string("5DS1Gaf6R9eFAV8QyeZP9P89kTkJMurxv3y3J3TTMu8p8VCX")
+ .unwrap();
+ let pay_to = Polkadot::account_id_of(ALICE);
+ let pay_amount = 90000000000;
+
+ AssetHubPolkadot::execute_with(|| {
+ type AssetHubBalances = <AssetHubPolkadot as AssetHubPolkadotPallet>::Balances;
+
+ assert_ok!(<AssetHubBalances as Mutate<_>>::mint_into(&pay_from, pay_amount * 2));
+ });
+
+ Collectives::execute_with(|| {
+ type RuntimeEvent = <Collectives as Chain>::RuntimeEvent;
+
+ assert_ok!(AmbassadorSalaryPaymaster::pay(&pay_to, (), pay_amount));
+ assert_expected_events!(
+ Collectives,
+ vec![
+ RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {},
+ ]
+ );
+ });
+
+ AssetHubPolkadot::execute_with(|| {
+ type RuntimeEvent = <AssetHubPolkadot as Chain>::RuntimeEvent;
+
+ assert_expected_events!(
+ AssetHubPolkadot,
+ vec![
+ RuntimeEvent::Balances(pallet_balances::Event::Transfer { from, to, amount }) => {
+ from: from == &pay_from,
+ to: to == &pay_to,
+ amount: amount == &pay_amount,
+ },
+ RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::Success { .. }) => {},
+ ]
+ );
+ });
+}

cumulus/parachains/integration-tests/emulated/collectives/collectives-polkadot/src/tests/mod.rs

@@ -13,4 +13,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod ambassador;
 mod fellowship;

cumulus/parachains/pallets/collective-content/Cargo.toml

@@ -0,0 +1,48 @@
+[package]
+name = "pallet-collective-content"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+description = "Managed content"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] }
+scale-info = { version = "2.3.0", default-features = false, features = ["derive"] }
+
+frame-benchmarking = { path = "../../../../substrate/frame/benchmarking", optional = true, default-features = false }
+frame-support = { path = "../../../../substrate/frame/support", default-features = false }
+frame-system = { path = "../../../../substrate/frame/system", default-features = false }
+
+sp-core = { path = "../../../../substrate/primitives/core", default-features = false }
+sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false }
+sp-std = { path = "../../../../substrate/primitives/std", default-features = false }
+
+[dev-dependencies]
+sp-io = { path = "../../../../substrate/primitives/io", default-features = false }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+ "frame-benchmarking/runtime-benchmarks",
+ "frame-support/runtime-benchmarks",
+ "frame-system/runtime-benchmarks",
+ "sp-runtime/runtime-benchmarks",
+]
+
+try-runtime = [
+ "frame-support/try-runtime",
+ "frame-system/try-runtime",
+ "sp-runtime/try-runtime",
+]
+
+std = [
+ "codec/std",
+ "frame-benchmarking/std",
+ "frame-support/std",
+ "frame-system/std",
+ "scale-info/std",
+ "sp-core/std",
+ "sp-io/std",
+ "sp-runtime/std",
+ "sp-std/std",
+]

cumulus/parachains/pallets/collective-content/src/benchmarking.rs

@@ -0,0 +1,116 @@
+// Copyright (C) 2023 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.
+
+//! The pallet benchmarks.
+
+use super::{Pallet as CollectiveContent, *};
+use frame_benchmarking::{impl_benchmark_test_suite, v2::*};
+use frame_support::traits::EnsureOrigin;
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+ frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+/// returns CID hash of 68 bytes of given `i`.
+fn create_cid(i: u8) -> OpaqueCid {
+ let cid: OpaqueCid = [i; 68].to_vec().try_into().unwrap();
+ cid
+}
+
+#[instance_benchmarks]
+mod benchmarks {
+ use super::*;
+
+ #[benchmark]
+ fn set_charter() -> Result<(), BenchmarkError> {
+ let cid: OpaqueCid = create_cid(1);
+ let origin =
+ T::CharterOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+ #[extrinsic_call]
+ _(origin as T::RuntimeOrigin, cid.clone());
+
+ assert_eq!(CollectiveContent::<T, I>::charter(), Some(cid.clone()));
+ assert_last_event::<T, I>(Event::NewCharterSet { cid }.into());
+ Ok(())
+ }
+
+ #[benchmark]
+ fn announce() -> Result<(), BenchmarkError> {
+ let expire_at = DispatchTime::<_>::At(10u32.into());
+ let now = frame_system::Pallet::<T>::block_number();
+ let cid: OpaqueCid = create_cid(1);
+ let origin = T::AnnouncementOrigin::try_successful_origin()
+ .map_err(|_| BenchmarkError::Weightless)?;
+
+ #[extrinsic_call]
+ _(origin as T::RuntimeOrigin, cid.clone(), Some(expire_at.clone()));
+
+ assert_eq!(CollectiveContent::<T, I>::announcements_count(), 1);
+ assert_last_event::<T, I>(
+ Event::AnnouncementAnnounced { cid, expire_at: expire_at.evaluate(now) }.into(),
+ );
+
+ Ok(())
+ }
+
+ #[benchmark]
+ fn remove_announcement() -> Result<(), BenchmarkError> {
+ let cid: OpaqueCid = create_cid(1);
+ let origin = T::AnnouncementOrigin::try_successful_origin()
+ .map_err(|_| BenchmarkError::Weightless)?;
+ CollectiveContent::<T, I>::announce(origin.clone(), cid.clone(), None)
+ .expect("could not publish an announcement");
+ assert_eq!(CollectiveContent::<T, I>::announcements_count(), 1);
+
+ #[extrinsic_call]
+ _(origin as T::RuntimeOrigin, cid.clone());
+
+ assert_eq!(CollectiveContent::<T, I>::announcements_count(), 0);
+ assert_last_event::<T, I>(Event::AnnouncementRemoved { cid }.into());
+
+ Ok(())
+ }
+
+ #[benchmark]
+ fn cleanup_announcements(x: Linear<0, 100>) -> Result<(), BenchmarkError> {
+ let origin = T::AnnouncementOrigin::try_successful_origin().unwrap();
+
+ let max_count = x;
+ for i in 0..max_count {
+ let cid: OpaqueCid = create_cid(i as u8);
+ CollectiveContent::<T, I>::announce(
+ origin.clone(),
+ cid,
+ Some(DispatchTime::<_>::At(5u32.into())),
+ )
+ .expect("could not publish an announcement");
+ }
+ assert_eq!(CollectiveContent::<T, I>::announcements_count(), max_count);
+ frame_system::Pallet::<T>::set_block_number(10u32.into());
+
+ #[block]
+ {
+ CollectiveContent::<T, I>::cleanup_announcements(10u32.into());
+ }
+
+ assert_eq!(CollectiveContent::<T, I>::announcements_count(), 0);
+ assert_eq!(frame_system::Pallet::<T>::events().len() as u32, max_count);
+
+ Ok(())
+ }
+
+ impl_benchmark_test_suite!(CollectiveContent, super::mock::new_bench_ext(), super::mock::Test);
+}