New asset system - Separate asset types and add pallet-assets instances to runtime

Cargo.toml

@@ -161,6 +161,7 @@ frame-system-benchmarking = { git = "https://github.com/paritytech/substrate", b
 frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
 frame-try-runtime = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
 pallet-asset-tx-payment = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
+pallet-assets = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
 pallet-aura = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
 pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
 pallet-bounties = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }

primitives/src/asset.rs

@@ -23,6 +23,9 @@ use scale_info::TypeInfo;
 /// The `Asset` enum represents all types of assets available in the Zeitgeist
 /// system.
 ///
+/// **Deprecated:** Market and Pool assets are "lazy" migrated to pallet-assets
+/// Do not create any new market or pool assets using this enumeration.
+///
 /// # Types
 ///
 /// * `MI`: Market Id
@@ -53,6 +56,24 @@ pub enum Asset<MI: MaxEncodedLen> {
     ParimutuelShare(MI, CategoryIndex),
 }
 
+/// The `MarketAsset` enum represents all types of assets available in the
+/// prediction market protocol.
+///
+/// # Types
+///
+/// * `MI`: Market Id
+#[cfg_attr(feature = "std", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[derive(Clone, Copy, Debug, Decode, Default, Eq, Encode, MaxEncodedLen, PartialEq, TypeInfo)]
+pub enum PredictionMarketAsset<MI: MaxEncodedLen> {
+    CategoricalOutcome(MI, CategoryIndex),
+    #[default]
+    CombinatorialOutcome,
+    ScalarOutcome(MI, ScalarPosition),
+    ParimutuelShare(MI, CategoryIndex),
+    PoolShare(PoolId),
+}
+
 /// In a scalar market, users can either choose a `Long` position,
 /// meaning that they think the outcome will be closer to the upper bound
 /// or a `Short` position meaning that they think the outcome will be closer

primitives/src/types.rs

