--- a/Cargo.lock +++ b/Cargo.lock @@ -5304,9 +5304,11 @@ "frame-support", "frame-system", "pallet-balances", + "pallet-common", "pallet-evm", "pallet-randomness-collective-flip", "pallet-timestamp", + "pallet-unique", "parity-scale-codec 3.1.5", "scale-info", "serde", @@ -5314,6 +5316,7 @@ "sp-io", "sp-runtime", "sp-std", + "up-data-structs", ] [[package]] --- a/pallets/app-promotion/Cargo.toml +++ b/pallets/app-promotion/Cargo.toml @@ -104,6 +104,22 @@ git = "https://github.com/uniquenetwork/frontier" branch = "unique-polkadot-v0.9.27" +################################################################################ +# local dependencies +[dependencies.up-data-structs] +default-features = false +path = "../../primitives/data-structs" + +[dependencies.pallet-common] +default-features = false +path = "../common" + +[dependencies.pallet-unique] +default-features = false +path = "../unique" + +################################################################################ + [dependencies] scale-info = { version = "2.0.1", default-features = false, features = [ "derive", --- a/pallets/app-promotion/src/benchmarking.rs +++ b/pallets/app-promotion/src/benchmarking.rs @@ -59,7 +59,7 @@ let _ = T::Currency::make_free_balance_be(&caller, Perbill::from_rational(1u32, 2) * BalanceOf::::max_value()); let _ = PromototionPallet::::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?; - } : {PromototionPallet::::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?} + } : {PromototionPallet::::unstake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?} recalculate_stake { let caller = account::("caller", 0, SEED); --- a/pallets/app-promotion/src/lib.rs +++ b/pallets/app-promotion/src/lib.rs @@ -36,11 +36,14 @@ pub mod types; pub mod weights; -use sp_std::{vec::Vec, iter::Sum}; +use sp_std::{vec::Vec, iter::Sum, borrow::ToOwned}; use codec::EncodeLike; use pallet_balances::BalanceLock; pub use types::ExtendedLockableCurrency; +// use up_common::constants::{DAYS, UNIQUE}; +use up_data_structs::CollectionId; + use frame_support::{ dispatch::{DispatchResult}, traits::{ @@ -55,38 +58,68 @@ use pallet_evm::account::CrossAccountId; use sp_runtime::{ Perbill, - traits::{BlockNumberProvider, CheckedAdd, CheckedSub}, + traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion}, ArithmeticError, }; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; -const SECONDS_TO_BLOCK: u32 = 6; -const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK; -const WEEK: u32 = 7 * DAY; -const TWO_WEEK: u32 = 2 * WEEK; -const YEAR: u32 = DAY * 365; +// const SECONDS_TO_BLOCK: u32 = 6; +// const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK; +// const WEEK: u32 = 7 * DAY; +// const TWO_WEEK: u32 = 2 * WEEK; +// const YEAR: u32 = DAY * 365; pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake"; #[frame_support::pallet] pub mod pallet { use super::*; - use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key}; + use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId}; use frame_system::pallet_prelude::*; + use types::CollectionHandler; #[pallet::config] pub trait Config: frame_system::Config + pallet_evm::account::Config { type Currency: ExtendedLockableCurrency; + type CollectionHandler: CollectionHandler< + AccountId = Self::AccountId, + CollectionId = CollectionId, + >; + type TreasuryAccountId: Get; + /// The app's pallet id, used for deriving its sovereign account ID. + #[pallet::constant] + type PalletId: Get; + + /// In relay blocks. + #[pallet::constant] + type RecalculationInterval: Get; + /// In chain blocks. + #[pallet::constant] + type PendingInterval: Get; + + /// In chain blocks. + #[pallet::constant] + type Day: Get; // useless + + #[pallet::constant] + type Nominal: Get>; + + #[pallet::constant] + type IntervalIncome: Get; + /// Weight information for extrinsics in this pallet. type WeightInfo: WeightInfo; - // The block number provider - type BlockNumberProvider: BlockNumberProvider; + // The relay block number provider + type RelayBlockNumberProvider: BlockNumberProvider; + + /// Events compatible with [`frame_system::Config::Event`]. + type Event: IsType<::Event> + From>; // /// Number of blocks that pass between treasury balance updates due to inflation // #[pallet::constant] @@ -100,6 +133,28 @@ #[pallet::generate_store(pub(super) trait Store)] pub struct Pallet(_); + #[pallet::event] + #[pallet::generate_deposit(fn deposit_event)] + pub enum Event { + StakingRecalculation( + /// Base on which interest is calculated + BalanceOf, + /// Amount of accrued interest + BalanceOf, + ), + } + + #[pallet::error] + pub enum Error { + AdminNotSet, + /// No permission to perform action + NoPermission, + /// Insufficient funds to perform an action + NotSufficientFounds, + InvalidArgument, + AlreadySponsored, + } + #[pallet::storage] pub type TotalStaked = StorageValue, QueryKind = ValueQuery>; @@ -164,23 +219,33 @@ }); let next_interest_block = Self::get_interest_block(); - - if next_interest_block != 0.into() && current_block >= next_interest_block { + let current_relay_block = T::RelayBlockNumberProvider::current_block_number(); + if next_interest_block != 0.into() && current_relay_block >= next_interest_block { let mut acc = >::default(); + let mut base_acc = >::default(); - NextInterestBlock::::set(current_block + DAY.into()); + NextInterestBlock::::set( + NextInterestBlock::::get() + T::RecalculationInterval::get(), + ); add_weight(0, 1, 0); Staked::::iter() - .filter(|((_, block), _)| *block + DAY.into() <= current_block) + .filter(|((_, block), _)| { + *block + T::RecalculationInterval::get() <= current_relay_block + }) .for_each(|((staker, block), amount)| { Self::recalculate_stake(&staker, block, amount, &mut acc); add_weight(0, 0, T::WeightInfo::recalculate_stake()); + base_acc += amount; }); >::get() .checked_add(&acc) .map(|res| >::set(res)); + + Self::deposit_event(Event::StakingRecalculation(base_acc, acc)); add_weight(0, 1, 0); + } else { + add_weight(1, 0, 0) }; consumed_weight } @@ -189,9 +254,9 @@ #[pallet::call] impl Pallet { #[pallet::weight(T::WeightInfo::set_admin_address())] - pub fn set_admin_address(origin: OriginFor, admin: T::AccountId) -> DispatchResult { + pub fn set_admin_address(origin: OriginFor, admin: T::CrossAccountId) -> DispatchResult { ensure_root(origin)?; - >::set(Some(admin)); + >::set(Some(admin.as_sub().to_owned())); Ok(()) } @@ -199,7 +264,7 @@ #[pallet::weight(T::WeightInfo::start_app_promotion())] pub fn start_app_promotion( origin: OriginFor, - promotion_start_relay_block: T::BlockNumber, + promotion_start_relay_block: Option, ) -> DispatchResult where ::BlockNumber: From, @@ -208,10 +273,13 @@ // Start app-promotion mechanics if it has not been yet initialized if >::get() == 0u32.into() { + let start_block = promotion_start_relay_block + .unwrap_or(T::RelayBlockNumberProvider::current_block_number()); + // Set promotion global start block - >::set(promotion_start_relay_block); + >::set(start_block); - >::set(promotion_start_relay_block + DAY.into()); + >::set(start_block + T::RecalculationInterval::get()); } Ok(()) @@ -221,6 +289,8 @@ pub fn stake(staker: OriginFor, amount: BalanceOf) -> DispatchResult { let staker_id = ensure_signed(staker)?; + ensure!(amount >= T::Nominal::get(), ArithmeticError::Underflow); + let balance = <::Currency as Currency>::free_balance(&staker_id); @@ -235,7 +305,7 @@ Self::add_lock_balance(&staker_id, amount)?; - let block_number = frame_system::Pallet::::block_number(); + let block_number = T::RelayBlockNumberProvider::current_block_number(); >::insert( (&staker_id, block_number), @@ -271,7 +341,7 @@ .ok_or(ArithmeticError::Underflow)?, ); - let block = frame_system::Pallet::::block_number() + WEEK.into(); + let block = frame_system::Pallet::::block_number() + T::PendingInterval::get(); >::insert( (&staker_id, block), >::get((&staker_id, block)) @@ -311,6 +381,40 @@ Ok(()) } + + #[pallet::weight(0)] + pub fn sponsor_collection( + admin: OriginFor, + collection_id: CollectionId, + ) -> DispatchResult { + let admin_id = ensure_signed(admin)?; + ensure!( + admin_id == Admin::::get().ok_or(Error::::AdminNotSet)?, + Error::::NoPermission + ); + + T::CollectionHandler::set_sponsor(Self::account_id(), collection_id) + } + #[pallet::weight(0)] + pub fn stop_sponsorign_collection( + admin: OriginFor, + collection_id: CollectionId, + ) -> DispatchResult { + let admin_id = ensure_signed(admin)?; + + ensure!( + admin_id == Admin::::get().ok_or(Error::::AdminNotSet)?, + Error::::NoPermission + ); + + ensure!( + T::CollectionHandler::get_sponsor(collection_id)? + .ok_or(>::InvalidArgument)? + == Self::account_id(), + >::NoPermission + ); + T::CollectionHandler::remove_collection_sponsor(collection_id) + } } } @@ -396,13 +500,13 @@ // Ok(()) // } - pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult { - Ok(()) - } + // pub fn sponsor_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult { + // Ok(()) + // } - pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult { - Ok(()) - } + // pub fn stop_sponsorign_collection(admin: T::AccountId, collection_id: u32) -> DispatchResult { + // Ok(()) + // } pub fn sponsor_conract(admin: T::AccountId, app_id: u32) -> DispatchResult { Ok(()) @@ -411,6 +515,10 @@ pub fn stop_sponsorign_contract(admin: T::AccountId, app_id: u32) -> DispatchResult { Ok(()) } + + pub fn account_id() -> T::AccountId { + T::PalletId::get().into_account_truncating() + } } impl Pallet { @@ -514,8 +622,7 @@ where I: EncodeLike> + Balance, { - let day_rate = Perbill::from_rational(5u32, 1_0000); - day_rate * base + T::IntervalIncome::get() * base } } --- a/pallets/app-promotion/src/tests.rs +++ b/pallets/app-promotion/src/tests.rs @@ -28,7 +28,7 @@ use sp_runtime::{ traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup}, testing::Header, - Perbill, + Perbill, Perquintill, }; // type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; @@ -126,3 +126,25 @@ // test_benchmark_stake::(); // } ) // } + +#[test] +fn test_perbill() { + const ONE_UNIQE: u128 = 1_000_000_000_000_000_000; + const SECONDS_TO_BLOCK: u32 = 12; + const DAY: u32 = 60 * 60 * 24 / SECONDS_TO_BLOCK; + const RECALCULATION_INTERVAL: u32 = 10; + let day_rate = Perbill::from_rational(5u64, 10_000); + let interval_rate = + Perbill::from_rational::(RECALCULATION_INTERVAL.into(), DAY.into()) * day_rate; + println!("{:?}", interval_rate * ONE_UNIQE + ONE_UNIQE); + println!("{:?}", day_rate * ONE_UNIQE); + println!("{:?}", Perbill::one() * ONE_UNIQE); + println!("{:?}", ONE_UNIQE); + let mut next_iters = ONE_UNIQE + interval_rate * ONE_UNIQE; + next_iters += interval_rate * next_iters; + println!("{:?}", next_iters); + let day_income = day_rate * ONE_UNIQE; + let interval_income = interval_rate * ONE_UNIQE; + let ratio = day_income / interval_income; + println!("{:?} || {:?}", ratio, DAY / RECALCULATION_INTERVAL); +} --- a/pallets/app-promotion/src/types.rs +++ b/pallets/app-promotion/src/types.rs @@ -1,6 +1,14 @@ use codec::EncodeLike; -use frame_support::{traits::LockableCurrency, WeakBoundedVec, Parameter}; +use frame_support::{ + traits::LockableCurrency, WeakBoundedVec, Parameter, dispatch::DispatchResult, ensure, +}; +use frame_system::Config; use pallet_balances::{BalanceLock, Config as BalancesConfig, Pallet as PalletBalances}; +use pallet_common::CollectionHandle; +use pallet_unique::{Event as UniqueEvent, Error as UniqueError}; +use sp_runtime::DispatchError; +use up_data_structs::{CollectionId, SponsorshipState}; +use sp_std::borrow::ToOwned; pub trait ExtendedLockableCurrency: LockableCurrency { fn locks(who: KArg) -> WeakBoundedVec, Self::MaxLocks> @@ -18,3 +26,70 @@ Self::locks(who) } } + +pub trait CollectionHandler { + type CollectionId; + type AccountId; + + fn set_sponsor( + sponsor_id: Self::AccountId, + collection_id: Self::CollectionId, + ) -> DispatchResult; + + fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult; + + fn get_sponsor( + collection_id: Self::CollectionId, + ) -> Result, DispatchError>; +} + +impl CollectionHandler for pallet_unique::Pallet { + type CollectionId = CollectionId; + + type AccountId = T::AccountId; + + fn set_sponsor( + sponsor_id: Self::AccountId, + collection_id: Self::CollectionId, + ) -> DispatchResult { + let mut target_collection = >::try_get(collection_id)?; + target_collection.check_is_internal()?; + target_collection.set_sponsor(sponsor_id.clone())?; + + Self::deposit_event(UniqueEvent::::CollectionSponsorSet( + collection_id, + sponsor_id.clone(), + )); + + ensure!( + target_collection.confirm_sponsorship(&sponsor_id)?, + UniqueError::::ConfirmUnsetSponsorFail + ); + + Self::deposit_event(UniqueEvent::::SponsorshipConfirmed( + collection_id, + sponsor_id, + )); + + target_collection.save() + } + + fn remove_collection_sponsor(collection_id: Self::CollectionId) -> DispatchResult { + let mut target_collection = >::try_get(collection_id)?; + target_collection.check_is_internal()?; + target_collection.sponsorship = SponsorshipState::Disabled; + + Self::deposit_event(UniqueEvent::::CollectionSponsorRemoved(collection_id)); + + target_collection.save() + } + + fn get_sponsor( + collection_id: Self::CollectionId, + ) -> Result, DispatchError> { + Ok(>::try_get(collection_id)? + .sponsorship + .pending_sponsor() + .map(|acc| acc.to_owned())) + } +} --- a/pallets/unique/src/lib.rs +++ b/pallets/unique/src/lib.rs @@ -277,7 +277,7 @@ { type Error = Error; - fn deposit_event() = default; + pub fn deposit_event() = default; fn on_initialize(_now: T::BlockNumber) -> Weight { 0 --- a/runtime/common/config/pallets/app_promotion.rs +++ b/runtime/common/config/pallets/app_promotion.rs @@ -16,12 +16,36 @@ use crate::{ runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider}, - Runtime, Balances, + Runtime, Balances, BlockNumber, Unique, Event, +}; + +use frame_support::{parameter_types, PalletId}; +use sp_arithmetic::Perbill; +use up_common::{ + constants::{DAYS, UNIQUE}, + types::Balance, }; +parameter_types! { + pub const AppPromotionId: PalletId = PalletId(*b"appstake"); + pub const RecalculationInterval: BlockNumber = 20; + pub const PendingInterval: BlockNumber = 10; + pub const Nominal: Balance = UNIQUE; + pub const Day: BlockNumber = DAYS; + pub IntervalIncome: Perbill = Perbill::from_rational(RecalculationInterval::get(), 2 * DAYS) * Perbill::from_rational(5u32, 10_000); +} + impl pallet_app_promotion::Config for Runtime { + type PalletId = AppPromotionId; + type CollectionHandler = Unique; type Currency = Balances; type WeightInfo = pallet_app_promotion::weights::SubstrateWeight; type TreasuryAccountId = TreasuryAccountId; - type BlockNumberProvider = RelayChainBlockNumberProvider; + type RelayBlockNumberProvider = RelayChainBlockNumberProvider; + type RecalculationInterval = RecalculationInterval; + type PendingInterval = PendingInterval; + type Day = Day; + type Nominal = Nominal; + type IntervalIncome = IntervalIncome; + type Event = Event; } --- a/runtime/common/construct_runtime/mod.rs +++ b/runtime/common/construct_runtime/mod.rs @@ -78,7 +78,7 @@ RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event} = 72, #[runtimes(opal)] - Promotion: pallet_app_promotion::{Pallet, Call, Storage} = 73, + Promotion: pallet_app_promotion::{Pallet, Call, Storage, Event} = 73, // Frontier EVM: pallet_evm::{Pallet, Config, Call, Storage, Event} = 100, --- a/tests/src/app-promotion.test.ts +++ b/tests/src/app-promotion.test.ts @@ -40,32 +40,32 @@ import chai, {use} from 'chai'; import chaiAsPromised from 'chai-as-promised'; -import getBalance, {getBalanceSingle} from './substrate/get-balance'; -import {unique} from './interfaces/definitions'; import {usingPlaygrounds} from './util/playgrounds'; import {default as waitNewBlocks} from './substrate/wait-new-blocks'; -import BN from 'bn.js'; -import {mnemonicGenerate} from '@polkadot/util-crypto'; +import {encodeAddress, hdEthereum, mnemonicGenerate} from '@polkadot/util-crypto'; +import {stringToU8a} from '@polkadot/util'; import {UniqueHelper} from './util/playgrounds/unique'; +import {ApiPromise} from '@polkadot/api'; chai.use(chaiAsPromised); const expect = chai.expect; let alice: IKeyringPair; let bob: IKeyringPair; let palletAdmin: IKeyringPair; -let nominal: bigint; +let nominal: bigint; +let promotionStartBlock: number | null = null; -describe('integration test: AppPromotion', () => { +describe('app-promotions.stake extrinsic', () => { before(async function() { await usingPlaygrounds(async (helper, privateKeyWrapper) => { if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); alice = privateKeyWrapper('//Alice'); bob = privateKeyWrapper('//Bob'); palletAdmin = privateKeyWrapper('//palletAdmin'); - const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw)); + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); nominal = helper.balance.getOneTokenNominal(); - await submitTransactionAsync(alice, tx); + await helper.signTransaction(alice, tx); }); }); it('will change balance state to "locked", add it to "staked" map, and increase "totalStaked" amount', async () => { @@ -85,18 +85,19 @@ const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt(); const staker = await createUser(); - const firstStakedBlock = await helper.chain.getLatestBlockNumber(); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled; + + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(nominal / 2n))).to.be.eventually.rejected; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled; expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal); expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true; expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal); expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal); await waitNewBlocks(helper.api!, 1); - const secondStakedBlock = await helper.chain.getLatestBlockNumber(); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled; + + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled; expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal); const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]); @@ -115,9 +116,9 @@ const staker = await createUser(); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected; - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled; - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected; }); }); @@ -128,17 +129,10 @@ // assert: query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100] await usingPlaygrounds(async helper => { - // const userOne = await createUser(); - // const userTwo = await createUser(); - // const userThree = await createUser(); - // const userFour = await createUser(); const crowd = []; for(let i = 4; i--;) crowd.push(await createUser()); - // const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper); - // const crowd = [userOne, userTwo, userThree, userFour]; - - const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal))); + const promises = crowd.map(async user => helper.signTransaction(user, helper.api!.tx.promotion.stake(nominal))); await expect(Promise.all(promises)).to.be.eventually.fulfilled; for (let i = 0; i < crowd.length; i++){ @@ -156,9 +150,9 @@ alice = privateKeyWrapper('//Alice'); bob = privateKeyWrapper('//Bob'); palletAdmin = privateKeyWrapper('//palletAdmin'); - const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw)); + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); nominal = helper.balance.getOneTokenNominal(); - await submitTransactionAsync(alice, tx); + await helper.signTransaction(alice, tx); }); }); @@ -174,8 +168,8 @@ await usingPlaygrounds(async helper => { const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt(); const staker = await createUser(); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled; - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled; expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal); expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(2n * nominal); expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + 2n * nominal); @@ -204,18 +198,18 @@ await usingPlaygrounds(async helper => { const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt(); const staker = await createUser(); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled; - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled; - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled; let stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()); expect(stakedPerBlock).to.be.deep.equal([nominal, 2n * nominal, 3n * nominal]); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled; expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal / 10n); stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()); expect(stakedPerBlock).to.be.deep.equal([7n * nominal / 10n, 2n * nominal, 3n * nominal]); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled; stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()); expect(stakedPerBlock).to.be.deep.equal([nominal, 3n * nominal]); const unstakedPerBlock = (await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()); @@ -223,7 +217,7 @@ expect(unstakedPerBlock).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n]); await waitNewBlocks(helper.api!, 1); - await expect(submitTransactionAsync(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled; expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([]); expect((await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n, 4n * nominal]); }); @@ -232,9 +226,643 @@ }); + +describe('Admin adress', () => { + before(async function () { + await usingPlaygrounds(async (helper, privateKeyWrapper) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + palletAdmin = privateKeyWrapper('//palletAdmin'); + await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal()); + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); + + await helper.signTransaction(alice, tx); + + nominal = helper.balance.getOneTokenNominal(); + }); + }); + + it('can be set by sudo only', async () => { + // assert: Sudo calls appPromotion.setAdminAddress(Alice) /// Sudo successfully sets Alice as admin + // assert: Bob calls appPromotion.setAdminAddress(Bob) throws /// Random account can not set admin + // assert: Alice calls appPromotion.setAdminAddress(Bob) throws /// Admin account can not set admin + await usingPlaygrounds(async (helper) => { + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(bob, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.rejected; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled; + }); + + }); + + it('can be any valid CrossAccountId', async () => { + /// We are not going to set an eth address as a sponsor, + /// but we do want to check, it doesn't break anything; + + // arrange: Charlie creates Punks + // arrange: Sudo calls appPromotion.setAdminAddress(0x0...) success + // arrange: Sudo calls appPromotion.setAdminAddress(Alice) success + + // assert: Alice calls appPromotion.sponsorCollection(Punks.id) success + + await usingPlaygrounds(async (helper) => { + + const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'}; + + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(ethAcc)))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))))).to.be.eventually.fulfilled; + + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled; + }); + + }); + + it('can be reassigned', async () => { + // arrange: Charlie creates Punks + // arrange: Sudo calls appPromotion.setAdminAddress(Alice) + // act: Sudo calls appPromotion.setAdminAddress(Bob) + + // assert: Alice calls appPromotion.sponsorCollection(Punks.id) throws /// Alice can not set collection sponsor + // assert: Bob calls appPromotion.sponsorCollection(Punks.id) successful /// Bob can set collection sponsor + + // act: Sudo calls appPromotion.setAdminAddress(null) successful /// Sudo can set null as a sponsor + // assert: Bob calls appPromotion.stopSponsoringCollection(Punks.id) throws /// Bob is no longer an admin + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected; + + await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled; + }); + + }); + +}); + +describe('App-promotion collection sponsoring', () => { + before(async function () { + await usingPlaygrounds(async (helper, privateKeyWrapper) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + palletAdmin = privateKeyWrapper('//palletAdmin'); + await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal()); + await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal()); + + + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); + await helper.signTransaction(alice, tx); + + // const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock)); + // await helper.signTransaction(alice, txStart); + + nominal = helper.balance.getOneTokenNominal(); + }); + }); + + it('can not be set by non admin', async () => { + + + // arrange: Charlie creates Punks + // arrange: Sudo calls appPromotion.setAdminAddress(Alice) + + // assert: Random calls appPromotion.sponsorCollection(Punks.id) throws /// Random account can not set sponsoring + // assert: Alice calls appPromotion.sponsorCollection(Punks.id) success /// Admin account can set sponsoring + + await usingPlaygrounds(async (helper) => { + const colletcion = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + + const collectionId = colletcion.collectionId; + + await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + }); + + }); + + it('will set pallet address as confirmed admin for collection without sponsor', async () => { + // arrange: Charlie creates Punks + + // act: Admin calls appPromotion.sponsorCollection(Punks.id) + + // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')}); + }); + + }); + + it('will set pallet address as confirmed admin for collection with unconfirmed sponsor', async () => { + // arrange: Charlie creates Punks + // arrange: Charlie calls setCollectionSponsor(Punks.Id, Dave) /// Dave is unconfirmed sponsor + + // act: Admin calls appPromotion.sponsorCollection(Punks.id) + + // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + await collection.setSponsor(alice, bob.address); + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address}); + + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')}); + }); + + }); + + it('will set pallet address as confirmed admin for collection with confirmed sponsor', async () => { + // arrange: Charlie creates Punks + // arrange: setCollectionSponsor(Punks.Id, Dave) + // arrange: confirmSponsorship(Punks.Id, Dave) /// Dave is confirmed sponsor + + // act: Admin calls appPromotion.sponsorCollection(Punks.id) + + // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + await collection.setSponsor(alice, bob.address); + + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address}); + expect(await collection.confirmSponsorship(bob)).to.be.true; + + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')}); + }); + }); + + it('can be overwritten by collection owner', async () => { + // arrange: Charlie creates Punks + // arrange: appPromotion.sponsorCollection(Punks.Id) /// Sponsor of Punks is pallete + + // act: Charlie calls unique.setCollectionLimits(limits) /// Charlie as owner can successfully change limits + // assert: query collectionById(Punks.id) 1. sponsored by pallete, 2. limits has been changed + + // act: Charlie calls setCollectionSponsor(Dave) /// Collection owner reasignes sponsoring + // assert: query collectionById: Punks sponsoring is unconfirmed by Dave + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')}); + + expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true; + expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0); + + expect((await collection.setSponsor(alice, bob.address))).to.be.true; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address}); + }); + + }); + + it('will keep collection limits set by the owner earlier', async () => { + // arrange: const limits = {...all possible collection limits} + // arrange: Charlie creates Punks + // arrange: Charlie calls unique.setCollectionLimits(limits) /// Owner sets all possible limits + + // act: Admin calls appPromotion.sponsorCollection(Punks.id) + // assert: query collectionById(Punks.id) returns limits + + await usingPlaygrounds(async (helper) => { + + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true; + const limits = (await collection.getData())?.raw.limits; + + const collectionId = collection.collectionId; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + expect((await collection.getData())?.raw.limits).to.be.deep.equal(limits); + }); + + }); + + it('will throw if collection doesn\'t exist', async () => { + // assert: Admin calls appPromotion.sponsorCollection(999999999999999) throw + await usingPlaygrounds(async (helper) => { + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected; + }); + }); + + it('will throw if collection was burnt', async () => { + // arrange: Charlie creates Punks + // arrange: Charlie burns Punks + + // assert: Admin calls appPromotion.sponsorCollection(Punks.id) throw + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + expect((await collection.burn(alice))).to.be.true; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected; + }); + + }); +}); + + +describe('app-promotion stopSponsoringCollection', () => { + before(async function () { + await usingPlaygrounds(async (helper, privateKeyWrapper) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + palletAdmin = privateKeyWrapper('//palletAdmin'); + await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal()); + await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal()); + + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); + await helper.signTransaction(alice, tx); + + nominal = helper.balance.getOneTokenNominal(); + }); + }); + + it('can not be called by non-admin', async () => { + // arrange: Alice creates Punks + // arrange: appPromotion.sponsorCollection(Punks.Id) + + // assert: Random calls appPromotion.stopSponsoringCollection(Punks) throws + // assert: query collectionById(Punks.id): sponsoring confirmed by PalleteAddress + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + + await expect(helper.signTransaction(bob, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')}); + }); + }); + + it('will set sponsoring as disabled', async () => { + // arrange: Alice creates Punks + // arrange: appPromotion.sponsorCollection(Punks.Id) + + // act: Admin calls appPromotion.stopSponsoringCollection(Punks) + + // assert: query collectionById(Punks.id): sponsoring unconfirmed + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.fulfilled; + + expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled'); + }); + }); + + it('will not affect collection which is not sponsored by pallete', async () => { + // arrange: Alice creates Punks + // arrange: Alice calls setCollectionSponsoring(Punks) + // arrange: Alice calls confirmSponsorship(Punks) + + // act: Admin calls appPromotion.stopSponsoringCollection(A) + // assert: query collectionById(Punks): Sponsoring: {Confirmed: Alice} /// Alice still collection owner + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + expect(await collection.setSponsor(alice, alice.address)).to.be.true; + expect(await collection.confirmSponsorship(alice)).to.be.true; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected; + + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: alice.address}); + }); + + }); + + it('will throw if collection does not exist', async () => { + // arrange: Alice creates Punks + // arrange: Alice burns Punks + + // assert: Admin calls appPromotion.stopSponsoringCollection(Punks.id) throws + // assert: Admin calls appPromotion.stopSponsoringCollection(999999999999999) throw + + await usingPlaygrounds(async (helper) => { + const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); + const collectionId = collection.collectionId; + + expect((await collection.burn(alice))).to.be.true; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected; + }); + }); +}); + +describe('app-promotion contract sponsoring', () => { + it('will set contract sponsoring mode and set palletes address as a sponsor', async () => { + // arrange: Alice deploys Flipper + + // act: Admin calls appPromotion.sponsorContract(Flipper.address) + + // assert: contract.sponsoringMode = TODO + // assert: contract.sponsor to be PalleteAddress + }); + + it('will overwrite sponsoring mode and existed sponsor', async () => { + // arrange: Alice deploys Flipper + // arrange: Alice sets self sponsoring for Flipper + + // act: Admin calls appPromotion.sponsorContract(Flipper.address) + + // assert: contract.sponsoringMode = TODO + // assert: contract.sponsor to be PalleteAddress + }); + + it('can be overwritten by contract owner', async () => { + // arrange: Alice deploys Flipper + // arrange: Admin calls appPromotion.sponsorContract(Flipper.address) + + // act: Alice sets self sponsoring for Flipper + + // assert: contract.sponsoringMode = Self + // assert: contract.sponsor to be contract + }); + + it('can not be set by non admin', async () => { + // arrange: Alice deploys Flipper + // arrange: Alice sets self sponsoring for Flipper + + // assert: Random calls appPromotion.sponsorContract(Flipper.address) throws + // assert: contract.sponsoringMode = Self + // assert: contract.sponsor to be contract + }); + + it('will return unused gas fee to app-promotion pallete', async () => { + // arrange: Alice deploys Flipper + // arrange: Admin calls appPromotion.sponsorContract(Flipper.address) + + // assert: Bob calls Flipper - expect balances deposit event do not appears for Bob /// Unused gas fee returns to contract + // assert: Bobs balance the same + }); + + it('will failed for non contract address', async () => { + // arrange: web3 creates new address - 0x0 + + // assert: Admin calls appPromotion.sponsorContract(0x0) throws + // assert: Admin calls appPromotion.sponsorContract(Substrate address) throws + }); + + it('will actually sponsor transactions', async () => { + // TODO test it because this is a new way of contract sponsoring + }); +}); + +describe('app-promotion stopSponsoringContract', () => { + before(async function () { + await usingPlaygrounds(async (helper, privateKeyWrapper) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + palletAdmin = privateKeyWrapper('//palletAdmin'); + await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal()); + await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal()); + + const promotionStartBlock = await helper.chain.getLatestBlockNumber(); + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); + await helper.signTransaction(alice, tx); + + const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock)); + await helper.signTransaction(alice, txStart); + + nominal = helper.balance.getOneTokenNominal(); + }); + }); + + it('will set contract sponsoring mode as disabled', async () => { + // arrange: Alice deploys Flipper + // arrange: Admin calls appPromotion.sponsorContract(Flipper.address) + + // act: Admin calls appPromotion.stopSponsoringContract(Flipper.address) + // assert: contract sponsoring mode = TODO + + // act: Bob calls Flipper + + // assert: PalleteAddress balance did not change + // assert: Bobs balance less than before /// Bob payed some fee + }); + + it('can not be called by non-admin', async () => { + // arrange: Alice deploys Flipper + // arrange: Admin calls appPromotion.sponsorContract(Flipper.address) + + // assert: Random calls appPromotion.stopSponsoringContract(Flipper.address) throws + // assert: contract sponsor is PallereAddress + }); + + it('will not affect a contract which is not sponsored by pallete', async () => { + // arrange: Alice deploys Flipper + // arrange: Alice sets self sponsoring for Flipper + + // act: Admin calls appPromotion.stopSponsoringContract(Flipper.address) throws + + // assert: contract.sponsoringMode = Self + // assert: contract.sponsor to be contract + }); + + it('will failed for non contract address', async () => { + // arrange: web3 creates new address - 0x0 + + // expect stopSponsoringContract(0x0) throws + }); +}); + +describe('app-promotion rewards', () => { + const DAY = 7200n; + + + before(async function () { + await usingPlaygrounds(async (helper, privateKeyWrapper) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + palletAdmin = privateKeyWrapper('//palletAdmin'); + if (promotionStartBlock == null) { + promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber(); + } + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))); + await helper.signTransaction(alice, tx); + + const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!)); + await helper.signTransaction(alice, txStart); + + nominal = helper.balance.getOneTokenNominal(); + }); + }); + + it('will credit 0.05% for staking period', async () => { + // arrange: bob.stake(10000); + // arrange: bob.stake(20000); + // arrange: waitForRewards(); + + // assert: bob.staked to equal [10005, 20010] + + await usingPlaygrounds(async helper => { + const staker = await createUser(50n * nominal); + await waitForRecalculationBlock(helper.api!); + + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled; + await waitForRelayBlock(helper.api!, 36); + + + expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))) + .map(([_, amount]) => amount.toBigInt())) + .to.be.deep.equal([calculateIncome(nominal, 10n), calculateIncome(2n * nominal, 10n)]); + }); + + }); + + it('will not be credited for unstaked (reserved) balance', async () => { + // arrange: bob.stake(10000); + // arrange: bob.unstake(5000); + // arrange: waitForRewards(); + + // assert: bob.staked to equal [5002.5] + await usingPlaygrounds(async helper => { + const staker = await createUser(20n * nominal); + await waitForRecalculationBlock(helper.api!); + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(5n * nominal))).to.be.eventually.fulfilled; + await waitForRelayBlock(helper.api!, 38); + + expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))) + .map(([_, amount]) => amount.toBigInt())) + .to.be.deep.equal([calculateIncome(5n * nominal, 10n)]); + + }); + + }); + + it('will bring compound interest', async () => { + // arrange: bob balance = 30000 + // arrange: bob.stake(10000); + // arrange: bob.stake(10000); + // arrange: waitForRewards(); + + // assert: bob.staked() equal [10005, 10005, 10005] /// 10_000 * 1.0005 + // act: waitForRewards(); + + // assert: bob.staked() equal [10010.0025, 10010.0025, 10010.0025] /// 10_005 * 1.0005 + // act: bob.unstake(10.0025) + // assert: bob.staked() equal [10000, 10010.0025, 10010.0025] /// 10_005 * 1.0005 + + // act: waitForRewards(); + // assert: bob.staked() equal [10005, 10015,00750125, 10015,00750125] /// + await usingPlaygrounds(async helper => { + const staker = await createUser(40n * nominal); + + await waitForRecalculationBlock(helper.api!); + // const foo = await helper.api!.registry.getChainProperties(). + + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled; + // await waitNewBlocks(helper.api!, 1); + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled; + // await waitNewBlocks(helper.api!, 1); + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled; + // console.log(await helper.balance.getSubstrate(staker.address)); + // await waitNewBlocks(helper.api!, 17); + await waitForRelayBlock(helper.api!, 34); + expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))) + .map(([_, amount]) => amount.toBigInt())) + .to.be.deep.equal([calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n)]); + + // console.log(await getBlockNumber(helper.api!)); + // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()])); + // console.log(`${calculateIncome(10n * nominal, 10n)} || ${calculateIncome(10n * nominal, 10n, 2)}`); + // await waitNewBlocks(helper.api!, 10); + await waitForRelayBlock(helper.api!, 20); + // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())); + // console.log(await helper.balance.getSubstrate(staker.address)); + await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(calculateIncome(10n * nominal, 10n, 2) - 10n * nominal))).to.be.eventually.fulfilled; + // console.log(calculateIncome(10n * nominal, 10n, 2)); + // console.log(calculateIncome(10n * nominal, 10n, 3)); + // console.log(calculateIncome(10n * nominal, 10n, 4)); + // console.log(calculateIncome(10n * nominal, 10n, 5)); + expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))) + .map(([_, amount]) => amount.toBigInt())) + .to.be.deep.equal([10n * nominal, calculateIncome(10n * nominal, 10n, 2), calculateIncome(10n * nominal, 10n, 2)]); + + // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())); + + // console.log(await helper.balance.getSubstrate(staker.address)); + }); + + }); +}); + + +function waitForRecalculationBlock(api: ApiPromise): Promise { + return new Promise(async (resolve, reject) => { + const unsubscribe = await api.query.system.events((events) => { + + events.forEach((record) => { + + const {event, phase} = record; + const types = event.typeDef; + + if (event.section === 'promotion' && event.method === 'StakingRecalculation') { + unsubscribe(); + resolve(); + } + }); + }); + }); +} + +async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise { + const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber(); + return new Promise(async (resolve, reject) => { + const unsubscribe = await api.query.parachainSystem.validationData(async (data) => { + // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`); + if (data.value.relayParentNumber.toNumber() - current_block >= blocks) { + unsubscribe(); + resolve(); + } + }); + }); + +} + + +function calculatePalleteAddress(palletId: any) { + const address = stringToU8a(('modl' + palletId).padEnd(32, '\0')); + return encodeAddress(address); +} +function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint { + const DAY = 7200n; + const ACCURACY = 1_000_000_000n; + const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ; + + if (iter > 1) { + return calculateIncome(income, calcPeriod, iter - 1); + } else return income; +} + async function createUser(amount?: bigint) { - return await usingPlaygrounds(async (helper, privateKeyWrapper) => { - const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`); + return await usingPlaygrounds(async helper => { + const user: IKeyringPair = helper.util.fromSeed(mnemonicGenerate()); await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal()); return user; }); --- a/tests/src/interfaces/augment-api-consts.ts +++ b/tests/src/interfaces/augment-api-consts.ts @@ -8,7 +8,7 @@ import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types'; import type { Option, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { Codec } from '@polkadot/types-codec/types'; -import type { Permill } from '@polkadot/types/interfaces/runtime'; +import type { Perbill, Permill } from '@polkadot/types/interfaces/runtime'; import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup'; export type __AugmentedConst = AugmentedConst; @@ -66,6 +66,30 @@ **/ [key: string]: Codec; }; + promotion: { + /** + * In chain blocks. + **/ + day: u32 & AugmentedConst; + intervalIncome: Perbill & AugmentedConst; + nominal: u128 & AugmentedConst; + /** + * The app's pallet id, used for deriving its sovereign account ID. + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * In chain blocks. + **/ + pendingInterval: u32 & AugmentedConst; + /** + * In relay blocks. + **/ + recalculationInterval: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; scheduler: { /** * The maximum weight that may be scheduled per block for any dispatchables of less --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -425,6 +425,23 @@ **/ [key: string]: AugmentedError; }; + promotion: { + AdminNotSet: AugmentedError; + AlreadySponsored: AugmentedError; + InvalidArgument: AugmentedError; + /** + * No permission to perform action + **/ + NoPermission: AugmentedError; + /** + * Insufficient funds to perform an action + **/ + NotSufficientFounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; refungible: { /** * Not Refungible item data used to mint in Refungible collection. --- a/tests/src/interfaces/augment-api-events.ts +++ b/tests/src/interfaces/augment-api-events.ts @@ -360,6 +360,13 @@ **/ [key: string]: AugmentedEvent; }; + promotion: { + StakingRecalculation: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; rmrkCore: { CollectionCreated: AugmentedEvent; CollectionDestroyed: AugmentedEvent; --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -363,9 +363,11 @@ [key: string]: SubmittableExtrinsicFunction; }; promotion: { - setAdminAddress: AugmentedSubmittable<(admin: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletEvmAccountBasicCrossAccountIdRepr]>; + sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; - startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + startAppPromotion: AugmentedSubmittable<(promotionStartRelayBlock: Option | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic, [Option]>; + stopSponsorignCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; unstake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; /** * Generic tx --- a/tests/src/interfaces/augment-types.ts +++ b/tests/src/interfaces/augment-types.ts @@ -5,7 +5,7 @@ // this is required to allow for ambient/previous definitions import '@polkadot/types/types/registry'; -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './default'; import type { Data, StorageKey } from '@polkadot/types'; import type { BitVec, Bool, Bytes, F32, F64, I128, I16, I256, I32, I64, I8, Json, Null, OptionBool, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, f32, f64, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec'; import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets'; @@ -805,6 +805,8 @@ PageCounter: PageCounter; PageIndexData: PageIndexData; PalletAppPromotionCall: PalletAppPromotionCall; + PalletAppPromotionError: PalletAppPromotionError; + PalletAppPromotionEvent: PalletAppPromotionEvent; PalletBalancesAccountData: PalletBalancesAccountData; PalletBalancesBalanceLock: PalletBalancesBalanceLock; PalletBalancesCall: PalletBalancesCall; --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -810,11 +810,11 @@ export interface PalletAppPromotionCall extends Enum { readonly isSetAdminAddress: boolean; readonly asSetAdminAddress: { - readonly admin: AccountId32; + readonly admin: PalletEvmAccountBasicCrossAccountIdRepr; } & Struct; readonly isStartAppPromotion: boolean; readonly asStartAppPromotion: { - readonly promotionStartRelayBlock: u32; + readonly promotionStartRelayBlock: Option; } & Struct; readonly isStake: boolean; readonly asStake: { @@ -824,7 +824,32 @@ readonly asUnstake: { readonly amount: u128; } & Struct; - readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake'; + readonly isSponsorCollection: boolean; + readonly asSponsorCollection: { + readonly collectionId: u32; + } & Struct; + readonly isStopSponsorignCollection: boolean; + readonly asStopSponsorignCollection: { + readonly collectionId: u32; + } & Struct; + readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsorignCollection'; +} + +/** @name PalletAppPromotionError */ +export interface PalletAppPromotionError extends Enum { + readonly isAdminNotSet: boolean; + readonly isNoPermission: boolean; + readonly isNotSufficientFounds: boolean; + readonly isInvalidArgument: boolean; + readonly isAlreadySponsored: boolean; + readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'InvalidArgument' | 'AlreadySponsored'; +} + +/** @name PalletAppPromotionEvent */ +export interface PalletAppPromotionEvent extends Enum { + readonly isStakingRecalculation: boolean; + readonly asStakingRecalculation: ITuple<[u128, u128]>; + readonly type: 'StakingRecalculation'; } /** @name PalletBalancesAccountData */ --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -1057,7 +1057,15 @@ } }, /** - * Lookup103: pallet_evm::pallet::Event + * Lookup103: pallet_app_promotion::pallet::Event + **/ + PalletAppPromotionEvent: { + _enum: { + StakingRecalculation: '(u128,u128)' + } + }, + /** + * Lookup104: pallet_evm::pallet::Event **/ PalletEvmEvent: { _enum: { @@ -1071,7 +1079,7 @@ } }, /** - * Lookup104: ethereum::log::Log + * Lookup105: ethereum::log::Log **/ EthereumLog: { address: 'H160', @@ -1079,7 +1087,7 @@ data: 'Bytes' }, /** - * Lookup108: pallet_ethereum::pallet::Event + * Lookup109: pallet_ethereum::pallet::Event **/ PalletEthereumEvent: { _enum: { @@ -1087,7 +1095,7 @@ } }, /** - * Lookup109: evm_core::error::ExitReason + * Lookup110: evm_core::error::ExitReason **/ EvmCoreErrorExitReason: { _enum: { @@ -1098,13 +1106,13 @@ } }, /** - * Lookup110: evm_core::error::ExitSucceed + * Lookup111: evm_core::error::ExitSucceed **/ EvmCoreErrorExitSucceed: { _enum: ['Stopped', 'Returned', 'Suicided'] }, /** - * Lookup111: evm_core::error::ExitError + * Lookup112: evm_core::error::ExitError **/ EvmCoreErrorExitError: { _enum: { @@ -1126,13 +1134,13 @@ } }, /** - * Lookup114: evm_core::error::ExitRevert + * Lookup115: evm_core::error::ExitRevert **/ EvmCoreErrorExitRevert: { _enum: ['Reverted'] }, /** - * Lookup115: evm_core::error::ExitFatal + * Lookup116: evm_core::error::ExitFatal **/ EvmCoreErrorExitFatal: { _enum: { @@ -1143,7 +1151,7 @@ } }, /** - * Lookup116: frame_system::Phase + * Lookup117: frame_system::Phase **/ FrameSystemPhase: { _enum: { @@ -1153,14 +1161,14 @@ } }, /** - * Lookup118: frame_system::LastRuntimeUpgradeInfo + * Lookup119: frame_system::LastRuntimeUpgradeInfo **/ FrameSystemLastRuntimeUpgradeInfo: { specVersion: 'Compact', specName: 'Text' }, /** - * Lookup119: frame_system::pallet::Call + * Lookup120: frame_system::pallet::Call **/ FrameSystemCall: { _enum: { @@ -1198,7 +1206,7 @@ } }, /** - * Lookup124: frame_system::limits::BlockWeights + * Lookup125: frame_system::limits::BlockWeights **/ FrameSystemLimitsBlockWeights: { baseBlock: 'u64', @@ -1206,7 +1214,7 @@ perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass' }, /** - * Lookup125: frame_support::weights::PerDispatchClass + * Lookup126: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassWeightsPerClass: { normal: 'FrameSystemLimitsWeightsPerClass', @@ -1214,7 +1222,7 @@ mandatory: 'FrameSystemLimitsWeightsPerClass' }, /** - * Lookup126: frame_system::limits::WeightsPerClass + * Lookup127: frame_system::limits::WeightsPerClass **/ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: 'u64', @@ -1223,13 +1231,13 @@ reserved: 'Option' }, /** - * Lookup128: frame_system::limits::BlockLength + * Lookup129: frame_system::limits::BlockLength **/ FrameSystemLimitsBlockLength: { max: 'FrameSupportWeightsPerDispatchClassU32' }, /** - * Lookup129: frame_support::weights::PerDispatchClass + * Lookup130: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassU32: { normal: 'u32', @@ -1237,14 +1245,14 @@ mandatory: 'u32' }, /** - * Lookup130: frame_support::weights::RuntimeDbWeight + * Lookup131: frame_support::weights::RuntimeDbWeight **/ FrameSupportWeightsRuntimeDbWeight: { read: 'u64', write: 'u64' }, /** - * Lookup131: sp_version::RuntimeVersion + * Lookup132: sp_version::RuntimeVersion **/ SpVersionRuntimeVersion: { specName: 'Text', @@ -1257,13 +1265,13 @@ stateVersion: 'u8' }, /** - * Lookup136: frame_system::pallet::Error + * Lookup137: frame_system::pallet::Error **/ FrameSystemError: { _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'] }, /** - * Lookup137: polkadot_primitives::v2::PersistedValidationData + * Lookup138: polkadot_primitives::v2::PersistedValidationData **/ PolkadotPrimitivesV2PersistedValidationData: { parentHead: 'Bytes', @@ -1272,19 +1280,19 @@ maxPovSize: 'u32' }, /** - * Lookup140: polkadot_primitives::v2::UpgradeRestriction + * Lookup141: polkadot_primitives::v2::UpgradeRestriction **/ PolkadotPrimitivesV2UpgradeRestriction: { _enum: ['Present'] }, /** - * Lookup141: sp_trie::storage_proof::StorageProof + * Lookup142: sp_trie::storage_proof::StorageProof **/ SpTrieStorageProof: { trieNodes: 'BTreeSet' }, /** - * Lookup143: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot + * Lookup144: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot **/ CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: { dmqMqcHead: 'H256', @@ -1293,7 +1301,7 @@ egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>' }, /** - * Lookup146: polkadot_primitives::v2::AbridgedHrmpChannel + * Lookup147: polkadot_primitives::v2::AbridgedHrmpChannel **/ PolkadotPrimitivesV2AbridgedHrmpChannel: { maxCapacity: 'u32', @@ -1304,7 +1312,7 @@ mqcHead: 'Option' }, /** - * Lookup147: polkadot_primitives::v2::AbridgedHostConfiguration + * Lookup148: polkadot_primitives::v2::AbridgedHostConfiguration **/ PolkadotPrimitivesV2AbridgedHostConfiguration: { maxCodeSize: 'u32', @@ -1318,14 +1326,14 @@ validationUpgradeDelay: 'u32' }, /** - * Lookup153: polkadot_core_primitives::OutboundHrmpMessage + * Lookup154: polkadot_core_primitives::OutboundHrmpMessage **/ PolkadotCorePrimitivesOutboundHrmpMessage: { recipient: 'u32', data: 'Bytes' }, /** - * Lookup154: cumulus_pallet_parachain_system::pallet::Call + * Lookup155: cumulus_pallet_parachain_system::pallet::Call **/ CumulusPalletParachainSystemCall: { _enum: { @@ -1344,7 +1352,7 @@ } }, /** - * Lookup155: cumulus_primitives_parachain_inherent::ParachainInherentData + * Lookup156: cumulus_primitives_parachain_inherent::ParachainInherentData **/ CumulusPrimitivesParachainInherentParachainInherentData: { validationData: 'PolkadotPrimitivesV2PersistedValidationData', @@ -1353,27 +1361,27 @@ horizontalMessages: 'BTreeMap>' }, /** - * Lookup157: polkadot_core_primitives::InboundDownwardMessage + * Lookup158: polkadot_core_primitives::InboundDownwardMessage **/ PolkadotCorePrimitivesInboundDownwardMessage: { sentAt: 'u32', msg: 'Bytes' }, /** - * Lookup160: polkadot_core_primitives::InboundHrmpMessage + * Lookup161: polkadot_core_primitives::InboundHrmpMessage **/ PolkadotCorePrimitivesInboundHrmpMessage: { sentAt: 'u32', data: 'Bytes' }, /** - * Lookup163: cumulus_pallet_parachain_system::pallet::Error + * Lookup164: cumulus_pallet_parachain_system::pallet::Error **/ CumulusPalletParachainSystemError: { _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized'] }, /** - * Lookup165: pallet_balances::BalanceLock + * Lookup166: pallet_balances::BalanceLock **/ PalletBalancesBalanceLock: { id: '[u8;8]', @@ -1381,26 +1389,26 @@ reasons: 'PalletBalancesReasons' }, /** - * Lookup166: pallet_balances::Reasons + * Lookup167: pallet_balances::Reasons **/ PalletBalancesReasons: { _enum: ['Fee', 'Misc', 'All'] }, /** - * Lookup169: pallet_balances::ReserveData + * Lookup170: pallet_balances::ReserveData **/ PalletBalancesReserveData: { id: '[u8;16]', amount: 'u128' }, /** - * Lookup171: pallet_balances::Releases + * Lookup172: pallet_balances::Releases **/ PalletBalancesReleases: { _enum: ['V1_0_0', 'V2_0_0'] }, /** - * Lookup172: pallet_balances::pallet::Call + * Lookup173: pallet_balances::pallet::Call **/ PalletBalancesCall: { _enum: { @@ -1433,13 +1441,13 @@ } }, /** - * Lookup175: pallet_balances::pallet::Error + * Lookup176: pallet_balances::pallet::Error **/ PalletBalancesError: { _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'KeepAlive', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves'] }, /** - * Lookup177: pallet_timestamp::pallet::Call + * Lookup178: pallet_timestamp::pallet::Call **/ PalletTimestampCall: { _enum: { @@ -1449,13 +1457,13 @@ } }, /** - * Lookup179: pallet_transaction_payment::Releases + * Lookup180: pallet_transaction_payment::Releases **/ PalletTransactionPaymentReleases: { _enum: ['V1Ancient', 'V2'] }, /** - * Lookup180: pallet_treasury::Proposal + * Lookup181: pallet_treasury::Proposal **/ PalletTreasuryProposal: { proposer: 'AccountId32', @@ -1464,7 +1472,7 @@ bond: 'u128' }, /** - * Lookup183: pallet_treasury::pallet::Call + * Lookup184: pallet_treasury::pallet::Call **/ PalletTreasuryCall: { _enum: { @@ -1488,17 +1496,17 @@ } }, /** - * Lookup186: frame_support::PalletId + * Lookup187: frame_support::PalletId **/ FrameSupportPalletId: '[u8;8]', /** - * Lookup187: pallet_treasury::pallet::Error + * Lookup188: pallet_treasury::pallet::Error **/ PalletTreasuryError: { _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved'] }, /** - * Lookup188: pallet_sudo::pallet::Call + * Lookup189: pallet_sudo::pallet::Call **/ PalletSudoCall: { _enum: { @@ -1522,7 +1530,7 @@ } }, /** - * Lookup190: orml_vesting::module::Call + * Lookup191: orml_vesting::module::Call **/ OrmlVestingModuleCall: { _enum: { @@ -1541,7 +1549,7 @@ } }, /** - * Lookup192: cumulus_pallet_xcmp_queue::pallet::Call + * Lookup193: cumulus_pallet_xcmp_queue::pallet::Call **/ CumulusPalletXcmpQueueCall: { _enum: { @@ -1590,7 +1598,7 @@ } }, /** - * Lookup193: pallet_xcm::pallet::Call + * Lookup194: pallet_xcm::pallet::Call **/ PalletXcmCall: { _enum: { @@ -1644,7 +1652,7 @@ } }, /** - * Lookup194: xcm::VersionedXcm + * Lookup195: xcm::VersionedXcm **/ XcmVersionedXcm: { _enum: { @@ -1654,7 +1662,7 @@ } }, /** - * Lookup195: xcm::v0::Xcm + * Lookup196: xcm::v0::Xcm **/ XcmV0Xcm: { _enum: { @@ -1708,7 +1716,7 @@ } }, /** - * Lookup197: xcm::v0::order::Order + * Lookup198: xcm::v0::order::Order **/ XcmV0Order: { _enum: { @@ -1751,7 +1759,7 @@ } }, /** - * Lookup199: xcm::v0::Response + * Lookup200: xcm::v0::Response **/ XcmV0Response: { _enum: { @@ -1759,7 +1767,7 @@ } }, /** - * Lookup200: xcm::v1::Xcm + * Lookup201: xcm::v1::Xcm **/ XcmV1Xcm: { _enum: { @@ -1818,7 +1826,7 @@ } }, /** - * Lookup202: xcm::v1::order::Order + * Lookup203: xcm::v1::order::Order **/ XcmV1Order: { _enum: { @@ -1863,7 +1871,7 @@ } }, /** - * Lookup204: xcm::v1::Response + * Lookup205: xcm::v1::Response **/ XcmV1Response: { _enum: { @@ -1872,11 +1880,11 @@ } }, /** - * Lookup218: cumulus_pallet_xcm::pallet::Call + * Lookup219: cumulus_pallet_xcm::pallet::Call **/ CumulusPalletXcmCall: 'Null', /** - * Lookup219: cumulus_pallet_dmp_queue::pallet::Call + * Lookup220: cumulus_pallet_dmp_queue::pallet::Call **/ CumulusPalletDmpQueueCall: { _enum: { @@ -1887,7 +1895,7 @@ } }, /** - * Lookup220: pallet_inflation::pallet::Call + * Lookup221: pallet_inflation::pallet::Call **/ PalletInflationCall: { _enum: { @@ -1897,7 +1905,7 @@ } }, /** - * Lookup221: pallet_unique::Call + * Lookup222: pallet_unique::Call **/ PalletUniqueCall: { _enum: { @@ -2029,7 +2037,7 @@ } }, /** - * Lookup226: up_data_structs::CollectionMode + * Lookup227: up_data_structs::CollectionMode **/ UpDataStructsCollectionMode: { _enum: { @@ -2039,7 +2047,7 @@ } }, /** - * Lookup227: up_data_structs::CreateCollectionData + * Lookup228: up_data_structs::CreateCollectionData **/ UpDataStructsCreateCollectionData: { mode: 'UpDataStructsCollectionMode', @@ -2054,13 +2062,13 @@ properties: 'Vec' }, /** - * Lookup229: up_data_structs::AccessMode + * Lookup230: up_data_structs::AccessMode **/ UpDataStructsAccessMode: { _enum: ['Normal', 'AllowList'] }, /** - * Lookup231: up_data_structs::CollectionLimits + * Lookup232: up_data_structs::CollectionLimits **/ UpDataStructsCollectionLimits: { accountTokenOwnershipLimit: 'Option', @@ -2074,7 +2082,7 @@ transfersEnabled: 'Option' }, /** - * Lookup233: up_data_structs::SponsoringRateLimit + * Lookup234: up_data_structs::SponsoringRateLimit **/ UpDataStructsSponsoringRateLimit: { _enum: { @@ -2083,7 +2091,7 @@ } }, /** - * Lookup236: up_data_structs::CollectionPermissions + * Lookup237: up_data_structs::CollectionPermissions **/ UpDataStructsCollectionPermissions: { access: 'Option', @@ -2091,7 +2099,7 @@ nesting: 'Option' }, /** - * Lookup238: up_data_structs::NestingPermissions + * Lookup239: up_data_structs::NestingPermissions **/ UpDataStructsNestingPermissions: { tokenOwner: 'bool', @@ -2099,18 +2107,18 @@ restricted: 'Option' }, /** - * Lookup240: up_data_structs::OwnerRestrictedSet + * Lookup241: up_data_structs::OwnerRestrictedSet **/ UpDataStructsOwnerRestrictedSet: 'BTreeSet', /** - * Lookup245: up_data_structs::PropertyKeyPermission + * Lookup246: up_data_structs::PropertyKeyPermission **/ UpDataStructsPropertyKeyPermission: { key: 'Bytes', permission: 'UpDataStructsPropertyPermission' }, /** - * Lookup246: up_data_structs::PropertyPermission + * Lookup247: up_data_structs::PropertyPermission **/ UpDataStructsPropertyPermission: { mutable: 'bool', @@ -2118,14 +2126,14 @@ tokenOwner: 'bool' }, /** - * Lookup249: up_data_structs::Property + * Lookup250: up_data_structs::Property **/ UpDataStructsProperty: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup252: up_data_structs::CreateItemData + * Lookup253: up_data_structs::CreateItemData **/ UpDataStructsCreateItemData: { _enum: { @@ -2135,26 +2143,26 @@ } }, /** - * Lookup253: up_data_structs::CreateNftData + * Lookup254: up_data_structs::CreateNftData **/ UpDataStructsCreateNftData: { properties: 'Vec' }, /** - * Lookup254: up_data_structs::CreateFungibleData + * Lookup255: up_data_structs::CreateFungibleData **/ UpDataStructsCreateFungibleData: { value: 'u128' }, /** - * Lookup255: up_data_structs::CreateReFungibleData + * Lookup256: up_data_structs::CreateReFungibleData **/ UpDataStructsCreateReFungibleData: { pieces: 'u128', properties: 'Vec' }, /** - * Lookup258: up_data_structs::CreateItemExData> + * Lookup259: up_data_structs::CreateItemExData> **/ UpDataStructsCreateItemExData: { _enum: { @@ -2165,14 +2173,14 @@ } }, /** - * Lookup260: up_data_structs::CreateNftExData> + * Lookup261: up_data_structs::CreateNftExData> **/ UpDataStructsCreateNftExData: { properties: 'Vec', owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup267: up_data_structs::CreateRefungibleExSingleOwner> + * Lookup268: up_data_structs::CreateRefungibleExSingleOwner> **/ UpDataStructsCreateRefungibleExSingleOwner: { user: 'PalletEvmAccountBasicCrossAccountIdRepr', @@ -2180,14 +2188,14 @@ properties: 'Vec' }, /** - * Lookup269: up_data_structs::CreateRefungibleExMultipleOwners> + * Lookup270: up_data_structs::CreateRefungibleExMultipleOwners> **/ UpDataStructsCreateRefungibleExMultipleOwners: { users: 'BTreeMap', properties: 'Vec' }, /** - * Lookup270: pallet_unique_scheduler::pallet::Call + * Lookup271: pallet_unique_scheduler::pallet::Call **/ PalletUniqueSchedulerCall: { _enum: { @@ -2211,7 +2219,7 @@ } }, /** - * Lookup272: frame_support::traits::schedule::MaybeHashed + * Lookup273: frame_support::traits::schedule::MaybeHashed **/ FrameSupportScheduleMaybeHashed: { _enum: { @@ -2220,7 +2228,7 @@ } }, /** - * Lookup273: pallet_configuration::pallet::Call + * Lookup274: pallet_configuration::pallet::Call **/ PalletConfigurationCall: { _enum: { @@ -2233,15 +2241,15 @@ } }, /** - * Lookup274: pallet_template_transaction_payment::Call + * Lookup275: pallet_template_transaction_payment::Call **/ PalletTemplateTransactionPaymentCall: 'Null', /** - * Lookup275: pallet_structure::pallet::Call + * Lookup276: pallet_structure::pallet::Call **/ PalletStructureCall: 'Null', /** - * Lookup276: pallet_rmrk_core::pallet::Call + * Lookup277: pallet_rmrk_core::pallet::Call **/ PalletRmrkCoreCall: { _enum: { @@ -2332,7 +2340,7 @@ } }, /** - * Lookup282: rmrk_traits::resource::ResourceTypes, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup283: rmrk_traits::resource::ResourceTypes, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceResourceTypes: { _enum: { @@ -2342,7 +2350,7 @@ } }, /** - * Lookup284: rmrk_traits::resource::BasicResource> + * Lookup285: rmrk_traits::resource::BasicResource> **/ RmrkTraitsResourceBasicResource: { src: 'Option', @@ -2351,7 +2359,7 @@ thumb: 'Option' }, /** - * Lookup286: rmrk_traits::resource::ComposableResource, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup287: rmrk_traits::resource::ComposableResource, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceComposableResource: { parts: 'Vec', @@ -2362,7 +2370,7 @@ thumb: 'Option' }, /** - * Lookup287: rmrk_traits::resource::SlotResource> + * Lookup288: rmrk_traits::resource::SlotResource> **/ RmrkTraitsResourceSlotResource: { base: 'u32', @@ -2373,7 +2381,7 @@ thumb: 'Option' }, /** - * Lookup290: pallet_rmrk_equip::pallet::Call + * Lookup291: pallet_rmrk_equip::pallet::Call **/ PalletRmrkEquipCall: { _enum: { @@ -2394,7 +2402,7 @@ } }, /** - * Lookup293: rmrk_traits::part::PartType, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup294: rmrk_traits::part::PartType, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPartPartType: { _enum: { @@ -2403,7 +2411,7 @@ } }, /** - * Lookup295: rmrk_traits::part::FixedPart> + * Lookup296: rmrk_traits::part::FixedPart> **/ RmrkTraitsPartFixedPart: { id: 'u32', @@ -2411,7 +2419,7 @@ src: 'Bytes' }, /** - * Lookup296: rmrk_traits::part::SlotPart, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup297: rmrk_traits::part::SlotPart, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPartSlotPart: { id: 'u32', @@ -2420,7 +2428,7 @@ z: 'u32' }, /** - * Lookup297: rmrk_traits::part::EquippableList> + * Lookup298: rmrk_traits::part::EquippableList> **/ RmrkTraitsPartEquippableList: { _enum: { @@ -2430,7 +2438,7 @@ } }, /** - * Lookup299: rmrk_traits::theme::Theme, sp_runtime::bounded::bounded_vec::BoundedVec>, S>> + * Lookup300: rmrk_traits::theme::Theme, sp_runtime::bounded::bounded_vec::BoundedVec>, S>> **/ RmrkTraitsTheme: { name: 'Bytes', @@ -2438,33 +2446,39 @@ inherit: 'bool' }, /** - * Lookup301: rmrk_traits::theme::ThemeProperty> + * Lookup302: rmrk_traits::theme::ThemeProperty> **/ RmrkTraitsThemeThemeProperty: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup303: pallet_app_promotion::pallet::Call + * Lookup304: pallet_app_promotion::pallet::Call **/ PalletAppPromotionCall: { _enum: { set_admin_address: { - admin: 'AccountId32', + admin: 'PalletEvmAccountBasicCrossAccountIdRepr', }, start_app_promotion: { - promotionStartRelayBlock: 'u32', + promotionStartRelayBlock: 'Option', }, stake: { amount: 'u128', }, unstake: { - amount: 'u128' + amount: 'u128', + }, + sponsor_collection: { + collectionId: 'u32', + }, + stop_sponsorign_collection: { + collectionId: 'u32' } } }, /** - * Lookup304: pallet_evm::pallet::Call + * Lookup305: pallet_evm::pallet::Call **/ PalletEvmCall: { _enum: { @@ -2507,7 +2521,7 @@ } }, /** - * Lookup308: pallet_ethereum::pallet::Call + * Lookup309: pallet_ethereum::pallet::Call **/ PalletEthereumCall: { _enum: { @@ -2517,7 +2531,7 @@ } }, /** - * Lookup309: ethereum::transaction::TransactionV2 + * Lookup310: ethereum::transaction::TransactionV2 **/ EthereumTransactionTransactionV2: { _enum: { @@ -2527,7 +2541,7 @@ } }, /** - * Lookup310: ethereum::transaction::LegacyTransaction + * Lookup311: ethereum::transaction::LegacyTransaction **/ EthereumTransactionLegacyTransaction: { nonce: 'U256', @@ -2539,7 +2553,7 @@ signature: 'EthereumTransactionTransactionSignature' }, /** - * Lookup311: ethereum::transaction::TransactionAction + * Lookup312: ethereum::transaction::TransactionAction **/ EthereumTransactionTransactionAction: { _enum: { @@ -2548,7 +2562,7 @@ } }, /** - * Lookup312: ethereum::transaction::TransactionSignature + * Lookup313: ethereum::transaction::TransactionSignature **/ EthereumTransactionTransactionSignature: { v: 'u64', @@ -2556,7 +2570,7 @@ s: 'H256' }, /** - * Lookup314: ethereum::transaction::EIP2930Transaction + * Lookup315: ethereum::transaction::EIP2930Transaction **/ EthereumTransactionEip2930Transaction: { chainId: 'u64', @@ -2572,14 +2586,14 @@ s: 'H256' }, /** - * Lookup316: ethereum::transaction::AccessListItem + * Lookup317: ethereum::transaction::AccessListItem **/ EthereumTransactionAccessListItem: { address: 'H160', storageKeys: 'Vec' }, /** - * Lookup317: ethereum::transaction::EIP1559Transaction + * Lookup318: ethereum::transaction::EIP1559Transaction **/ EthereumTransactionEip1559Transaction: { chainId: 'u64', @@ -2596,7 +2610,7 @@ s: 'H256' }, /** - * Lookup318: pallet_evm_migration::pallet::Call + * Lookup319: pallet_evm_migration::pallet::Call **/ PalletEvmMigrationCall: { _enum: { @@ -2614,19 +2628,19 @@ } }, /** - * Lookup321: pallet_sudo::pallet::Error + * Lookup322: pallet_sudo::pallet::Error **/ PalletSudoError: { _enum: ['RequireSudo'] }, /** - * Lookup323: orml_vesting::module::Error + * Lookup324: orml_vesting::module::Error **/ OrmlVestingModuleError: { _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded'] }, /** - * Lookup325: cumulus_pallet_xcmp_queue::InboundChannelDetails + * Lookup326: cumulus_pallet_xcmp_queue::InboundChannelDetails **/ CumulusPalletXcmpQueueInboundChannelDetails: { sender: 'u32', @@ -2634,19 +2648,19 @@ messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>' }, /** - * Lookup326: cumulus_pallet_xcmp_queue::InboundState + * Lookup327: cumulus_pallet_xcmp_queue::InboundState **/ CumulusPalletXcmpQueueInboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup329: polkadot_parachain::primitives::XcmpMessageFormat + * Lookup330: polkadot_parachain::primitives::XcmpMessageFormat **/ PolkadotParachainPrimitivesXcmpMessageFormat: { _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals'] }, /** - * Lookup332: cumulus_pallet_xcmp_queue::OutboundChannelDetails + * Lookup333: cumulus_pallet_xcmp_queue::OutboundChannelDetails **/ CumulusPalletXcmpQueueOutboundChannelDetails: { recipient: 'u32', @@ -2656,13 +2670,13 @@ lastIndex: 'u16' }, /** - * Lookup333: cumulus_pallet_xcmp_queue::OutboundState + * Lookup334: cumulus_pallet_xcmp_queue::OutboundState **/ CumulusPalletXcmpQueueOutboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup335: cumulus_pallet_xcmp_queue::QueueConfigData + * Lookup336: cumulus_pallet_xcmp_queue::QueueConfigData **/ CumulusPalletXcmpQueueQueueConfigData: { suspendThreshold: 'u32', @@ -2673,29 +2687,29 @@ xcmpMaxIndividualWeight: 'u64' }, /** - * Lookup337: cumulus_pallet_xcmp_queue::pallet::Error + * Lookup338: cumulus_pallet_xcmp_queue::pallet::Error **/ CumulusPalletXcmpQueueError: { _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit'] }, /** - * Lookup338: pallet_xcm::pallet::Error + * Lookup339: pallet_xcm::pallet::Error **/ PalletXcmError: { _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed'] }, /** - * Lookup339: cumulus_pallet_xcm::pallet::Error + * Lookup340: cumulus_pallet_xcm::pallet::Error **/ CumulusPalletXcmError: 'Null', /** - * Lookup340: cumulus_pallet_dmp_queue::ConfigData + * Lookup341: cumulus_pallet_dmp_queue::ConfigData **/ CumulusPalletDmpQueueConfigData: { maxIndividual: 'u64' }, /** - * Lookup341: cumulus_pallet_dmp_queue::PageIndexData + * Lookup342: cumulus_pallet_dmp_queue::PageIndexData **/ CumulusPalletDmpQueuePageIndexData: { beginUsed: 'u32', @@ -2703,19 +2717,19 @@ overweightCount: 'u64' }, /** - * Lookup344: cumulus_pallet_dmp_queue::pallet::Error + * Lookup345: cumulus_pallet_dmp_queue::pallet::Error **/ CumulusPalletDmpQueueError: { _enum: ['Unknown', 'OverLimit'] }, /** - * Lookup348: pallet_unique::Error + * Lookup349: pallet_unique::Error **/ PalletUniqueError: { _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection'] }, /** - * Lookup351: pallet_unique_scheduler::ScheduledV3, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32> + * Lookup352: pallet_unique_scheduler::ScheduledV3, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32> **/ PalletUniqueSchedulerScheduledV3: { maybeId: 'Option<[u8;16]>', @@ -2725,7 +2739,7 @@ origin: 'OpalRuntimeOriginCaller' }, /** - * Lookup352: opal_runtime::OriginCaller + * Lookup353: opal_runtime::OriginCaller **/ OpalRuntimeOriginCaller: { _enum: { @@ -2834,7 +2848,7 @@ } }, /** - * Lookup353: frame_support::dispatch::RawOrigin + * Lookup354: frame_support::dispatch::RawOrigin **/ FrameSupportDispatchRawOrigin: { _enum: { @@ -2844,7 +2858,7 @@ } }, /** - * Lookup354: pallet_xcm::pallet::Origin + * Lookup355: pallet_xcm::pallet::Origin **/ PalletXcmOrigin: { _enum: { @@ -2853,7 +2867,7 @@ } }, /** - * Lookup355: cumulus_pallet_xcm::pallet::Origin + * Lookup356: cumulus_pallet_xcm::pallet::Origin **/ CumulusPalletXcmOrigin: { _enum: { @@ -2862,7 +2876,7 @@ } }, /** - * Lookup356: pallet_ethereum::RawOrigin + * Lookup357: pallet_ethereum::RawOrigin **/ PalletEthereumRawOrigin: { _enum: { @@ -2870,17 +2884,17 @@ } }, /** - * Lookup357: sp_core::Void + * Lookup358: sp_core::Void **/ SpCoreVoid: 'Null', /** - * Lookup358: pallet_unique_scheduler::pallet::Error + * Lookup359: pallet_unique_scheduler::pallet::Error **/ PalletUniqueSchedulerError: { _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange'] }, /** - * Lookup359: up_data_structs::Collection + * Lookup360: up_data_structs::Collection **/ UpDataStructsCollection: { owner: 'AccountId32', @@ -2894,7 +2908,7 @@ externalCollection: 'bool' }, /** - * Lookup360: up_data_structs::SponsorshipState + * Lookup361: up_data_structs::SponsorshipState **/ UpDataStructsSponsorshipState: { _enum: { @@ -2904,7 +2918,7 @@ } }, /** - * Lookup361: up_data_structs::Properties + * Lookup362: up_data_structs::Properties **/ UpDataStructsProperties: { map: 'UpDataStructsPropertiesMapBoundedVec', @@ -2912,15 +2926,15 @@ spaceLimit: 'u32' }, /** - * Lookup362: up_data_structs::PropertiesMap> + * Lookup363: up_data_structs::PropertiesMap> **/ UpDataStructsPropertiesMapBoundedVec: 'BTreeMap', /** - * Lookup367: up_data_structs::PropertiesMap + * Lookup368: up_data_structs::PropertiesMap **/ UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap', /** - * Lookup374: up_data_structs::CollectionStats + * Lookup375: up_data_structs::CollectionStats **/ UpDataStructsCollectionStats: { created: 'u32', @@ -2928,18 +2942,18 @@ alive: 'u32' }, /** - * Lookup375: up_data_structs::TokenChild + * Lookup376: up_data_structs::TokenChild **/ UpDataStructsTokenChild: { token: 'u32', collection: 'u32' }, /** - * Lookup376: PhantomType::up_data_structs + * Lookup377: PhantomType::up_data_structs **/ PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]', /** - * Lookup378: up_data_structs::TokenData> + * Lookup379: up_data_structs::TokenData> **/ UpDataStructsTokenData: { properties: 'Vec', @@ -2947,7 +2961,7 @@ pieces: 'u128' }, /** - * Lookup380: up_data_structs::RpcCollection + * Lookup381: up_data_structs::RpcCollection **/ UpDataStructsRpcCollection: { owner: 'AccountId32', @@ -2963,7 +2977,7 @@ readOnly: 'bool' }, /** - * Lookup381: rmrk_traits::collection::CollectionInfo, sp_runtime::bounded::bounded_vec::BoundedVec, sp_core::crypto::AccountId32> + * Lookup382: rmrk_traits::collection::CollectionInfo, sp_runtime::bounded::bounded_vec::BoundedVec, sp_core::crypto::AccountId32> **/ RmrkTraitsCollectionCollectionInfo: { issuer: 'AccountId32', @@ -2973,7 +2987,7 @@ nftsCount: 'u32' }, /** - * Lookup382: rmrk_traits::nft::NftInfo> + * Lookup383: rmrk_traits::nft::NftInfo> **/ RmrkTraitsNftNftInfo: { owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple', @@ -2983,14 +2997,14 @@ pending: 'bool' }, /** - * Lookup384: rmrk_traits::nft::RoyaltyInfo + * Lookup385: rmrk_traits::nft::RoyaltyInfo **/ RmrkTraitsNftRoyaltyInfo: { recipient: 'AccountId32', amount: 'Permill' }, /** - * Lookup385: rmrk_traits::resource::ResourceInfo, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup386: rmrk_traits::resource::ResourceInfo, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsResourceResourceInfo: { id: 'u32', @@ -2999,14 +3013,14 @@ pendingRemoval: 'bool' }, /** - * Lookup386: rmrk_traits::property::PropertyInfo, sp_runtime::bounded::bounded_vec::BoundedVec> + * Lookup387: rmrk_traits::property::PropertyInfo, sp_runtime::bounded::bounded_vec::BoundedVec> **/ RmrkTraitsPropertyPropertyInfo: { key: 'Bytes', value: 'Bytes' }, /** - * Lookup387: rmrk_traits::base::BaseInfo> + * Lookup388: rmrk_traits::base::BaseInfo> **/ RmrkTraitsBaseBaseInfo: { issuer: 'AccountId32', @@ -3014,80 +3028,86 @@ symbol: 'Bytes' }, /** - * Lookup388: rmrk_traits::nft::NftChild + * Lookup389: rmrk_traits::nft::NftChild **/ RmrkTraitsNftNftChild: { collectionId: 'u32', nftId: 'u32' }, /** - * Lookup390: pallet_common::pallet::Error + * Lookup391: pallet_common::pallet::Error **/ PalletCommonError: { _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'CantDestroyNotEmptyCollection', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'UserIsNotAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey', 'CollectionIsExternal', 'CollectionIsInternal'] }, /** - * Lookup392: pallet_fungible::pallet::Error + * Lookup393: pallet_fungible::pallet::Error **/ PalletFungibleError: { _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup393: pallet_refungible::ItemData + * Lookup394: pallet_refungible::ItemData **/ PalletRefungibleItemData: { constData: 'Bytes' }, /** - * Lookup398: pallet_refungible::pallet::Error + * Lookup399: pallet_refungible::pallet::Error **/ PalletRefungibleError: { _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed'] }, /** - * Lookup399: pallet_nonfungible::ItemData> + * Lookup400: pallet_nonfungible::ItemData> **/ PalletNonfungibleItemData: { owner: 'PalletEvmAccountBasicCrossAccountIdRepr' }, /** - * Lookup401: up_data_structs::PropertyScope + * Lookup402: up_data_structs::PropertyScope **/ UpDataStructsPropertyScope: { _enum: ['None', 'Rmrk', 'Eth'] }, /** - * Lookup403: pallet_nonfungible::pallet::Error + * Lookup404: pallet_nonfungible::pallet::Error **/ PalletNonfungibleError: { _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren'] }, /** - * Lookup404: pallet_structure::pallet::Error + * Lookup405: pallet_structure::pallet::Error **/ PalletStructureError: { _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound'] }, /** - * Lookup405: pallet_rmrk_core::pallet::Error + * Lookup406: pallet_rmrk_core::pallet::Error **/ PalletRmrkCoreError: { _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId'] }, /** - * Lookup407: pallet_rmrk_equip::pallet::Error + * Lookup408: pallet_rmrk_equip::pallet::Error **/ PalletRmrkEquipError: { _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart'] }, /** - * Lookup411: pallet_evm::pallet::Error + * Lookup410: pallet_app_promotion::pallet::Error + **/ + PalletAppPromotionError: { + _enum: ['AdminNotSet', 'NoPermission', 'NotSufficientFounds', 'InvalidArgument', 'AlreadySponsored'] + }, + /** + * Lookup413: pallet_evm::pallet::Error **/ PalletEvmError: { _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce'] }, /** - * Lookup414: fp_rpc::TransactionStatus + * Lookup416: fp_rpc::TransactionStatus **/ FpRpcTransactionStatus: { transactionHash: 'H256', @@ -3099,11 +3119,11 @@ logsBloom: 'EthbloomBloom' }, /** - * Lookup416: ethbloom::Bloom + * Lookup418: ethbloom::Bloom **/ EthbloomBloom: '[u8;256]', /** - * Lookup418: ethereum::receipt::ReceiptV3 + * Lookup420: ethereum::receipt::ReceiptV3 **/ EthereumReceiptReceiptV3: { _enum: { @@ -3113,7 +3133,7 @@ } }, /** - * Lookup419: ethereum::receipt::EIP658ReceiptData + * Lookup421: ethereum::receipt::EIP658ReceiptData **/ EthereumReceiptEip658ReceiptData: { statusCode: 'u8', @@ -3122,7 +3142,7 @@ logs: 'Vec' }, /** - * Lookup420: ethereum::block::Block + * Lookup422: ethereum::block::Block **/ EthereumBlock: { header: 'EthereumHeader', @@ -3130,7 +3150,7 @@ ommers: 'Vec' }, /** - * Lookup421: ethereum::header::Header + * Lookup423: ethereum::header::Header **/ EthereumHeader: { parentHash: 'H256', @@ -3150,41 +3170,41 @@ nonce: 'EthereumTypesHashH64' }, /** - * Lookup422: ethereum_types::hash::H64 + * Lookup424: ethereum_types::hash::H64 **/ EthereumTypesHashH64: '[u8;8]', /** - * Lookup427: pallet_ethereum::pallet::Error + * Lookup429: pallet_ethereum::pallet::Error **/ PalletEthereumError: { _enum: ['InvalidSignature', 'PreLogExists'] }, /** - * Lookup428: pallet_evm_coder_substrate::pallet::Error + * Lookup430: pallet_evm_coder_substrate::pallet::Error **/ PalletEvmCoderSubstrateError: { _enum: ['OutOfGas', 'OutOfFund'] }, /** - * Lookup429: pallet_evm_contract_helpers::SponsoringModeT + * Lookup431: pallet_evm_contract_helpers::SponsoringModeT **/ PalletEvmContractHelpersSponsoringModeT: { _enum: ['Disabled', 'Allowlisted', 'Generous'] }, /** - * Lookup431: pallet_evm_contract_helpers::pallet::Error + * Lookup433: pallet_evm_contract_helpers::pallet::Error **/ PalletEvmContractHelpersError: { _enum: ['NoPermission'] }, /** - * Lookup432: pallet_evm_migration::pallet::Error + * Lookup434: pallet_evm_migration::pallet::Error **/ PalletEvmMigrationError: { _enum: ['AccountNotEmpty', 'AccountIsNotMigrating'] }, /** - * Lookup434: sp_runtime::MultiSignature + * Lookup436: sp_runtime::MultiSignature **/ SpRuntimeMultiSignature: { _enum: { @@ -3194,43 +3214,43 @@ } }, /** - * Lookup435: sp_core::ed25519::Signature + * Lookup437: sp_core::ed25519::Signature **/ SpCoreEd25519Signature: '[u8;64]', /** - * Lookup437: sp_core::sr25519::Signature + * Lookup439: sp_core::sr25519::Signature **/ SpCoreSr25519Signature: '[u8;64]', /** - * Lookup438: sp_core::ecdsa::Signature + * Lookup440: sp_core::ecdsa::Signature **/ SpCoreEcdsaSignature: '[u8;65]', /** - * Lookup441: frame_system::extensions::check_spec_version::CheckSpecVersion + * Lookup443: frame_system::extensions::check_spec_version::CheckSpecVersion **/ FrameSystemExtensionsCheckSpecVersion: 'Null', /** - * Lookup442: frame_system::extensions::check_genesis::CheckGenesis + * Lookup444: frame_system::extensions::check_genesis::CheckGenesis **/ FrameSystemExtensionsCheckGenesis: 'Null', /** - * Lookup445: frame_system::extensions::check_nonce::CheckNonce + * Lookup447: frame_system::extensions::check_nonce::CheckNonce **/ FrameSystemExtensionsCheckNonce: 'Compact', /** - * Lookup446: frame_system::extensions::check_weight::CheckWeight + * Lookup448: frame_system::extensions::check_weight::CheckWeight **/ FrameSystemExtensionsCheckWeight: 'Null', /** - * Lookup447: pallet_template_transaction_payment::ChargeTransactionPayment + * Lookup449: pallet_template_transaction_payment::ChargeTransactionPayment **/ PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact', /** - * Lookup448: opal_runtime::Runtime + * Lookup450: opal_runtime::Runtime **/ OpalRuntimeRuntime: 'Null', /** - * Lookup449: pallet_ethereum::FakeTransactionFinalizer + * Lookup451: pallet_ethereum::FakeTransactionFinalizer **/ PalletEthereumFakeTransactionFinalizer: 'Null' }; --- a/tests/src/interfaces/registry.ts +++ b/tests/src/interfaces/registry.ts @@ -5,7 +5,7 @@ // this is required to allow for ambient/previous definitions import '@polkadot/types/types/registry'; -import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmOrigin, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportScheduleLookupError, FrameSupportScheduleMaybeHashed, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeOriginCaller, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletAppPromotionCall, PalletAppPromotionError, PalletAppPromotionEvent, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletConfigurationCall, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEthereumRawOrigin, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletRmrkCoreCall, PalletRmrkCoreError, PalletRmrkCoreEvent, PalletRmrkEquipCall, PalletRmrkEquipError, PalletRmrkEquipEvent, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletUniqueSchedulerCall, PalletUniqueSchedulerError, PalletUniqueSchedulerEvent, PalletUniqueSchedulerScheduledV3, PalletXcmCall, PalletXcmError, PalletXcmEvent, PalletXcmOrigin, PhantomTypeUpDataStructs, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTraitsBaseBaseInfo, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsNftNftChild, RmrkTraitsNftNftInfo, RmrkTraitsNftRoyaltyInfo, RmrkTraitsPartEquippableList, RmrkTraitsPartFixedPart, RmrkTraitsPartPartType, RmrkTraitsPartSlotPart, RmrkTraitsPropertyPropertyInfo, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceInfo, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, RmrkTraitsThemeThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExMultipleOwners, UpDataStructsCreateRefungibleExSingleOwner, UpDataStructsNestingPermissions, UpDataStructsOwnerRestrictedSet, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsRpcCollection, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenChild, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; declare module '@polkadot/types/types/registry' { interface InterfaceTypes { @@ -84,6 +84,8 @@ OrmlVestingModuleEvent: OrmlVestingModuleEvent; OrmlVestingVestingSchedule: OrmlVestingVestingSchedule; PalletAppPromotionCall: PalletAppPromotionCall; + PalletAppPromotionError: PalletAppPromotionError; + PalletAppPromotionEvent: PalletAppPromotionEvent; PalletBalancesAccountData: PalletBalancesAccountData; PalletBalancesBalanceLock: PalletBalancesBalanceLock; PalletBalancesCall: PalletBalancesCall; --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -1198,7 +1198,14 @@ readonly type: 'BaseCreated' | 'EquippablesUpdated'; } - /** @name PalletEvmEvent (103) */ + /** @name PalletAppPromotionEvent (103) */ + interface PalletAppPromotionEvent extends Enum { + readonly isStakingRecalculation: boolean; + readonly asStakingRecalculation: ITuple<[u128, u128]>; + readonly type: 'StakingRecalculation'; + } + + /** @name PalletEvmEvent (104) */ interface PalletEvmEvent extends Enum { readonly isLog: boolean; readonly asLog: EthereumLog; @@ -1217,21 +1224,21 @@ readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw'; } - /** @name EthereumLog (104) */ + /** @name EthereumLog (105) */ interface EthereumLog extends Struct { readonly address: H160; readonly topics: Vec; readonly data: Bytes; } - /** @name PalletEthereumEvent (108) */ + /** @name PalletEthereumEvent (109) */ interface PalletEthereumEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>; readonly type: 'Executed'; } - /** @name EvmCoreErrorExitReason (109) */ + /** @name EvmCoreErrorExitReason (110) */ interface EvmCoreErrorExitReason extends Enum { readonly isSucceed: boolean; readonly asSucceed: EvmCoreErrorExitSucceed; @@ -1244,7 +1251,7 @@ readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal'; } - /** @name EvmCoreErrorExitSucceed (110) */ + /** @name EvmCoreErrorExitSucceed (111) */ interface EvmCoreErrorExitSucceed extends Enum { readonly isStopped: boolean; readonly isReturned: boolean; @@ -1252,7 +1259,7 @@ readonly type: 'Stopped' | 'Returned' | 'Suicided'; } - /** @name EvmCoreErrorExitError (111) */ + /** @name EvmCoreErrorExitError (112) */ interface EvmCoreErrorExitError extends Enum { readonly isStackUnderflow: boolean; readonly isStackOverflow: boolean; @@ -1273,13 +1280,13 @@ readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode'; } - /** @name EvmCoreErrorExitRevert (114) */ + /** @name EvmCoreErrorExitRevert (115) */ interface EvmCoreErrorExitRevert extends Enum { readonly isReverted: boolean; readonly type: 'Reverted'; } - /** @name EvmCoreErrorExitFatal (115) */ + /** @name EvmCoreErrorExitFatal (116) */ interface EvmCoreErrorExitFatal extends Enum { readonly isNotSupported: boolean; readonly isUnhandledInterrupt: boolean; @@ -1290,7 +1297,7 @@ readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other'; } - /** @name FrameSystemPhase (116) */ + /** @name FrameSystemPhase (117) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -1299,13 +1306,13 @@ readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } - /** @name FrameSystemLastRuntimeUpgradeInfo (118) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (119) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCall (119) */ + /** @name FrameSystemCall (120) */ interface FrameSystemCall extends Enum { readonly isFillBlock: boolean; readonly asFillBlock: { @@ -1347,21 +1354,21 @@ readonly type: 'FillBlock' | 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent'; } - /** @name FrameSystemLimitsBlockWeights (124) */ + /** @name FrameSystemLimitsBlockWeights (125) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: u64; readonly maxBlock: u64; readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass; } - /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (125) */ + /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (126) */ interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (126) */ + /** @name FrameSystemLimitsWeightsPerClass (127) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: u64; readonly maxExtrinsic: Option; @@ -1369,25 +1376,25 @@ readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (128) */ + /** @name FrameSystemLimitsBlockLength (129) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportWeightsPerDispatchClassU32; } - /** @name FrameSupportWeightsPerDispatchClassU32 (129) */ + /** @name FrameSupportWeightsPerDispatchClassU32 (130) */ interface FrameSupportWeightsPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name FrameSupportWeightsRuntimeDbWeight (130) */ + /** @name FrameSupportWeightsRuntimeDbWeight (131) */ interface FrameSupportWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (131) */ + /** @name SpVersionRuntimeVersion (132) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -1399,7 +1406,7 @@ readonly stateVersion: u8; } - /** @name FrameSystemError (136) */ + /** @name FrameSystemError (137) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -1410,7 +1417,7 @@ readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered'; } - /** @name PolkadotPrimitivesV2PersistedValidationData (137) */ + /** @name PolkadotPrimitivesV2PersistedValidationData (138) */ interface PolkadotPrimitivesV2PersistedValidationData extends Struct { readonly parentHead: Bytes; readonly relayParentNumber: u32; @@ -1418,18 +1425,18 @@ readonly maxPovSize: u32; } - /** @name PolkadotPrimitivesV2UpgradeRestriction (140) */ + /** @name PolkadotPrimitivesV2UpgradeRestriction (141) */ interface PolkadotPrimitivesV2UpgradeRestriction extends Enum { readonly isPresent: boolean; readonly type: 'Present'; } - /** @name SpTrieStorageProof (141) */ + /** @name SpTrieStorageProof (142) */ interface SpTrieStorageProof extends Struct { readonly trieNodes: BTreeSet; } - /** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot (143) */ + /** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot (144) */ interface CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot extends Struct { readonly dmqMqcHead: H256; readonly relayDispatchQueueSize: ITuple<[u32, u32]>; @@ -1437,7 +1444,7 @@ readonly egressChannels: Vec>; } - /** @name PolkadotPrimitivesV2AbridgedHrmpChannel (146) */ + /** @name PolkadotPrimitivesV2AbridgedHrmpChannel (147) */ interface PolkadotPrimitivesV2AbridgedHrmpChannel extends Struct { readonly maxCapacity: u32; readonly maxTotalSize: u32; @@ -1447,7 +1454,7 @@ readonly mqcHead: Option; } - /** @name PolkadotPrimitivesV2AbridgedHostConfiguration (147) */ + /** @name PolkadotPrimitivesV2AbridgedHostConfiguration (148) */ interface PolkadotPrimitivesV2AbridgedHostConfiguration extends Struct { readonly maxCodeSize: u32; readonly maxHeadDataSize: u32; @@ -1460,13 +1467,13 @@ readonly validationUpgradeDelay: u32; } - /** @name PolkadotCorePrimitivesOutboundHrmpMessage (153) */ + /** @name PolkadotCorePrimitivesOutboundHrmpMessage (154) */ interface PolkadotCorePrimitivesOutboundHrmpMessage extends Struct { readonly recipient: u32; readonly data: Bytes; } - /** @name CumulusPalletParachainSystemCall (154) */ + /** @name CumulusPalletParachainSystemCall (155) */ interface CumulusPalletParachainSystemCall extends Enum { readonly isSetValidationData: boolean; readonly asSetValidationData: { @@ -1487,7 +1494,7 @@ readonly type: 'SetValidationData' | 'SudoSendUpwardMessage' | 'AuthorizeUpgrade' | 'EnactAuthorizedUpgrade'; } - /** @name CumulusPrimitivesParachainInherentParachainInherentData (155) */ + /** @name CumulusPrimitivesParachainInherentParachainInherentData (156) */ interface CumulusPrimitivesParachainInherentParachainInherentData extends Struct { readonly validationData: PolkadotPrimitivesV2PersistedValidationData; readonly relayChainState: SpTrieStorageProof; @@ -1495,19 +1502,19 @@ readonly horizontalMessages: BTreeMap>; } - /** @name PolkadotCorePrimitivesInboundDownwardMessage (157) */ + /** @name PolkadotCorePrimitivesInboundDownwardMessage (158) */ interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct { readonly sentAt: u32; readonly msg: Bytes; } - /** @name PolkadotCorePrimitivesInboundHrmpMessage (160) */ + /** @name PolkadotCorePrimitivesInboundHrmpMessage (161) */ interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct { readonly sentAt: u32; readonly data: Bytes; } - /** @name CumulusPalletParachainSystemError (163) */ + /** @name CumulusPalletParachainSystemError (164) */ interface CumulusPalletParachainSystemError extends Enum { readonly isOverlappingUpgrades: boolean; readonly isProhibitedByPolkadot: boolean; @@ -1520,14 +1527,14 @@ readonly type: 'OverlappingUpgrades' | 'ProhibitedByPolkadot' | 'TooBig' | 'ValidationDataNotAvailable' | 'HostConfigurationNotAvailable' | 'NotScheduled' | 'NothingAuthorized' | 'Unauthorized'; } - /** @name PalletBalancesBalanceLock (165) */ + /** @name PalletBalancesBalanceLock (166) */ interface PalletBalancesBalanceLock extends Struct { readonly id: U8aFixed; readonly amount: u128; readonly reasons: PalletBalancesReasons; } - /** @name PalletBalancesReasons (166) */ + /** @name PalletBalancesReasons (167) */ interface PalletBalancesReasons extends Enum { readonly isFee: boolean; readonly isMisc: boolean; @@ -1535,20 +1542,20 @@ readonly type: 'Fee' | 'Misc' | 'All'; } - /** @name PalletBalancesReserveData (169) */ + /** @name PalletBalancesReserveData (170) */ interface PalletBalancesReserveData extends Struct { readonly id: U8aFixed; readonly amount: u128; } - /** @name PalletBalancesReleases (171) */ + /** @name PalletBalancesReleases (172) */ interface PalletBalancesReleases extends Enum { readonly isV100: boolean; readonly isV200: boolean; readonly type: 'V100' | 'V200'; } - /** @name PalletBalancesCall (172) */ + /** @name PalletBalancesCall (173) */ interface PalletBalancesCall extends Enum { readonly isTransfer: boolean; readonly asTransfer: { @@ -1585,7 +1592,7 @@ readonly type: 'Transfer' | 'SetBalance' | 'ForceTransfer' | 'TransferKeepAlive' | 'TransferAll' | 'ForceUnreserve'; } - /** @name PalletBalancesError (175) */ + /** @name PalletBalancesError (176) */ interface PalletBalancesError extends Enum { readonly isVestingBalance: boolean; readonly isLiquidityRestrictions: boolean; @@ -1598,7 +1605,7 @@ readonly type: 'VestingBalance' | 'LiquidityRestrictions' | 'InsufficientBalance' | 'ExistentialDeposit' | 'KeepAlive' | 'ExistingVestingSchedule' | 'DeadAccount' | 'TooManyReserves'; } - /** @name PalletTimestampCall (177) */ + /** @name PalletTimestampCall (178) */ interface PalletTimestampCall extends Enum { readonly isSet: boolean; readonly asSet: { @@ -1607,14 +1614,14 @@ readonly type: 'Set'; } - /** @name PalletTransactionPaymentReleases (179) */ + /** @name PalletTransactionPaymentReleases (180) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: 'V1Ancient' | 'V2'; } - /** @name PalletTreasuryProposal (180) */ + /** @name PalletTreasuryProposal (181) */ interface PalletTreasuryProposal extends Struct { readonly proposer: AccountId32; readonly value: u128; @@ -1622,7 +1629,7 @@ readonly bond: u128; } - /** @name PalletTreasuryCall (183) */ + /** @name PalletTreasuryCall (184) */ interface PalletTreasuryCall extends Enum { readonly isProposeSpend: boolean; readonly asProposeSpend: { @@ -1649,10 +1656,10 @@ readonly type: 'ProposeSpend' | 'RejectProposal' | 'ApproveProposal' | 'Spend' | 'RemoveApproval'; } - /** @name FrameSupportPalletId (186) */ + /** @name FrameSupportPalletId (187) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name PalletTreasuryError (187) */ + /** @name PalletTreasuryError (188) */ interface PalletTreasuryError extends Enum { readonly isInsufficientProposersBalance: boolean; readonly isInvalidIndex: boolean; @@ -1662,7 +1669,7 @@ readonly type: 'InsufficientProposersBalance' | 'InvalidIndex' | 'TooManyApprovals' | 'InsufficientPermission' | 'ProposalNotApproved'; } - /** @name PalletSudoCall (188) */ + /** @name PalletSudoCall (189) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -1685,7 +1692,7 @@ readonly type: 'Sudo' | 'SudoUncheckedWeight' | 'SetKey' | 'SudoAs'; } - /** @name OrmlVestingModuleCall (190) */ + /** @name OrmlVestingModuleCall (191) */ interface OrmlVestingModuleCall extends Enum { readonly isClaim: boolean; readonly isVestedTransfer: boolean; @@ -1705,7 +1712,7 @@ readonly type: 'Claim' | 'VestedTransfer' | 'UpdateVestingSchedules' | 'ClaimFor'; } - /** @name CumulusPalletXcmpQueueCall (192) */ + /** @name CumulusPalletXcmpQueueCall (193) */ interface CumulusPalletXcmpQueueCall extends Enum { readonly isServiceOverweight: boolean; readonly asServiceOverweight: { @@ -1741,7 +1748,7 @@ readonly type: 'ServiceOverweight' | 'SuspendXcmExecution' | 'ResumeXcmExecution' | 'UpdateSuspendThreshold' | 'UpdateDropThreshold' | 'UpdateResumeThreshold' | 'UpdateThresholdWeight' | 'UpdateWeightRestrictDecay' | 'UpdateXcmpMaxIndividualWeight'; } - /** @name PalletXcmCall (193) */ + /** @name PalletXcmCall (194) */ interface PalletXcmCall extends Enum { readonly isSend: boolean; readonly asSend: { @@ -1803,7 +1810,7 @@ readonly type: 'Send' | 'TeleportAssets' | 'ReserveTransferAssets' | 'Execute' | 'ForceXcmVersion' | 'ForceDefaultXcmVersion' | 'ForceSubscribeVersionNotify' | 'ForceUnsubscribeVersionNotify' | 'LimitedReserveTransferAssets' | 'LimitedTeleportAssets'; } - /** @name XcmVersionedXcm (194) */ + /** @name XcmVersionedXcm (195) */ interface XcmVersionedXcm extends Enum { readonly isV0: boolean; readonly asV0: XcmV0Xcm; @@ -1814,7 +1821,7 @@ readonly type: 'V0' | 'V1' | 'V2'; } - /** @name XcmV0Xcm (195) */ + /** @name XcmV0Xcm (196) */ interface XcmV0Xcm extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: { @@ -1877,7 +1884,7 @@ readonly type: 'WithdrawAsset' | 'ReserveAssetDeposit' | 'TeleportAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom'; } - /** @name XcmV0Order (197) */ + /** @name XcmV0Order (198) */ interface XcmV0Order extends Enum { readonly isNull: boolean; readonly isDepositAsset: boolean; @@ -1925,14 +1932,14 @@ readonly type: 'Null' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution'; } - /** @name XcmV0Response (199) */ + /** @name XcmV0Response (200) */ interface XcmV0Response extends Enum { readonly isAssets: boolean; readonly asAssets: Vec; readonly type: 'Assets'; } - /** @name XcmV1Xcm (200) */ + /** @name XcmV1Xcm (201) */ interface XcmV1Xcm extends Enum { readonly isWithdrawAsset: boolean; readonly asWithdrawAsset: { @@ -2001,7 +2008,7 @@ readonly type: 'WithdrawAsset' | 'ReserveAssetDeposited' | 'ReceiveTeleportedAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom' | 'SubscribeVersion' | 'UnsubscribeVersion'; } - /** @name XcmV1Order (202) */ + /** @name XcmV1Order (203) */ interface XcmV1Order extends Enum { readonly isNoop: boolean; readonly isDepositAsset: boolean; @@ -2051,7 +2058,7 @@ readonly type: 'Noop' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution'; } - /** @name XcmV1Response (204) */ + /** @name XcmV1Response (205) */ interface XcmV1Response extends Enum { readonly isAssets: boolean; readonly asAssets: XcmV1MultiassetMultiAssets; @@ -2060,10 +2067,10 @@ readonly type: 'Assets' | 'Version'; } - /** @name CumulusPalletXcmCall (218) */ + /** @name CumulusPalletXcmCall (219) */ type CumulusPalletXcmCall = Null; - /** @name CumulusPalletDmpQueueCall (219) */ + /** @name CumulusPalletDmpQueueCall (220) */ interface CumulusPalletDmpQueueCall extends Enum { readonly isServiceOverweight: boolean; readonly asServiceOverweight: { @@ -2073,7 +2080,7 @@ readonly type: 'ServiceOverweight'; } - /** @name PalletInflationCall (220) */ + /** @name PalletInflationCall (221) */ interface PalletInflationCall extends Enum { readonly isStartInflation: boolean; readonly asStartInflation: { @@ -2082,7 +2089,7 @@ readonly type: 'StartInflation'; } - /** @name PalletUniqueCall (221) */ + /** @name PalletUniqueCall (222) */ interface PalletUniqueCall extends Enum { readonly isCreateCollection: boolean; readonly asCreateCollection: { @@ -2240,7 +2247,7 @@ readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition'; } - /** @name UpDataStructsCollectionMode (226) */ + /** @name UpDataStructsCollectionMode (227) */ interface UpDataStructsCollectionMode extends Enum { readonly isNft: boolean; readonly isFungible: boolean; @@ -2249,7 +2256,7 @@ readonly type: 'Nft' | 'Fungible' | 'ReFungible'; } - /** @name UpDataStructsCreateCollectionData (227) */ + /** @name UpDataStructsCreateCollectionData (228) */ interface UpDataStructsCreateCollectionData extends Struct { readonly mode: UpDataStructsCollectionMode; readonly access: Option; @@ -2263,14 +2270,14 @@ readonly properties: Vec; } - /** @name UpDataStructsAccessMode (229) */ + /** @name UpDataStructsAccessMode (230) */ interface UpDataStructsAccessMode extends Enum { readonly isNormal: boolean; readonly isAllowList: boolean; readonly type: 'Normal' | 'AllowList'; } - /** @name UpDataStructsCollectionLimits (231) */ + /** @name UpDataStructsCollectionLimits (232) */ interface UpDataStructsCollectionLimits extends Struct { readonly accountTokenOwnershipLimit: Option; readonly sponsoredDataSize: Option; @@ -2283,7 +2290,7 @@ readonly transfersEnabled: Option; } - /** @name UpDataStructsSponsoringRateLimit (233) */ + /** @name UpDataStructsSponsoringRateLimit (234) */ interface UpDataStructsSponsoringRateLimit extends Enum { readonly isSponsoringDisabled: boolean; readonly isBlocks: boolean; @@ -2291,43 +2298,43 @@ readonly type: 'SponsoringDisabled' | 'Blocks'; } - /** @name UpDataStructsCollectionPermissions (236) */ + /** @name UpDataStructsCollectionPermissions (237) */ interface UpDataStructsCollectionPermissions extends Struct { readonly access: Option; readonly mintMode: Option; readonly nesting: Option; } - /** @name UpDataStructsNestingPermissions (238) */ + /** @name UpDataStructsNestingPermissions (239) */ interface UpDataStructsNestingPermissions extends Struct { readonly tokenOwner: bool; readonly collectionAdmin: bool; readonly restricted: Option; } - /** @name UpDataStructsOwnerRestrictedSet (240) */ + /** @name UpDataStructsOwnerRestrictedSet (241) */ interface UpDataStructsOwnerRestrictedSet extends BTreeSet {} - /** @name UpDataStructsPropertyKeyPermission (245) */ + /** @name UpDataStructsPropertyKeyPermission (246) */ interface UpDataStructsPropertyKeyPermission extends Struct { readonly key: Bytes; readonly permission: UpDataStructsPropertyPermission; } - /** @name UpDataStructsPropertyPermission (246) */ + /** @name UpDataStructsPropertyPermission (247) */ interface UpDataStructsPropertyPermission extends Struct { readonly mutable: bool; readonly collectionAdmin: bool; readonly tokenOwner: bool; } - /** @name UpDataStructsProperty (249) */ + /** @name UpDataStructsProperty (250) */ interface UpDataStructsProperty extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name UpDataStructsCreateItemData (252) */ + /** @name UpDataStructsCreateItemData (253) */ interface UpDataStructsCreateItemData extends Enum { readonly isNft: boolean; readonly asNft: UpDataStructsCreateNftData; @@ -2338,23 +2345,23 @@ readonly type: 'Nft' | 'Fungible' | 'ReFungible'; } - /** @name UpDataStructsCreateNftData (253) */ + /** @name UpDataStructsCreateNftData (254) */ interface UpDataStructsCreateNftData extends Struct { readonly properties: Vec; } - /** @name UpDataStructsCreateFungibleData (254) */ + /** @name UpDataStructsCreateFungibleData (255) */ interface UpDataStructsCreateFungibleData extends Struct { readonly value: u128; } - /** @name UpDataStructsCreateReFungibleData (255) */ + /** @name UpDataStructsCreateReFungibleData (256) */ interface UpDataStructsCreateReFungibleData extends Struct { readonly pieces: u128; readonly properties: Vec; } - /** @name UpDataStructsCreateItemExData (258) */ + /** @name UpDataStructsCreateItemExData (259) */ interface UpDataStructsCreateItemExData extends Enum { readonly isNft: boolean; readonly asNft: Vec; @@ -2367,26 +2374,26 @@ readonly type: 'Nft' | 'Fungible' | 'RefungibleMultipleItems' | 'RefungibleMultipleOwners'; } - /** @name UpDataStructsCreateNftExData (260) */ + /** @name UpDataStructsCreateNftExData (261) */ interface UpDataStructsCreateNftExData extends Struct { readonly properties: Vec; readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name UpDataStructsCreateRefungibleExSingleOwner (267) */ + /** @name UpDataStructsCreateRefungibleExSingleOwner (268) */ interface UpDataStructsCreateRefungibleExSingleOwner extends Struct { readonly user: PalletEvmAccountBasicCrossAccountIdRepr; readonly pieces: u128; readonly properties: Vec; } - /** @name UpDataStructsCreateRefungibleExMultipleOwners (269) */ + /** @name UpDataStructsCreateRefungibleExMultipleOwners (270) */ interface UpDataStructsCreateRefungibleExMultipleOwners extends Struct { readonly users: BTreeMap; readonly properties: Vec; } - /** @name PalletUniqueSchedulerCall (270) */ + /** @name PalletUniqueSchedulerCall (271) */ interface PalletUniqueSchedulerCall extends Enum { readonly isScheduleNamed: boolean; readonly asScheduleNamed: { @@ -2411,7 +2418,7 @@ readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter'; } - /** @name FrameSupportScheduleMaybeHashed (272) */ + /** @name FrameSupportScheduleMaybeHashed (273) */ interface FrameSupportScheduleMaybeHashed extends Enum { readonly isValue: boolean; readonly asValue: Call; @@ -2420,7 +2427,7 @@ readonly type: 'Value' | 'Hash'; } - /** @name PalletConfigurationCall (273) */ + /** @name PalletConfigurationCall (274) */ interface PalletConfigurationCall extends Enum { readonly isSetWeightToFeeCoefficientOverride: boolean; readonly asSetWeightToFeeCoefficientOverride: { @@ -2433,13 +2440,13 @@ readonly type: 'SetWeightToFeeCoefficientOverride' | 'SetMinGasPriceOverride'; } - /** @name PalletTemplateTransactionPaymentCall (274) */ + /** @name PalletTemplateTransactionPaymentCall (275) */ type PalletTemplateTransactionPaymentCall = Null; - /** @name PalletStructureCall (275) */ + /** @name PalletStructureCall (276) */ type PalletStructureCall = Null; - /** @name PalletRmrkCoreCall (276) */ + /** @name PalletRmrkCoreCall (277) */ interface PalletRmrkCoreCall extends Enum { readonly isCreateCollection: boolean; readonly asCreateCollection: { @@ -2545,7 +2552,7 @@ readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'Send' | 'AcceptNft' | 'RejectNft' | 'AcceptResource' | 'AcceptResourceRemoval' | 'SetProperty' | 'SetPriority' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource' | 'RemoveResource'; } - /** @name RmrkTraitsResourceResourceTypes (282) */ + /** @name RmrkTraitsResourceResourceTypes (283) */ interface RmrkTraitsResourceResourceTypes extends Enum { readonly isBasic: boolean; readonly asBasic: RmrkTraitsResourceBasicResource; @@ -2556,7 +2563,7 @@ readonly type: 'Basic' | 'Composable' | 'Slot'; } - /** @name RmrkTraitsResourceBasicResource (284) */ + /** @name RmrkTraitsResourceBasicResource (285) */ interface RmrkTraitsResourceBasicResource extends Struct { readonly src: Option; readonly metadata: Option; @@ -2564,7 +2571,7 @@ readonly thumb: Option; } - /** @name RmrkTraitsResourceComposableResource (286) */ + /** @name RmrkTraitsResourceComposableResource (287) */ interface RmrkTraitsResourceComposableResource extends Struct { readonly parts: Vec; readonly base: u32; @@ -2574,7 +2581,7 @@ readonly thumb: Option; } - /** @name RmrkTraitsResourceSlotResource (287) */ + /** @name RmrkTraitsResourceSlotResource (288) */ interface RmrkTraitsResourceSlotResource extends Struct { readonly base: u32; readonly src: Option; @@ -2584,7 +2591,7 @@ readonly thumb: Option; } - /** @name PalletRmrkEquipCall (290) */ + /** @name PalletRmrkEquipCall (291) */ interface PalletRmrkEquipCall extends Enum { readonly isCreateBase: boolean; readonly asCreateBase: { @@ -2606,7 +2613,7 @@ readonly type: 'CreateBase' | 'ThemeAdd' | 'Equippable'; } - /** @name RmrkTraitsPartPartType (293) */ + /** @name RmrkTraitsPartPartType (294) */ interface RmrkTraitsPartPartType extends Enum { readonly isFixedPart: boolean; readonly asFixedPart: RmrkTraitsPartFixedPart; @@ -2615,14 +2622,14 @@ readonly type: 'FixedPart' | 'SlotPart'; } - /** @name RmrkTraitsPartFixedPart (295) */ + /** @name RmrkTraitsPartFixedPart (296) */ interface RmrkTraitsPartFixedPart extends Struct { readonly id: u32; readonly z: u32; readonly src: Bytes; } - /** @name RmrkTraitsPartSlotPart (296) */ + /** @name RmrkTraitsPartSlotPart (297) */ interface RmrkTraitsPartSlotPart extends Struct { readonly id: u32; readonly equippable: RmrkTraitsPartEquippableList; @@ -2630,7 +2637,7 @@ readonly z: u32; } - /** @name RmrkTraitsPartEquippableList (297) */ + /** @name RmrkTraitsPartEquippableList (298) */ interface RmrkTraitsPartEquippableList extends Enum { readonly isAll: boolean; readonly isEmpty: boolean; @@ -2639,28 +2646,28 @@ readonly type: 'All' | 'Empty' | 'Custom'; } - /** @name RmrkTraitsTheme (299) */ + /** @name RmrkTraitsTheme (300) */ interface RmrkTraitsTheme extends Struct { readonly name: Bytes; readonly properties: Vec; readonly inherit: bool; } - /** @name RmrkTraitsThemeThemeProperty (301) */ + /** @name RmrkTraitsThemeThemeProperty (302) */ interface RmrkTraitsThemeThemeProperty extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name PalletAppPromotionCall (303) */ + /** @name PalletAppPromotionCall (304) */ interface PalletAppPromotionCall extends Enum { readonly isSetAdminAddress: boolean; readonly asSetAdminAddress: { - readonly admin: AccountId32; + readonly admin: PalletEvmAccountBasicCrossAccountIdRepr; } & Struct; readonly isStartAppPromotion: boolean; readonly asStartAppPromotion: { - readonly promotionStartRelayBlock: u32; + readonly promotionStartRelayBlock: Option; } & Struct; readonly isStake: boolean; readonly asStake: { @@ -2670,10 +2677,18 @@ readonly asUnstake: { readonly amount: u128; } & Struct; - readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake'; + readonly isSponsorCollection: boolean; + readonly asSponsorCollection: { + readonly collectionId: u32; + } & Struct; + readonly isStopSponsorignCollection: boolean; + readonly asStopSponsorignCollection: { + readonly collectionId: u32; + } & Struct; + readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake' | 'SponsorCollection' | 'StopSponsorignCollection'; } - /** @name PalletEvmCall (304) */ + /** @name PalletEvmCall (305) */ interface PalletEvmCall extends Enum { readonly isWithdraw: boolean; readonly asWithdraw: { @@ -2718,7 +2733,7 @@ readonly type: 'Withdraw' | 'Call' | 'Create' | 'Create2'; } - /** @name PalletEthereumCall (308) */ + /** @name PalletEthereumCall (309) */ interface PalletEthereumCall extends Enum { readonly isTransact: boolean; readonly asTransact: { @@ -2727,7 +2742,7 @@ readonly type: 'Transact'; } - /** @name EthereumTransactionTransactionV2 (309) */ + /** @name EthereumTransactionTransactionV2 (310) */ interface EthereumTransactionTransactionV2 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumTransactionLegacyTransaction; @@ -2738,7 +2753,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumTransactionLegacyTransaction (310) */ + /** @name EthereumTransactionLegacyTransaction (311) */ interface EthereumTransactionLegacyTransaction extends Struct { readonly nonce: U256; readonly gasPrice: U256; @@ -2749,7 +2764,7 @@ readonly signature: EthereumTransactionTransactionSignature; } - /** @name EthereumTransactionTransactionAction (311) */ + /** @name EthereumTransactionTransactionAction (312) */ interface EthereumTransactionTransactionAction extends Enum { readonly isCall: boolean; readonly asCall: H160; @@ -2757,14 +2772,14 @@ readonly type: 'Call' | 'Create'; } - /** @name EthereumTransactionTransactionSignature (312) */ + /** @name EthereumTransactionTransactionSignature (313) */ interface EthereumTransactionTransactionSignature extends Struct { readonly v: u64; readonly r: H256; readonly s: H256; } - /** @name EthereumTransactionEip2930Transaction (314) */ + /** @name EthereumTransactionEip2930Transaction (315) */ interface EthereumTransactionEip2930Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -2779,13 +2794,13 @@ readonly s: H256; } - /** @name EthereumTransactionAccessListItem (316) */ + /** @name EthereumTransactionAccessListItem (317) */ interface EthereumTransactionAccessListItem extends Struct { readonly address: H160; readonly storageKeys: Vec; } - /** @name EthereumTransactionEip1559Transaction (317) */ + /** @name EthereumTransactionEip1559Transaction (318) */ interface EthereumTransactionEip1559Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -2801,7 +2816,7 @@ readonly s: H256; } - /** @name PalletEvmMigrationCall (318) */ + /** @name PalletEvmMigrationCall (319) */ interface PalletEvmMigrationCall extends Enum { readonly isBegin: boolean; readonly asBegin: { @@ -2820,13 +2835,13 @@ readonly type: 'Begin' | 'SetData' | 'Finish'; } - /** @name PalletSudoError (321) */ + /** @name PalletSudoError (322) */ interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: 'RequireSudo'; } - /** @name OrmlVestingModuleError (323) */ + /** @name OrmlVestingModuleError (324) */ interface OrmlVestingModuleError extends Enum { readonly isZeroVestingPeriod: boolean; readonly isZeroVestingPeriodCount: boolean; @@ -2837,21 +2852,21 @@ readonly type: 'ZeroVestingPeriod' | 'ZeroVestingPeriodCount' | 'InsufficientBalanceToLock' | 'TooManyVestingSchedules' | 'AmountLow' | 'MaxVestingSchedulesExceeded'; } - /** @name CumulusPalletXcmpQueueInboundChannelDetails (325) */ + /** @name CumulusPalletXcmpQueueInboundChannelDetails (326) */ interface CumulusPalletXcmpQueueInboundChannelDetails extends Struct { readonly sender: u32; readonly state: CumulusPalletXcmpQueueInboundState; readonly messageMetadata: Vec>; } - /** @name CumulusPalletXcmpQueueInboundState (326) */ + /** @name CumulusPalletXcmpQueueInboundState (327) */ interface CumulusPalletXcmpQueueInboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name PolkadotParachainPrimitivesXcmpMessageFormat (329) */ + /** @name PolkadotParachainPrimitivesXcmpMessageFormat (330) */ interface PolkadotParachainPrimitivesXcmpMessageFormat extends Enum { readonly isConcatenatedVersionedXcm: boolean; readonly isConcatenatedEncodedBlob: boolean; @@ -2859,7 +2874,7 @@ readonly type: 'ConcatenatedVersionedXcm' | 'ConcatenatedEncodedBlob' | 'Signals'; } - /** @name CumulusPalletXcmpQueueOutboundChannelDetails (332) */ + /** @name CumulusPalletXcmpQueueOutboundChannelDetails (333) */ interface CumulusPalletXcmpQueueOutboundChannelDetails extends Struct { readonly recipient: u32; readonly state: CumulusPalletXcmpQueueOutboundState; @@ -2868,14 +2883,14 @@ readonly lastIndex: u16; } - /** @name CumulusPalletXcmpQueueOutboundState (333) */ + /** @name CumulusPalletXcmpQueueOutboundState (334) */ interface CumulusPalletXcmpQueueOutboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name CumulusPalletXcmpQueueQueueConfigData (335) */ + /** @name CumulusPalletXcmpQueueQueueConfigData (336) */ interface CumulusPalletXcmpQueueQueueConfigData extends Struct { readonly suspendThreshold: u32; readonly dropThreshold: u32; @@ -2885,7 +2900,7 @@ readonly xcmpMaxIndividualWeight: u64; } - /** @name CumulusPalletXcmpQueueError (337) */ + /** @name CumulusPalletXcmpQueueError (338) */ interface CumulusPalletXcmpQueueError extends Enum { readonly isFailedToSend: boolean; readonly isBadXcmOrigin: boolean; @@ -2895,7 +2910,7 @@ readonly type: 'FailedToSend' | 'BadXcmOrigin' | 'BadXcm' | 'BadOverweightIndex' | 'WeightOverLimit'; } - /** @name PalletXcmError (338) */ + /** @name PalletXcmError (339) */ interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -2913,29 +2928,29 @@ readonly type: 'Unreachable' | 'SendFailure' | 'Filtered' | 'UnweighableMessage' | 'DestinationNotInvertible' | 'Empty' | 'CannotReanchor' | 'TooManyAssets' | 'InvalidOrigin' | 'BadVersion' | 'BadLocation' | 'NoSubscription' | 'AlreadySubscribed'; } - /** @name CumulusPalletXcmError (339) */ + /** @name CumulusPalletXcmError (340) */ type CumulusPalletXcmError = Null; - /** @name CumulusPalletDmpQueueConfigData (340) */ + /** @name CumulusPalletDmpQueueConfigData (341) */ interface CumulusPalletDmpQueueConfigData extends Struct { readonly maxIndividual: u64; } - /** @name CumulusPalletDmpQueuePageIndexData (341) */ + /** @name CumulusPalletDmpQueuePageIndexData (342) */ interface CumulusPalletDmpQueuePageIndexData extends Struct { readonly beginUsed: u32; readonly endUsed: u32; readonly overweightCount: u64; } - /** @name CumulusPalletDmpQueueError (344) */ + /** @name CumulusPalletDmpQueueError (345) */ interface CumulusPalletDmpQueueError extends Enum { readonly isUnknown: boolean; readonly isOverLimit: boolean; readonly type: 'Unknown' | 'OverLimit'; } - /** @name PalletUniqueError (348) */ + /** @name PalletUniqueError (349) */ interface PalletUniqueError extends Enum { readonly isCollectionDecimalPointLimitExceeded: boolean; readonly isConfirmUnsetSponsorFail: boolean; @@ -2944,7 +2959,7 @@ readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument' | 'RepartitionCalledOnNonRefungibleCollection'; } - /** @name PalletUniqueSchedulerScheduledV3 (351) */ + /** @name PalletUniqueSchedulerScheduledV3 (352) */ interface PalletUniqueSchedulerScheduledV3 extends Struct { readonly maybeId: Option; readonly priority: u8; @@ -2953,7 +2968,7 @@ readonly origin: OpalRuntimeOriginCaller; } - /** @name OpalRuntimeOriginCaller (352) */ + /** @name OpalRuntimeOriginCaller (353) */ interface OpalRuntimeOriginCaller extends Enum { readonly isSystem: boolean; readonly asSystem: FrameSupportDispatchRawOrigin; @@ -2967,7 +2982,7 @@ readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum'; } - /** @name FrameSupportDispatchRawOrigin (353) */ + /** @name FrameSupportDispatchRawOrigin (354) */ interface FrameSupportDispatchRawOrigin extends Enum { readonly isRoot: boolean; readonly isSigned: boolean; @@ -2976,7 +2991,7 @@ readonly type: 'Root' | 'Signed' | 'None'; } - /** @name PalletXcmOrigin (354) */ + /** @name PalletXcmOrigin (355) */ interface PalletXcmOrigin extends Enum { readonly isXcm: boolean; readonly asXcm: XcmV1MultiLocation; @@ -2985,7 +3000,7 @@ readonly type: 'Xcm' | 'Response'; } - /** @name CumulusPalletXcmOrigin (355) */ + /** @name CumulusPalletXcmOrigin (356) */ interface CumulusPalletXcmOrigin extends Enum { readonly isRelay: boolean; readonly isSiblingParachain: boolean; @@ -2993,17 +3008,17 @@ readonly type: 'Relay' | 'SiblingParachain'; } - /** @name PalletEthereumRawOrigin (356) */ + /** @name PalletEthereumRawOrigin (357) */ interface PalletEthereumRawOrigin extends Enum { readonly isEthereumTransaction: boolean; readonly asEthereumTransaction: H160; readonly type: 'EthereumTransaction'; } - /** @name SpCoreVoid (357) */ + /** @name SpCoreVoid (358) */ type SpCoreVoid = Null; - /** @name PalletUniqueSchedulerError (358) */ + /** @name PalletUniqueSchedulerError (359) */ interface PalletUniqueSchedulerError extends Enum { readonly isFailedToSchedule: boolean; readonly isNotFound: boolean; @@ -3012,7 +3027,7 @@ readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange'; } - /** @name UpDataStructsCollection (359) */ + /** @name UpDataStructsCollection (360) */ interface UpDataStructsCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -3025,7 +3040,7 @@ readonly externalCollection: bool; } - /** @name UpDataStructsSponsorshipState (360) */ + /** @name UpDataStructsSponsorshipState (361) */ interface UpDataStructsSponsorshipState extends Enum { readonly isDisabled: boolean; readonly isUnconfirmed: boolean; @@ -3035,43 +3050,43 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } - /** @name UpDataStructsProperties (361) */ + /** @name UpDataStructsProperties (362) */ interface UpDataStructsProperties extends Struct { readonly map: UpDataStructsPropertiesMapBoundedVec; readonly consumedSpace: u32; readonly spaceLimit: u32; } - /** @name UpDataStructsPropertiesMapBoundedVec (362) */ + /** @name UpDataStructsPropertiesMapBoundedVec (363) */ interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap {} - /** @name UpDataStructsPropertiesMapPropertyPermission (367) */ + /** @name UpDataStructsPropertiesMapPropertyPermission (368) */ interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap {} - /** @name UpDataStructsCollectionStats (374) */ + /** @name UpDataStructsCollectionStats (375) */ interface UpDataStructsCollectionStats extends Struct { readonly created: u32; readonly destroyed: u32; readonly alive: u32; } - /** @name UpDataStructsTokenChild (375) */ + /** @name UpDataStructsTokenChild (376) */ interface UpDataStructsTokenChild extends Struct { readonly token: u32; readonly collection: u32; } - /** @name PhantomTypeUpDataStructs (376) */ + /** @name PhantomTypeUpDataStructs (377) */ interface PhantomTypeUpDataStructs extends Vec> {} - /** @name UpDataStructsTokenData (378) */ + /** @name UpDataStructsTokenData (379) */ interface UpDataStructsTokenData extends Struct { readonly properties: Vec; readonly owner: Option; readonly pieces: u128; } - /** @name UpDataStructsRpcCollection (380) */ + /** @name UpDataStructsRpcCollection (381) */ interface UpDataStructsRpcCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -3086,7 +3101,7 @@ readonly readOnly: bool; } - /** @name RmrkTraitsCollectionCollectionInfo (381) */ + /** @name RmrkTraitsCollectionCollectionInfo (382) */ interface RmrkTraitsCollectionCollectionInfo extends Struct { readonly issuer: AccountId32; readonly metadata: Bytes; @@ -3095,7 +3110,7 @@ readonly nftsCount: u32; } - /** @name RmrkTraitsNftNftInfo (382) */ + /** @name RmrkTraitsNftNftInfo (383) */ interface RmrkTraitsNftNftInfo extends Struct { readonly owner: RmrkTraitsNftAccountIdOrCollectionNftTuple; readonly royalty: Option; @@ -3104,13 +3119,13 @@ readonly pending: bool; } - /** @name RmrkTraitsNftRoyaltyInfo (384) */ + /** @name RmrkTraitsNftRoyaltyInfo (385) */ interface RmrkTraitsNftRoyaltyInfo extends Struct { readonly recipient: AccountId32; readonly amount: Permill; } - /** @name RmrkTraitsResourceResourceInfo (385) */ + /** @name RmrkTraitsResourceResourceInfo (386) */ interface RmrkTraitsResourceResourceInfo extends Struct { readonly id: u32; readonly resource: RmrkTraitsResourceResourceTypes; @@ -3118,26 +3133,26 @@ readonly pendingRemoval: bool; } - /** @name RmrkTraitsPropertyPropertyInfo (386) */ + /** @name RmrkTraitsPropertyPropertyInfo (387) */ interface RmrkTraitsPropertyPropertyInfo extends Struct { readonly key: Bytes; readonly value: Bytes; } - /** @name RmrkTraitsBaseBaseInfo (387) */ + /** @name RmrkTraitsBaseBaseInfo (388) */ interface RmrkTraitsBaseBaseInfo extends Struct { readonly issuer: AccountId32; readonly baseType: Bytes; readonly symbol: Bytes; } - /** @name RmrkTraitsNftNftChild (388) */ + /** @name RmrkTraitsNftNftChild (389) */ interface RmrkTraitsNftNftChild extends Struct { readonly collectionId: u32; readonly nftId: u32; } - /** @name PalletCommonError (390) */ + /** @name PalletCommonError (391) */ interface PalletCommonError extends Enum { readonly isCollectionNotFound: boolean; readonly isMustBeTokenOwner: boolean; @@ -3176,7 +3191,7 @@ readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'CantDestroyNotEmptyCollection' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'UserIsNotAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey' | 'CollectionIsExternal' | 'CollectionIsInternal'; } - /** @name PalletFungibleError (392) */ + /** @name PalletFungibleError (393) */ interface PalletFungibleError extends Enum { readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isFungibleItemsHaveNoId: boolean; @@ -3186,12 +3201,12 @@ readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletRefungibleItemData (393) */ + /** @name PalletRefungibleItemData (394) */ interface PalletRefungibleItemData extends Struct { readonly constData: Bytes; } - /** @name PalletRefungibleError (398) */ + /** @name PalletRefungibleError (399) */ interface PalletRefungibleError extends Enum { readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isWrongRefungiblePieces: boolean; @@ -3201,12 +3216,12 @@ readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RepartitionWhileNotOwningAllPieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed'; } - /** @name PalletNonfungibleItemData (399) */ + /** @name PalletNonfungibleItemData (400) */ interface PalletNonfungibleItemData extends Struct { readonly owner: PalletEvmAccountBasicCrossAccountIdRepr; } - /** @name UpDataStructsPropertyScope (401) */ + /** @name UpDataStructsPropertyScope (402) */ interface UpDataStructsPropertyScope extends Enum { readonly isNone: boolean; readonly isRmrk: boolean; @@ -3214,7 +3229,7 @@ readonly type: 'None' | 'Rmrk' | 'Eth'; } - /** @name PalletNonfungibleError (403) */ + /** @name PalletNonfungibleError (404) */ interface PalletNonfungibleError extends Enum { readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean; readonly isNonfungibleItemsHaveNoAmount: boolean; @@ -3222,7 +3237,7 @@ readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount' | 'CantBurnNftWithChildren'; } - /** @name PalletStructureError (404) */ + /** @name PalletStructureError (405) */ interface PalletStructureError extends Enum { readonly isOuroborosDetected: boolean; readonly isDepthLimit: boolean; @@ -3231,7 +3246,7 @@ readonly type: 'OuroborosDetected' | 'DepthLimit' | 'BreadthLimit' | 'TokenNotFound'; } - /** @name PalletRmrkCoreError (405) */ + /** @name PalletRmrkCoreError (406) */ interface PalletRmrkCoreError extends Enum { readonly isCorruptedCollectionType: boolean; readonly isRmrkPropertyKeyIsTooLong: boolean; @@ -3255,7 +3270,7 @@ readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; } - /** @name PalletRmrkEquipError (407) */ + /** @name PalletRmrkEquipError (408) */ interface PalletRmrkEquipError extends Enum { readonly isPermissionError: boolean; readonly isNoAvailableBaseId: boolean; @@ -3267,7 +3282,17 @@ readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart'; } - /** @name PalletEvmError (411) */ + /** @name PalletAppPromotionError (410) */ + interface PalletAppPromotionError extends Enum { + readonly isAdminNotSet: boolean; + readonly isNoPermission: boolean; + readonly isNotSufficientFounds: boolean; + readonly isInvalidArgument: boolean; + readonly isAlreadySponsored: boolean; + readonly type: 'AdminNotSet' | 'NoPermission' | 'NotSufficientFounds' | 'InvalidArgument' | 'AlreadySponsored'; + } + + /** @name PalletEvmError (413) */ interface PalletEvmError extends Enum { readonly isBalanceLow: boolean; readonly isFeeOverflow: boolean; @@ -3278,7 +3303,7 @@ readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce'; } - /** @name FpRpcTransactionStatus (414) */ + /** @name FpRpcTransactionStatus (416) */ interface FpRpcTransactionStatus extends Struct { readonly transactionHash: H256; readonly transactionIndex: u32; @@ -3289,10 +3314,10 @@ readonly logsBloom: EthbloomBloom; } - /** @name EthbloomBloom (416) */ + /** @name EthbloomBloom (418) */ interface EthbloomBloom extends U8aFixed {} - /** @name EthereumReceiptReceiptV3 (418) */ + /** @name EthereumReceiptReceiptV3 (420) */ interface EthereumReceiptReceiptV3 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumReceiptEip658ReceiptData; @@ -3303,7 +3328,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumReceiptEip658ReceiptData (419) */ + /** @name EthereumReceiptEip658ReceiptData (421) */ interface EthereumReceiptEip658ReceiptData extends Struct { readonly statusCode: u8; readonly usedGas: U256; @@ -3311,14 +3336,14 @@ readonly logs: Vec; } - /** @name EthereumBlock (420) */ + /** @name EthereumBlock (422) */ interface EthereumBlock extends Struct { readonly header: EthereumHeader; readonly transactions: Vec; readonly ommers: Vec; } - /** @name EthereumHeader (421) */ + /** @name EthereumHeader (423) */ interface EthereumHeader extends Struct { readonly parentHash: H256; readonly ommersHash: H256; @@ -3337,24 +3362,24 @@ readonly nonce: EthereumTypesHashH64; } - /** @name EthereumTypesHashH64 (422) */ + /** @name EthereumTypesHashH64 (424) */ interface EthereumTypesHashH64 extends U8aFixed {} - /** @name PalletEthereumError (427) */ + /** @name PalletEthereumError (429) */ interface PalletEthereumError extends Enum { readonly isInvalidSignature: boolean; readonly isPreLogExists: boolean; readonly type: 'InvalidSignature' | 'PreLogExists'; } - /** @name PalletEvmCoderSubstrateError (428) */ + /** @name PalletEvmCoderSubstrateError (430) */ interface PalletEvmCoderSubstrateError extends Enum { readonly isOutOfGas: boolean; readonly isOutOfFund: boolean; readonly type: 'OutOfGas' | 'OutOfFund'; } - /** @name PalletEvmContractHelpersSponsoringModeT (429) */ + /** @name PalletEvmContractHelpersSponsoringModeT (431) */ interface PalletEvmContractHelpersSponsoringModeT extends Enum { readonly isDisabled: boolean; readonly isAllowlisted: boolean; @@ -3362,20 +3387,20 @@ readonly type: 'Disabled' | 'Allowlisted' | 'Generous'; } - /** @name PalletEvmContractHelpersError (431) */ + /** @name PalletEvmContractHelpersError (433) */ interface PalletEvmContractHelpersError extends Enum { readonly isNoPermission: boolean; readonly type: 'NoPermission'; } - /** @name PalletEvmMigrationError (432) */ + /** @name PalletEvmMigrationError (434) */ interface PalletEvmMigrationError extends Enum { readonly isAccountNotEmpty: boolean; readonly isAccountIsNotMigrating: boolean; readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating'; } - /** @name SpRuntimeMultiSignature (434) */ + /** @name SpRuntimeMultiSignature (436) */ interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: SpCoreEd25519Signature; @@ -3386,34 +3411,34 @@ readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa'; } - /** @name SpCoreEd25519Signature (435) */ + /** @name SpCoreEd25519Signature (437) */ interface SpCoreEd25519Signature extends U8aFixed {} - /** @name SpCoreSr25519Signature (437) */ + /** @name SpCoreSr25519Signature (439) */ interface SpCoreSr25519Signature extends U8aFixed {} - /** @name SpCoreEcdsaSignature (438) */ + /** @name SpCoreEcdsaSignature (440) */ interface SpCoreEcdsaSignature extends U8aFixed {} - /** @name FrameSystemExtensionsCheckSpecVersion (441) */ + /** @name FrameSystemExtensionsCheckSpecVersion (443) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (442) */ + /** @name FrameSystemExtensionsCheckGenesis (444) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (445) */ + /** @name FrameSystemExtensionsCheckNonce (447) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (446) */ + /** @name FrameSystemExtensionsCheckWeight (448) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (447) */ + /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (449) */ interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name OpalRuntimeRuntime (448) */ + /** @name OpalRuntimeRuntime (450) */ type OpalRuntimeRuntime = Null; - /** @name PalletEthereumFakeTransactionFinalizer (449) */ + /** @name PalletEthereumFakeTransactionFinalizer (451) */ type PalletEthereumFakeTransactionFinalizer = Null; } // declare module