@@ -81,8 +81,15 @@ impl<'a> Arbitrary<'a> for MultiHash {
 /// ORML adapter
 pub type BasicCurrencyAdapter<R, B> = orml_currencies::BasicCurrencyAdapter<R, B, Amount, Balance>;
 
+/// ID type for any asset class
 pub type CurrencyId = Asset<MarketId>;
 
+// ID type for asset classes that anyone can create
+pub type AssetId = u128;
+
+// ID type for the asset classes are used within the prediction market protocol
+pub type MarketAsset = PredictionMarketAsset<MarketId>;
+
 /// The asset id specifically used for pallet_assets_tx_payment for
 /// paying transaction fees in different assets.
 /// Since the polkadot extension and wallets can't handle custom asset ids other than just u32,

runtime/battery-station/Cargo.toml

@@ -11,6 +11,7 @@ orml-currencies = { workspace = true }
 orml-tokens = { workspace = true }
 orml-traits = { workspace = true }
 pallet-asset-tx-payment = { workspace = true }
+pallet-assets = { workspace = true }
 pallet-balances = { workspace = true }
 pallet-bounties = { workspace = true }
 pallet-collective = { workspace = true }
@@ -182,6 +183,7 @@ runtime-benchmarks = [
     "orml-benchmarking",
     "orml-tokens/runtime-benchmarks",
     "orml-xtokens?/runtime-benchmarks",
+    "pallet-assets/runtime-benchmarks",
     "pallet-author-inherent?/runtime-benchmarks",
     "pallet-author-mapping?/runtime-benchmarks",
     "pallet-author-slot-filter?/runtime-benchmarks",
@@ -231,6 +233,7 @@ std = [
     "orml-currencies/std",
     "orml-tokens/std",
     "orml-traits/std",
+    "pallet-assets/std",
     "pallet-asset-tx-payment/std",
     "pallet-balances/std",
     "pallet-bounties/std",
@@ -352,6 +355,7 @@ try-runtime = [
     "pallet-preimage/try-runtime",
 
     # Money runtime pallets
+    "pallet-assets/try-runtime",
     "pallet-asset-tx-payment/try-runtime",
     "pallet-balances/try-runtime",
     "pallet-bounties/try-runtime",

runtime/battery-station/src/lib.rs

@@ -30,7 +30,7 @@ use common_runtime::{
 };
 pub use frame_system::{
     Call as SystemCall, CheckEra, CheckGenesis, CheckNonZeroSender, CheckNonce, CheckSpecVersion,
-    CheckTxVersion, CheckWeight,
+    CheckTxVersion, CheckWeight, EnsureNever,
 };
 #[cfg(feature = "parachain")]
 pub use pallet_author_slot_filter::EligibilityValue;
@@ -42,12 +42,16 @@ pub use crate::parachain_params::*;
 pub use crate::parameters::*;
 use alloc::vec;
 use frame_support::{
-    traits::{ConstU32, Contains, EitherOfDiverse, EqualPrivilegeOnly, InstanceFilter},
+    traits::{
+        AsEnsureOriginWithArg, ConstU32, Contains, EitherOfDiverse, EqualPrivilegeOnly,
+        InstanceFilter,
+    },
     weights::{constants::RocksDbWeight, ConstantMultiplier, IdentityFee, Weight},
 };
-use frame_system::{EnsureRoot, EnsureWithSuccess};
+use frame_system::{EnsureRoot, EnsureSigned, EnsureWithSuccess};
 use orml_currencies::Call::transfer;
 use pallet_collective::{EnsureProportionAtLeast, PrimeDefaultVote};
+use parity_scale_codec::Compact;
 use sp_runtime::traits::{AccountIdConversion, AccountIdLookup, BlakeTwo256};
 #[cfg(feature = "std")]
 use sp_version::NativeVersion;
@@ -66,7 +70,7 @@ use zrml_swaps::Call::{
 };
 #[cfg(feature = "parachain")]
 use {
-    frame_support::traits::{AsEnsureOriginWithArg, Everything, Nothing},
+    frame_support::traits::{Everything, Nothing},
     xcm_builder::{EnsureXcmOrigin, FixedWeightBounds},
     xcm_config::{
         asset_registry::CustomAssetProcessor,

runtime/battery-station/src/parameters.rs

@@ -63,6 +63,38 @@ parameter_types! {
 }
 
 parameter_types! {
+    // Assets (Campaign)
+    pub const CampaignAssetsAccountDeposit: Balance = deposit(1, 16);
+    pub const CampaignAssetsApprovalDeposit: Balance = ExistentialDeposit::get();
+    /// The amount of native currency that is frozen during the whole lifetime
+    /// if an asset class. Freezing happens at asset class creation.
+    /// Irrelevant - No origin can successfully call the associated dispatchable call.
+    pub const CampaignAssetsDeposit: Balance = BASE;
+    pub const CampaignAssetsStringLimit: u32 = 256;
+    pub const CampaignAssetsMetadataDepositBase: Balance = deposit(1, 68);
+    pub const CampaignAssetsMetadataDepositPerByte: Balance = deposit(0, 1);
+
+    // Assets (Custom)
+    pub const CustomAssetsAccountDeposit: Balance = deposit(1, 16);
+    pub const CustomAssetsApprovalDeposit: Balance = ExistentialDeposit::get();
+    /// The amount of native currency that is frozen during the whole lifetime
+    /// of an asset class. Freezing happens at asset class creation.
+    pub const CustomAssetsDeposit: Balance = BASE;
+    pub const CustomAssetsStringLimit: u32 = 50;
+    pub const CustomAssetsMetadataDepositBase: Balance = deposit(1, 68);
+    pub const CustomAssetsMetadataDepositPerByte: Balance = deposit(0, 1);
+
+    // Assets (Market)
+    pub const MarketAssetsAccountDeposit: Balance = deposit(1, 16);
+    pub const MarketAssetsApprovalDeposit: Balance = ExistentialDeposit::get();
+    /// The amount of native currency that is frozen during the whole lifetime
+    /// of an asset class. Freezing happens at asset class creation.
+    /// Irrelevant - No origin can successfully call the associated dispatchable call.
+    pub const MarketAssetsDeposit: Balance = BASE;
+    pub const MarketAssetsStringLimit: u32 = 50;
+    pub const MarketAssetsMetadataDepositBase: Balance = deposit(1, 68);
+    pub const MarketAssetsMetadataDepositPerByte: Balance = deposit(0, 1);
+
     // Authorized
     pub const AuthorizedPalletId: PalletId = AUTHORIZED_PALLET_ID;
     pub const CorrectionPeriod: BlockNumber = BLOCKS_PER_DAY;

runtime/common/Cargo.toml

@@ -6,6 +6,7 @@ frame-system = { workspace = true }
 orml-currencies = { workspace = true }
 orml-tokens = { workspace = true }
 pallet-asset-tx-payment = { workspace = true }
+pallet-assets = { workspace = true }
 pallet-author-inherent = { workspace = true, optional = true }
 pallet-author-mapping = { workspace = true, optional = true }
 pallet-author-slot-filter = { workspace = true, optional = true }
@@ -49,6 +50,7 @@ std = [
     "frame-support/std",
     "orml-currencies/std",
     "orml-tokens/std",
+    "pallet-assets/std",
     "pallet-asset-tx-payment/std",
     "pallet-author-inherent?/std",
     "pallet-author-mapping?/std",

runtime/common/src/lib.rs

@@ -93,6 +93,11 @@ macro_rules! decl_common_types {
         pub type UncheckedExtrinsic =
             generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
 
+        // Asset instances
+        type CustomAssetsInstance = pallet_assets::Instance1;
+        type CampaignAssetsInstance = pallet_assets::Instance2;
+        type MarketAssetsInstance = pallet_assets::Instance3;
+
         // Governance
         type AdvisoryCommitteeInstance = pallet_collective::Instance1;
         type AdvisoryCommitteeMembershipInstance = pallet_membership::Instance1;
@@ -284,6 +289,9 @@ macro_rules! create_runtime {
                 Multisig: pallet_multisig::{Call, Event<T>, Pallet, Storage} = 14,
                 Bounties: pallet_bounties::{Call, Event<T>, Pallet, Storage} =  15,
                 AssetTxPayment: pallet_asset_tx_payment::{Event<T>, Pallet} = 16,
+                Assets: pallet_assets::<Instance1>::{Call, Pallet, Storage, Event<T>} = 17,
+                CampaignAssets: pallet_assets::<Instance2>::{Call, Pallet, Storage, Event<T>} = 18,
+                MarketAssets: pallet_assets::<Instance3>::{Call, Pallet, Storage, Event<T>} = 19,
 
                 // Governance
                 Democracy: pallet_democracy::{Pallet, Call, Storage, Config<T>, Event<T>} = 20,
@@ -625,6 +633,107 @@ macro_rules! impl_config_traits {
             type XcmExecutor = xcm_executor::XcmExecutor<XcmConfig>;
         }
 
+        // Required for runtime benchmarks
+        pallet_assets::runtime_benchmarks_enabled! {
+            pub struct CustomAssetsBenchmarkHelper;
+
+            impl<AssetIdParameter> pallet_assets::BenchmarkHelper<AssetIdParameter>
+                for CustomAssetsBenchmarkHelper
+            where
+                AssetIdParameter: From<u128>,
+            {
+                fn create_asset_id_parameter(id: u32) -> AssetIdParameter {
+                    (id as u128).into()
+                }
+            }
+        }
+
+        impl pallet_assets::Config<CustomAssetsInstance> for Runtime {
+            type ApprovalDeposit = CustomAssetsApprovalDeposit;
+            type AssetAccountDeposit = CustomAssetsAccountDeposit;
+            type AssetDeposit = CustomAssetsDeposit;
+            type AssetId = AssetId;
+            type AssetIdParameter = Compact<AssetId>;
+            type Balance = Balance;
+            #[cfg(feature = "runtime-benchmarks")]
+            type BenchmarkHelper = CustomAssetsBenchmarkHelper;
+            type CallbackHandle = ();
+            type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<AccountId>>;
+            type Currency = Balances;
+            type Extra = ();
+            type ForceOrigin = EnsureRootOrTwoThirdsTechnicalCommittee;
+            type Freezer = ();
+            type MetadataDepositBase = CustomAssetsMetadataDepositBase;
+            type MetadataDepositPerByte = CustomAssetsMetadataDepositPerByte;
+            // TODO(#1176): Figure out sensible number after benchmark on reference machine
+            type RemoveItemsLimit = ConstU32<{ 50 }>;
+            type RuntimeEvent = RuntimeEvent;
+            type StringLimit = CustomAssetsStringLimit;
+            type WeightInfo = weights::pallet_assets::WeightInfo<Runtime>;
+        }
+
+        impl pallet_assets::Config<CampaignAssetsInstance> for Runtime {
+            type ApprovalDeposit = CampaignAssetsApprovalDeposit;
+            type AssetAccountDeposit = CampaignAssetsAccountDeposit;
+            type AssetDeposit = CampaignAssetsDeposit;
+            type AssetId = AssetId;
+            type AssetIdParameter = Compact<AssetId>;
+            type Balance = Balance;
+            #[cfg(feature = "runtime-benchmarks")]
+            type BenchmarkHelper = CustomAssetsBenchmarkHelper;
+            type CallbackHandle = ();
+            type CreateOrigin = AsEnsureOriginWithArg<EnsureNever<AccountId>>;
+            type Currency = Balances;
+            type Extra = ();
+            type ForceOrigin = EnsureRootOrTwoThirdsCouncil;
+            type Freezer = ();
+            type MetadataDepositBase = CampaignAssetsMetadataDepositBase;
+            type MetadataDepositPerByte = CampaignAssetsMetadataDepositPerByte;
+            // TODO(#1176): Figure out sensible number after benchmark on reference machine
+            type RemoveItemsLimit = ConstU32<{ 50 }>;
+            type RuntimeEvent = RuntimeEvent;
+            type StringLimit = CampaignAssetsStringLimit;
+            type WeightInfo = weights::pallet_assets::WeightInfo<Runtime>;
+        }
+
+        // Required for runtime benchmarks
+        pallet_assets::runtime_benchmarks_enabled! {
+            pub struct MarketAssetsBenchmarkHelper;
+
+            impl pallet_assets::BenchmarkHelper<MarketAsset>
+                for MarketAssetsBenchmarkHelper
+            {
+                fn create_asset_id_parameter(id: u32) -> MarketAsset {
+                    MarketAsset::CategoricalOutcome(0, id as CategoryIndex)
+                }
+            }
+        }
+
+        impl pallet_assets::Config<MarketAssetsInstance> for Runtime {
+            type ApprovalDeposit = MarketAssetsApprovalDeposit;
+            type AssetAccountDeposit = MarketAssetsAccountDeposit;
+            type AssetDeposit = MarketAssetsDeposit;
+            type AssetId = MarketAsset;
+            type AssetIdParameter = MarketAsset;
+            type Balance = Balance;
+            #[cfg(feature = "runtime-benchmarks")]
+            type BenchmarkHelper = MarketAssetsBenchmarkHelper;
+            type CallbackHandle = ();
+            type CreateOrigin = AsEnsureOriginWithArg<EnsureNever<AccountId>>;
+            type Currency = Balances;
+            type Extra = ();
+            type ForceOrigin = EnsureRootOrAllTechnicalCommittee;
+            type Freezer = ();
+            type MetadataDepositBase = MarketAssetsMetadataDepositBase;
+            type MetadataDepositPerByte = MarketAssetsMetadataDepositPerByte;
+            // TODO(#1176): Figure out sensible number after benchmark on reference machine
+            type RemoveItemsLimit = ConstU32<{ 50 }>;
+            type RuntimeEvent = RuntimeEvent;
+            type StringLimit = MarketAssetsStringLimit;
+            type WeightInfo = weights::pallet_assets::WeightInfo<Runtime>;
+        }
+
+
         impl pallet_balances::Config for Runtime {
             type AccountStore = System;
             type Balance = Balance;
@@ -1372,6 +1481,7 @@ macro_rules! create_runtime_api {
                     list_benchmark!(list, extra, frame_system, SystemBench::<Runtime>);
                     orml_list_benchmark!(list, extra, orml_currencies, crate::benchmarks::currencies);
                     orml_list_benchmark!(list, extra, orml_tokens, crate::benchmarks::tokens);
+                    list_benchmark!(list, extra, pallet_assets, Assets);
                     list_benchmark!(list, extra, pallet_balances, Balances);
                     list_benchmark!(list, extra, pallet_bounties, Bounties);
                     list_benchmark!(list, extra, pallet_collective, AdvisoryCommittee);
@@ -1476,6 +1586,7 @@ macro_rules! create_runtime_api {
                     add_benchmark!(params, batches, frame_system, SystemBench::<Runtime>);
                     orml_add_benchmark!(params, batches, orml_currencies, crate::benchmarks::currencies);
                     orml_add_benchmark!(params, batches, orml_tokens, crate::benchmarks::tokens);
+                    add_benchmark!(params, batches, pallet_assets, Assets);
                     add_benchmark!(params, batches, pallet_balances, Balances);
                     add_benchmark!(params, batches, pallet_bounties, Bounties);
                     add_benchmark!(params, batches, pallet_collective, AdvisoryCommittee);

runtime/common/src/weights/mod.rs

@@ -32,6 +32,7 @@ cfg_if::cfg_if! {
 pub mod frame_system;
 pub mod orml_currencies;
 pub mod orml_tokens;
+pub mod pallet_assets;
 pub mod pallet_balances;
 pub mod pallet_bounties;
 pub mod pallet_collective;