difftreelog
add rpc methods + tests
in: master
17 files changed
client/rpc/src/lib.rsdiffbeforeafterboth--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -262,6 +262,14 @@
#[method(name = "unique_totalStakingLocked")]
fn total_staking_locked(&self, staker: CrossAccountId, at: Option<BlockHash>)
-> Result<String>;
+
+ /// Return the total amount locked by staking tokens.
+ #[method(name = "unique_pendingUnstake")]
+ fn pending_unstake(
+ &self,
+ staker: Option<CrossAccountId>,
+ at: Option<BlockHash>,
+ ) -> Result<String>;
}
mod rmrk_unique_rpc {
@@ -548,6 +556,7 @@
.map(|(b, a)| (b, a.to_string()))
.collect::<Vec<_>>(), unique_api);
pass_method!(total_staking_locked(staker: CrossAccountId) -> String => |v| v.to_string(), unique_api);
+ pass_method!(pending_unstake(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), unique_api);
}
#[allow(deprecated)]
node/cli/src/service.rsdiffbeforeafterboth--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -63,7 +63,7 @@
use fc_rpc_core::types::FilterPool;
use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};
-use unique_runtime_common::types::{
+use up_common::types::opaque::{
AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block, BlockNumber,
};
pallets/app-promotion/src/lib.rsdiffbeforeafterboth--- a/pallets/app-promotion/src/lib.rs
+++ b/pallets/app-promotion/src/lib.rs
@@ -31,12 +31,12 @@
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
-pub mod types;
-
#[cfg(test)]
mod tests;
+pub mod types;
+pub mod weights;
-use sp_std::vec::Vec;
+use sp_std::{vec::Vec, iter::Sum};
use codec::EncodeLike;
use pallet_balances::BalanceLock;
pub use types::ExtendedLockableCurrency;
@@ -48,6 +48,9 @@
},
ensure,
};
+
+use weights::WeightInfo;
+
pub use pallet::*;
use pallet_evm::account::CrossAccountId;
use sp_runtime::{
@@ -79,6 +82,9 @@
type TreasuryAccountId: Get<Self::AccountId>;
+ /// Weight information for extrinsics in this pallet.
+ type WeightInfo: WeightInfo;
+
// The block number provider
type BlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;
@@ -136,6 +142,7 @@
fn on_initialize(current_block: T::BlockNumber) -> Weight
where
<T as frame_system::Config>::BlockNumber: From<u32>,
+ // <<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
{
PendingUnstake::<T>::iter()
.filter_map(|((staker, block), amount)| {
@@ -172,7 +179,7 @@
#[pallet::call]
impl<T: Config> Pallet<T> {
- #[pallet::weight(0)]
+ #[pallet::weight(T::WeightInfo::set_admin_address())]
pub fn set_admin_address(origin: OriginFor<T>, admin: T::AccountId) -> DispatchResult {
ensure_root(origin)?;
<Admin<T>>::set(Some(admin));
@@ -180,7 +187,7 @@
Ok(())
}
- #[pallet::weight(0)]
+ #[pallet::weight(T::WeightInfo::start_app_promotion())]
pub fn start_app_promotion(
origin: OriginFor<T>,
promotion_start_relay_block: T::BlockNumber,
@@ -201,7 +208,7 @@
Ok(())
}
- #[pallet::weight(0)]
+ #[pallet::weight(T::WeightInfo::stake())]
pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
let staker_id = ensure_signed(staker)?;
@@ -210,10 +217,16 @@
ensure!(balance >= amount, ArithmeticError::Underflow);
- Self::set_lock_unchecked(&staker_id, amount);
+ <<T as Config>::Currency as Currency<T::AccountId>>::ensure_can_withdraw(
+ &staker_id,
+ amount,
+ WithdrawReasons::all(),
+ balance - amount,
+ )?;
+
+ Self::add_lock_balance(&staker_id, amount)?;
- let block_number =
- <T::BlockNumberProvider as BlockNumberProvider>::current_block_number();
+ let block_number = frame_system::Pallet::<T>::block_number();
<Staked<T>>::insert(
(&staker_id, block_number),
@@ -231,7 +244,7 @@
Ok(())
}
- #[pallet::weight(0)]
+ #[pallet::weight(T::WeightInfo::unstake())]
pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
let staker_id = ensure_signed(staker)?;
@@ -249,7 +262,7 @@
.ok_or(ArithmeticError::Underflow)?,
);
- let block = <T::BlockNumberProvider>::current_block_number() + WEEK.into();
+ let block = frame_system::Pallet::<T>::block_number() + WEEK.into();
<PendingUnstake<T>>::insert(
(&staker_id, block),
<PendingUnstake<T>>::get((&staker_id, block))
@@ -400,8 +413,8 @@
fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
Self::get_locked_balance(staker)
- .map(|l| l.amount)
- .and_then(|b| b.checked_add(&amount))
+ .map_or(<BalanceOf<T>>::default(), |l| l.amount)
+ .checked_add(&amount)
.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))
.ok_or(ArithmeticError::Overflow.into())
}
@@ -437,10 +450,11 @@
pub fn total_staked_by_id_per_block(
staker: impl EncodeLike<T::AccountId>,
) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
- let staked = Staked::<T>::iter_prefix((staker,))
+ let mut staked = Staked::<T>::iter_prefix((staker,))
.into_iter()
.map(|(block, amount)| (block, amount))
.collect::<Vec<_>>();
+ staked.sort_by_key(|(block, _)| *block);
if !staked.is_empty() {
Some(staked)
} else {
@@ -495,3 +509,14 @@
day_rate * base
}
}
+
+impl<T: Config> Pallet<T>
+where
+ <<T as pallet::Config>::Currency as Currency<T::AccountId>>::Balance: Sum,
+{
+ pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {
+ staker.map_or(PendingUnstake::<T>::iter_values().sum(), |s| {
+ PendingUnstake::<T>::iter_prefix_values((s.as_sub(),)).sum()
+ })
+ }
+}
primitives/rpc/src/lib.rsdiffbeforeafterboth--- a/primitives/rpc/src/lib.rs
+++ b/primitives/rpc/src/lib.rs
@@ -129,5 +129,6 @@
fn total_staked(staker: Option<CrossAccountId>) -> Result<u128>;
fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>>;
fn total_staking_locked(staker: CrossAccountId) -> Result<u128>;
+ fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128>;
}
}
runtime/common/config/pallets/app_promotion.rsdiffbeforeafterboth--- /dev/null
+++ b/runtime/common/config/pallets/app_promotion.rs
@@ -0,0 +1,27 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+ runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider},
+ Runtime, Balances,
+};
+
+impl pallet_app_promotion::Config for Runtime {
+ type Currency = Balances;
+ type WeightInfo = pallet_app_promotion::weights::SubstrateWeight<Self>;
+ type TreasuryAccountId = TreasuryAccountId;
+ type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
+}
runtime/common/config/pallets/mod.rsdiffbeforeafterboth--- a/runtime/common/config/pallets/mod.rs
+++ b/runtime/common/config/pallets/mod.rs
@@ -40,6 +40,9 @@
#[cfg(feature = "scheduler")]
pub mod scheduler;
+#[cfg(feature = "app-promotion")]
+pub mod app_promotion;
+
parameter_types! {
pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();
pub const CollectionCreationPrice: Balance = 2 * UNIQUE;
runtime/common/construct_runtime/mod.rsdiffbeforeafterboth--- a/runtime/common/construct_runtime/mod.rs
+++ b/runtime/common/construct_runtime/mod.rs
@@ -77,6 +77,9 @@
#[runtimes(opal)]
RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
+ #[runtimes(opal)]
+ Promotion: pallet_app_promotion::{Pallet, Call, Storage} = 73,
+
// Frontier
EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,
Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,
runtime/common/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -190,7 +190,6 @@
fn total_staked(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked(staker).unwrap_or_default())
- // Ok(0)
}
fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {
@@ -198,9 +197,12 @@
}
fn total_staking_locked(staker: CrossAccountId) -> Result<u128, DispatchError> {
- // Ok(0)
Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_locked_balance(staker))
}
+
+ fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {
+ Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_pending_unstake(staker))
+ }
}
impl rmrk_rpc::RmrkApi<
runtime/opal/Cargo.tomldiffbeforeafterboth--- a/runtime/opal/Cargo.toml
+++ b/runtime/opal/Cargo.toml
@@ -124,11 +124,12 @@
"orml-vesting/std",
]
limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']
-opal-runtime = ['refungible', 'scheduler', 'rmrk']
+opal-runtime = ['refungible', 'scheduler', 'rmrk', 'app-promotion']
refungible = []
scheduler = []
rmrk = []
+app-promotion = []
################################################################################
# Substrate Dependencies
tests/src/app-promotion.test.tsdiffbeforeafterboth--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -15,7 +15,7 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {default as usingApi, submitTransactionAsync} from './substrate/substrate-api';
-import {IKeyringPair} from '@polkadot/types/types';
+import {IKeyringPair, ITuple} from '@polkadot/types/types';
import {
createMultipleItemsExpectSuccess,
@@ -33,26 +33,38 @@
U128_MAX,
burnFromExpectSuccess,
UNIQUE,
+ getModuleNames,
+ Pallets,
+ getBlockNumber,
} from './util/helpers';
-import chai from 'chai';
+import chai, {use} from 'chai';
import chaiAsPromised from 'chai-as-promised';
-import getBalance from './substrate/get-balance';
-import { unique } from './interfaces/definitions';
+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 {UniqueHelper} from './util/playgrounds/unique';
chai.use(chaiAsPromised);
const expect = chai.expect;
let alice: IKeyringPair;
let bob: IKeyringPair;
let palletAdmin: IKeyringPair;
+let nominal: bigint;
describe('integration test: AppPromotion', () => {
- before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
+ 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 = api.tx.sudo.sudo(api.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+ const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(palletAdmin.addressRaw));
+ nominal = helper.balance.getOneTokenNominal();
await submitTransactionAsync(alice, tx);
});
});
@@ -69,22 +81,110 @@
// assert: query appPromotion.staked(Alice) equal [100, 200]
// assert: query appPromotion.totalStaked() increased by 200
- await usingApi(async (api, privateKeyWrapper) => {
- await submitTransactionAsync(alice, api.tx.balances.transfer(bob.addressRaw, 10n * UNIQUE));
- const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alice.address, bob.address]);
+ await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+ 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;
+ 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);
- console.log(`alice: ${alicesBalanceBefore} \n bob: ${bobsBalanceBefore}`);
+ await waitNewBlocks(helper.api!, 1);
+ const secondStakedBlock = await helper.chain.getLatestBlockNumber();
- await submitTransactionAsync(alice, api.tx.promotion.stake(1n * UNIQUE));
- await submitTransactionAsync(bob, api.tx.promotion.stake(1n * UNIQUE));
- const alice_total_staked = (await (api.rpc.unique.totalStaked(normalizeAccountId(alice)))).toBigInt();
- const bob_total_staked = (await api.rpc.unique.totalStaked(normalizeAccountId(bob))).toBigInt();
-
- console.log(`alice staked: ${alice_total_staked} \n bob staked: ${bob_total_staked}, total staked: ${(await api.rpc.unique.totalStaked()).toBigInt()}`);
+ await expect(submitTransactionAsync(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()]);
+ expect(stakedPerBlock.map((x) => x[1])).to.be.deep.equal([nominal, 2n * nominal]);
+ });
+ });
+
+ it('will throws if stake amount is more than total free balance', async () => {
+ // arrange: Alice balance = 1000
+ // assert: Alice calls appPromotion.stake(1000) throws /// because Alice needs some fee
+
+ // act: Alice calls appPromotion.stake(700)
+ // assert: Alice calls appPromotion.stake(400) throws /// because Alice has ~300 free QTZ and 700 locked
+
+ await usingPlaygrounds(async helper => {
+ 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;
});
});
+
+ it.skip('for different accounts in one block is possible', async () => {
+ // arrange: Alice, Bob, Charlie, Dave balance = 1000
+ // arrange: Alice, Bob, Charlie, Dave calls appPromotion.stake(100) in the same time
+
+ // assert: query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]
+ await usingPlaygrounds(async helper => {
+ const crowd = await creteAccounts([10n, 10n, 10n, 10n], alice, helper);
+ // const promises = crowd.map(async user => submitTransactionAsync(user, helper.api!.tx.promotion.stake(nominal)));
+ // await expect(Promise.all(promises)).to.be.eventually.fulfilled;
+ });
+ });
+
+});
+
+describe.skip('unstake balance 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));
+ nominal = helper.balance.getOneTokenNominal();
+ await submitTransactionAsync(alice, tx);
+ });
+ });
+ it('will change balance state to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {
+ // arrange: Alice balance = 1000
+ // arrange: Alice calls appPromotion.stake(Alice, 500)
+
+ // act: Alice calls appPromotion.unstake(300)
+ // assert: Alice reserved balance to equal 300
+ // assert: query appPromotion.staked(Alice) equal [200] /// 500 - 300
+ // assert: query appPromotion.pendingUnstake(Alice) to equal [300]
+ // assert: query appPromotion.totalStaked() decreased by 300
+ });
+});
+
+
+
+async function createUser(amount?: bigint) {
+ return await usingPlaygrounds(async (helper, privateKeyWrapper) => {
+ const user: IKeyringPair = privateKeyWrapper(`//Alice+${(new Date()).getTime()}`);
+ await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());
+ return user;
+ });
+}
+
+const creteAccounts = async (balances: bigint[], donor: IKeyringPair, helper: UniqueHelper) => {
+ let nonce = await helper.chain.getNonce(donor.address);
+ const tokenNominal = helper.balance.getOneTokenNominal();
+ const transactions = [];
+ const accounts = [];
+ for (const balance of balances) {
+ const recepient = helper.util.fromSeed(mnemonicGenerate());
+ accounts.push(recepient);
+ if (balance !== 0n){
+ const tx = helper.constructApiCall('api.tx.balances.transfer', [{Id: recepient.address}, balance * tokenNominal]);
+ transactions.push(helper.signTransaction(donor, tx, 'account generation', {nonce}));
+ nonce++;
+ }
+ }
-});
\ No newline at end of file
+ await Promise.all(transactions);
+ return accounts;
+};
\ No newline at end of file
tests/src/interfaces/augment-api-rpc.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -703,6 +703,10 @@
**/
nextSponsored: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
/**
+ * Returns the total amount of unstaked tokens
+ **/
+ pendingUnstake: AugmentedRpc<(staker?: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;
+ /**
* Get property permissions, optionally limited to the provided keys
**/
propertyPermissions: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys?: Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsPropertyKeyPermission>>>;
tests/src/interfaces/lookup.tsdiffbeforeafterboth1// Auto-generated via `yarn polkadot-types-from-defs`, do not edit2/* eslint-disable */34/* eslint-disable sort-keys */56export default {7 /**8 * Lookup2: polkadot_primitives::v2::PersistedValidationData<primitive_types::H256, N>9 **/10 PolkadotPrimitivesV2PersistedValidationData: {11 parentHead: 'Bytes',12 relayParentNumber: 'u32',13 relayParentStorageRoot: 'H256',14 maxPovSize: 'u32'15 },16 /**17 * Lookup9: polkadot_primitives::v2::UpgradeRestriction18 **/19 PolkadotPrimitivesV2UpgradeRestriction: {20 _enum: ['Present']21 },22 /**23 * Lookup10: sp_trie::storage_proof::StorageProof24 **/25 SpTrieStorageProof: {26 trieNodes: 'BTreeSet<Bytes>'27 },28 /**29 * Lookup13: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot30 **/31 CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {32 dmqMqcHead: 'H256',33 relayDispatchQueueSize: '(u32,u32)',34 ingressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>',35 egressChannels: 'Vec<(u32,PolkadotPrimitivesV2AbridgedHrmpChannel)>'36 },37 /**38 * Lookup18: polkadot_primitives::v2::AbridgedHrmpChannel39 **/40 PolkadotPrimitivesV2AbridgedHrmpChannel: {41 maxCapacity: 'u32',42 maxTotalSize: 'u32',43 maxMessageSize: 'u32',44 msgCount: 'u32',45 totalSize: 'u32',46 mqcHead: 'Option<H256>'47 },48 /**49 * Lookup20: polkadot_primitives::v2::AbridgedHostConfiguration50 **/51 PolkadotPrimitivesV2AbridgedHostConfiguration: {52 maxCodeSize: 'u32',53 maxHeadDataSize: 'u32',54 maxUpwardQueueCount: 'u32',55 maxUpwardQueueSize: 'u32',56 maxUpwardMessageSize: 'u32',57 maxUpwardMessageNumPerCandidate: 'u32',58 hrmpMaxMessageNumPerCandidate: 'u32',59 validationUpgradeCooldown: 'u32',60 validationUpgradeDelay: 'u32'61 },62 /**63 * Lookup26: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>64 **/65 PolkadotCorePrimitivesOutboundHrmpMessage: {66 recipient: 'u32',67 data: 'Bytes'68 },69 /**70 * Lookup28: cumulus_pallet_parachain_system::pallet::Call<T>71 **/72 CumulusPalletParachainSystemCall: {73 _enum: {74 set_validation_data: {75 data: 'CumulusPrimitivesParachainInherentParachainInherentData',76 },77 sudo_send_upward_message: {78 message: 'Bytes',79 },80 authorize_upgrade: {81 codeHash: 'H256',82 },83 enact_authorized_upgrade: {84 code: 'Bytes'85 }86 }87 },88 /**89 * Lookup29: cumulus_primitives_parachain_inherent::ParachainInherentData90 **/91 CumulusPrimitivesParachainInherentParachainInherentData: {92 validationData: 'PolkadotPrimitivesV2PersistedValidationData',93 relayChainState: 'SpTrieStorageProof',94 downwardMessages: 'Vec<PolkadotCorePrimitivesInboundDownwardMessage>',95 horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'96 },97 /**98 * Lookup31: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>99 **/100 PolkadotCorePrimitivesInboundDownwardMessage: {101 sentAt: 'u32',102 msg: 'Bytes'103 },104 /**105 * Lookup34: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>106 **/107 PolkadotCorePrimitivesInboundHrmpMessage: {108 sentAt: 'u32',109 data: 'Bytes'110 },111 /**112 * Lookup37: cumulus_pallet_parachain_system::pallet::Event<T>113 **/114 CumulusPalletParachainSystemEvent: {115 _enum: {116 ValidationFunctionStored: 'Null',117 ValidationFunctionApplied: {118 relayChainBlockNum: 'u32',119 },120 ValidationFunctionDiscarded: 'Null',121 UpgradeAuthorized: {122 codeHash: 'H256',123 },124 DownwardMessagesReceived: {125 count: 'u32',126 },127 DownwardMessagesProcessed: {128 weightUsed: 'u64',129 dmqHead: 'H256'130 }131 }132 },133 /**134 * Lookup38: cumulus_pallet_parachain_system::pallet::Error<T>135 **/136 CumulusPalletParachainSystemError: {137 _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']138 },139 /**140 * Lookup41: pallet_balances::AccountData<Balance>141 **/142 PalletBalancesAccountData: {143 free: 'u128',144 reserved: 'u128',145 miscFrozen: 'u128',146 feeFrozen: 'u128'147 },148 /**149 * Lookup43: pallet_balances::BalanceLock<Balance>150 **/151 PalletBalancesBalanceLock: {152 id: '[u8;8]',153 amount: 'u128',154 reasons: 'PalletBalancesReasons'155 },156 /**157 * Lookup45: pallet_balances::Reasons158 **/159 PalletBalancesReasons: {160 _enum: ['Fee', 'Misc', 'All']161 },162 /**163 * Lookup48: pallet_balances::ReserveData<ReserveIdentifier, Balance>164 **/165 PalletBalancesReserveData: {166 id: '[u8;16]',167 amount: 'u128'168 },169 /**170 * Lookup171: pallet_balances::Releases171 **/172 PalletBalancesReleases: {173 _enum: ['V1_0_0', 'V2_0_0']174 },175 /**176 * Lookup172: pallet_balances::pallet::Call<T, I>177 **/178 PalletBalancesCall: {179 _enum: {180 transfer: {181 dest: 'MultiAddress',182 value: 'Compact<u128>',183 },184 set_balance: {185 who: 'MultiAddress',186 newFree: 'Compact<u128>',187 newReserved: 'Compact<u128>',188 },189 force_transfer: {190 source: 'MultiAddress',191 dest: 'MultiAddress',192 value: 'Compact<u128>',193 },194 transfer_keep_alive: {195 dest: 'MultiAddress',196 value: 'Compact<u128>',197 },198 transfer_all: {199 dest: 'MultiAddress',200 keepAlive: 'bool',201 },202 force_unreserve: {203 who: 'MultiAddress',204 amount: 'u128'205 }206 }207 },208 /**209 * Lookup175: pallet_balances::pallet::Error<T, I>210 **/211 PalletBalancesError: {212 _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'KeepAlive', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves']213 },214 /**215 * Lookup177: pallet_timestamp::pallet::Call<T>216 **/217 PalletTimestampCall: {218 _enum: {219 set: {220 now: 'Compact<u64>'221 }222 }223 },224 /**225 * Lookup179: pallet_transaction_payment::Releases226 **/227 PalletTransactionPaymentReleases: {228 _enum: ['V1Ancient', 'V2']229 },230 /**231 * Lookup180: pallet_treasury::Proposal<sp_core::crypto::AccountId32, Balance>232 **/233 PalletTreasuryProposal: {234 proposer: 'AccountId32',235 value: 'u128',236 beneficiary: 'AccountId32',237 bond: 'u128'238 },239 /**240 * Lookup183: pallet_treasury::pallet::Call<T, I>241 **/242 PalletTreasuryCall: {243 _enum: {244 propose_spend: {245 value: 'Compact<u128>',246 beneficiary: 'MultiAddress',247 },248 reject_proposal: {249 proposalId: 'Compact<u32>',250 },251 approve_proposal: {252 proposalId: 'Compact<u32>',253 },254 spend: {255 amount: 'Compact<u128>',256 beneficiary: 'MultiAddress',257 },258 remove_approval: {259 proposalId: 'Compact<u32>'260 }261 }262 },263 /**264 * Lookup186: frame_support::PalletId265 **/266 FrameSupportPalletId: '[u8;8]',267 /**268 * Lookup187: pallet_treasury::pallet::Error<T, I>269 **/270 PalletTreasuryError: {271 _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved']272 },273 /**274 * Lookup188: pallet_sudo::pallet::Call<T>275 **/276 PalletSudoCall: {277 _enum: {278 sudo: {279 call: 'Call',280 },281 sudo_unchecked_weight: {282 call: 'Call',283 weight: 'u64',284 },285 set_key: {286 _alias: {287 new_: 'new',288 },289 new_: 'MultiAddress',290 },291 sudo_as: {292 who: 'MultiAddress',293 call: 'Call'294 }295 }296 },297 /**298 * Lookup190: orml_vesting::module::Call<T>299 **/300 OrmlVestingModuleCall: {301 _enum: {302 claim: 'Null',303 vested_transfer: {304 dest: 'MultiAddress',305 schedule: 'OrmlVestingVestingSchedule',306 },307 update_vesting_schedules: {308 who: 'MultiAddress',309 vestingSchedules: 'Vec<OrmlVestingVestingSchedule>',310 },311 claim_for: {312 dest: 'MultiAddress'313 }314 }315 },316 /**317 * Lookup192: cumulus_pallet_xcmp_queue::pallet::Call<T>318 **/319 CumulusPalletXcmpQueueCall: {320 _enum: {321 service_overweight: {322 index: 'u64',323 weightLimit: 'u64',324 },325 suspend_xcm_execution: 'Null',326 resume_xcm_execution: 'Null',327 update_suspend_threshold: {328 _alias: {329 new_: 'new',330 },331 new_: 'u32',332 },333 update_drop_threshold: {334 _alias: {335 new_: 'new',336 },337 new_: 'u32',338 },339 update_resume_threshold: {340 _alias: {341 new_: 'new',342 },343 new_: 'u32',344 },345 update_threshold_weight: {346 _alias: {347 new_: 'new',348 },349 new_: 'u64',350 },351 update_weight_restrict_decay: {352 _alias: {353 new_: 'new',354 },355 new_: 'u64',356 },357 update_xcmp_max_individual_weight: {358 _alias: {359 new_: 'new',360 },361 new_: 'u64'362 }363 }364 },365 /**366 * Lookup193: pallet_xcm::pallet::Call<T>367 **/368 PalletXcmCall: {369 _enum: {370 send: {371 dest: 'XcmVersionedMultiLocation',372 message: 'XcmVersionedXcm',373 },374 teleport_assets: {375 dest: 'XcmVersionedMultiLocation',376 beneficiary: 'XcmVersionedMultiLocation',377 assets: 'XcmVersionedMultiAssets',378 feeAssetItem: 'u32',379 },380 reserve_transfer_assets: {381 dest: 'XcmVersionedMultiLocation',382 beneficiary: 'XcmVersionedMultiLocation',383 assets: 'XcmVersionedMultiAssets',384 feeAssetItem: 'u32',385 },386 execute: {387 message: 'XcmVersionedXcm',388 maxWeight: 'u64',389 },390 force_xcm_version: {391 location: 'XcmV1MultiLocation',392 xcmVersion: 'u32',393 },394 force_default_xcm_version: {395 maybeXcmVersion: 'Option<u32>',396 },397 force_subscribe_version_notify: {398 location: 'XcmVersionedMultiLocation',399 },400 force_unsubscribe_version_notify: {401 location: 'XcmVersionedMultiLocation',402 },403 limited_reserve_transfer_assets: {404 dest: 'XcmVersionedMultiLocation',405 beneficiary: 'XcmVersionedMultiLocation',406 assets: 'XcmVersionedMultiAssets',407 feeAssetItem: 'u32',408 weightLimit: 'XcmV2WeightLimit',409 },410 limited_teleport_assets: {411 dest: 'XcmVersionedMultiLocation',412 beneficiary: 'XcmVersionedMultiLocation',413 assets: 'XcmVersionedMultiAssets',414 feeAssetItem: 'u32',415 weightLimit: 'XcmV2WeightLimit'416 }417 }418 },419 /**420 * Lookup194: xcm::VersionedXcm<Call>421 **/422 XcmVersionedXcm: {423 _enum: {424 V0: 'XcmV0Xcm',425 V1: 'XcmV1Xcm',426 V2: 'XcmV2Xcm'427 }428 },429 /**430 * Lookup195: xcm::v0::Xcm<Call>431 **/432 XcmV0Xcm: {433 _enum: {434 WithdrawAsset: {435 assets: 'Vec<XcmV0MultiAsset>',436 effects: 'Vec<XcmV0Order>',437 },438 ReserveAssetDeposit: {439 assets: 'Vec<XcmV0MultiAsset>',440 effects: 'Vec<XcmV0Order>',441 },442 TeleportAsset: {443 assets: 'Vec<XcmV0MultiAsset>',444 effects: 'Vec<XcmV0Order>',445 },446 QueryResponse: {447 queryId: 'Compact<u64>',448 response: 'XcmV0Response',449 },450 TransferAsset: {451 assets: 'Vec<XcmV0MultiAsset>',452 dest: 'XcmV0MultiLocation',453 },454 TransferReserveAsset: {455 assets: 'Vec<XcmV0MultiAsset>',456 dest: 'XcmV0MultiLocation',457 effects: 'Vec<XcmV0Order>',458 },459 Transact: {460 originType: 'XcmV0OriginKind',461 requireWeightAtMost: 'u64',462 call: 'XcmDoubleEncoded',463 },464 HrmpNewChannelOpenRequest: {465 sender: 'Compact<u32>',466 maxMessageSize: 'Compact<u32>',467 maxCapacity: 'Compact<u32>',468 },469 HrmpChannelAccepted: {470 recipient: 'Compact<u32>',471 },472 HrmpChannelClosing: {473 initiator: 'Compact<u32>',474 sender: 'Compact<u32>',475 recipient: 'Compact<u32>',476 },477 RelayedFrom: {478 who: 'XcmV0MultiLocation',479 message: 'XcmV0Xcm'480 }481 }482 },483 /**484 * Lookup197: xcm::v0::order::Order<Call>485 **/486 XcmV0Order: {487 _enum: {488 Null: 'Null',489 DepositAsset: {490 assets: 'Vec<XcmV0MultiAsset>',491 dest: 'XcmV0MultiLocation',492 },493 DepositReserveAsset: {494 assets: 'Vec<XcmV0MultiAsset>',495 dest: 'XcmV0MultiLocation',496 effects: 'Vec<XcmV0Order>',497 },498 ExchangeAsset: {499 give: 'Vec<XcmV0MultiAsset>',500 receive: 'Vec<XcmV0MultiAsset>',501 },502 InitiateReserveWithdraw: {503 assets: 'Vec<XcmV0MultiAsset>',504 reserve: 'XcmV0MultiLocation',505 effects: 'Vec<XcmV0Order>',506 },507 InitiateTeleport: {508 assets: 'Vec<XcmV0MultiAsset>',509 dest: 'XcmV0MultiLocation',510 effects: 'Vec<XcmV0Order>',511 },512 QueryHolding: {513 queryId: 'Compact<u64>',514 dest: 'XcmV0MultiLocation',515 assets: 'Vec<XcmV0MultiAsset>',516 },517 BuyExecution: {518 fees: 'XcmV0MultiAsset',519 weight: 'u64',520 debt: 'u64',521 haltOnError: 'bool',522 xcm: 'Vec<XcmV0Xcm>'523 }524 }525 },526 /**527 * Lookup199: xcm::v0::Response528 **/529 XcmV0Response: {530 _enum: {531 Assets: 'Vec<XcmV0MultiAsset>'532 }533 },534 /**535 * Lookup200: xcm::v1::Xcm<Call>536 **/537 XcmV1Xcm: {538 _enum: {539 WithdrawAsset: {540 assets: 'XcmV1MultiassetMultiAssets',541 effects: 'Vec<XcmV1Order>',542 },543 ReserveAssetDeposited: {544 assets: 'XcmV1MultiassetMultiAssets',545 effects: 'Vec<XcmV1Order>',546 },547 ReceiveTeleportedAsset: {548 assets: 'XcmV1MultiassetMultiAssets',549 effects: 'Vec<XcmV1Order>',550 },551 QueryResponse: {552 queryId: 'Compact<u64>',553 response: 'XcmV1Response',554 },555 TransferAsset: {556 assets: 'XcmV1MultiassetMultiAssets',557 beneficiary: 'XcmV1MultiLocation',558 },559 TransferReserveAsset: {560 assets: 'XcmV1MultiassetMultiAssets',561 dest: 'XcmV1MultiLocation',562 effects: 'Vec<XcmV1Order>',563 },564 Transact: {565 originType: 'XcmV0OriginKind',566 requireWeightAtMost: 'u64',567 call: 'XcmDoubleEncoded',568 },569 HrmpNewChannelOpenRequest: {570 sender: 'Compact<u32>',571 maxMessageSize: 'Compact<u32>',572 maxCapacity: 'Compact<u32>',573 },574 HrmpChannelAccepted: {575 recipient: 'Compact<u32>',576 },577 HrmpChannelClosing: {578 initiator: 'Compact<u32>',579 sender: 'Compact<u32>',580 recipient: 'Compact<u32>',581 },582 RelayedFrom: {583 who: 'XcmV1MultilocationJunctions',584 message: 'XcmV1Xcm',585 },586 SubscribeVersion: {587 queryId: 'Compact<u64>',588 maxResponseWeight: 'Compact<u64>',589 },590 UnsubscribeVersion: 'Null'591 }592 },593 /**594 * Lookup202: xcm::v1::order::Order<Call>595 **/596 XcmV1Order: {597 _enum: {598 Noop: 'Null',599 DepositAsset: {600 assets: 'XcmV1MultiassetMultiAssetFilter',601 maxAssets: 'u32',602 beneficiary: 'XcmV1MultiLocation',603 },604 DepositReserveAsset: {605 assets: 'XcmV1MultiassetMultiAssetFilter',606 maxAssets: 'u32',607 dest: 'XcmV1MultiLocation',608 effects: 'Vec<XcmV1Order>',609 },610 ExchangeAsset: {611 give: 'XcmV1MultiassetMultiAssetFilter',612 receive: 'XcmV1MultiassetMultiAssets',613 },614 InitiateReserveWithdraw: {615 assets: 'XcmV1MultiassetMultiAssetFilter',616 reserve: 'XcmV1MultiLocation',617 effects: 'Vec<XcmV1Order>',618 },619 InitiateTeleport: {620 assets: 'XcmV1MultiassetMultiAssetFilter',621 dest: 'XcmV1MultiLocation',622 effects: 'Vec<XcmV1Order>',623 },624 QueryHolding: {625 queryId: 'Compact<u64>',626 dest: 'XcmV1MultiLocation',627 assets: 'XcmV1MultiassetMultiAssetFilter',628 },629 BuyExecution: {630 fees: 'XcmV1MultiAsset',631 weight: 'u64',632 debt: 'u64',633 haltOnError: 'bool',634 instructions: 'Vec<XcmV1Xcm>'635 }636 }637 },638 /**639 * Lookup204: xcm::v1::Response640 **/641 XcmV1Response: {642 _enum: {643 Assets: 'XcmV1MultiassetMultiAssets',644 Version: 'u32'645 }646 },647 /**648 * Lookup218: cumulus_pallet_xcm::pallet::Call<T>649 **/650 CumulusPalletXcmCall: 'Null',651 /**652 * Lookup219: cumulus_pallet_dmp_queue::pallet::Call<T>653 **/654 CumulusPalletDmpQueueCall: {655 _enum: {656 service_overweight: {657 index: 'u64',658 weightLimit: 'u64'659 }660 }661 },662 /**663 * Lookup220: pallet_inflation::pallet::Call<T>664 **/665 PalletInflationCall: {666 _enum: {667 start_inflation: {668 inflationStartRelayBlock: 'u32'669 }670 }671 },672 /**673 * Lookup221: pallet_unique::Call<T>674 **/675 PalletUniqueCall: {676 _enum: {677 create_collection: {678 collectionName: 'Vec<u16>',679 collectionDescription: 'Vec<u16>',680 tokenPrefix: 'Bytes',681 mode: 'UpDataStructsCollectionMode',682 },683 create_collection_ex: {684 data: 'UpDataStructsCreateCollectionData',685 },686 destroy_collection: {687 collectionId: 'u32',688 },689 add_to_allow_list: {690 collectionId: 'u32',691 address: 'PalletEvmAccountBasicCrossAccountIdRepr',692 },693 remove_from_allow_list: {694 collectionId: 'u32',695 address: 'PalletEvmAccountBasicCrossAccountIdRepr',696 },697 change_collection_owner: {698 collectionId: 'u32',699 newOwner: 'AccountId32',700 },701 add_collection_admin: {702 collectionId: 'u32',703 newAdminId: 'PalletEvmAccountBasicCrossAccountIdRepr',704 },705 remove_collection_admin: {706 collectionId: 'u32',707 accountId: 'PalletEvmAccountBasicCrossAccountIdRepr',708 },709 set_collection_sponsor: {710 collectionId: 'u32',711 newSponsor: 'AccountId32',712 },713 confirm_sponsorship: {714 collectionId: 'u32',715 },716 remove_collection_sponsor: {717 collectionId: 'u32',718 },719 create_item: {720 collectionId: 'u32',721 owner: 'PalletEvmAccountBasicCrossAccountIdRepr',722 data: 'UpDataStructsCreateItemData',723 },724 create_multiple_items: {725 collectionId: 'u32',726 owner: 'PalletEvmAccountBasicCrossAccountIdRepr',727 itemsData: 'Vec<UpDataStructsCreateItemData>',728 },729 set_collection_properties: {730 collectionId: 'u32',731 properties: 'Vec<UpDataStructsProperty>',732 },733 delete_collection_properties: {734 collectionId: 'u32',735 propertyKeys: 'Vec<Bytes>',736 },737 set_token_properties: {738 collectionId: 'u32',739 tokenId: 'u32',740 properties: 'Vec<UpDataStructsProperty>',741 },742 delete_token_properties: {743 collectionId: 'u32',744 tokenId: 'u32',745 propertyKeys: 'Vec<Bytes>',746 },747 set_token_property_permissions: {748 collectionId: 'u32',749 propertyPermissions: 'Vec<UpDataStructsPropertyKeyPermission>',750 },751 create_multiple_items_ex: {752 collectionId: 'u32',753 data: 'UpDataStructsCreateItemExData',754 },755<<<<<<< HEAD756 set_transfers_enabled_flag: {757 collectionId: 'u32',758 value: 'bool',759=======760 finish: {761 address: 'H160',762 code: 'Bytes'763 }764 }765 },766 /**767 * Lookup259: pallet_sudo::pallet::Event<T>768 **/769 PalletSudoEvent: {770 _enum: {771 Sudid: {772 sudoResult: 'Result<Null, SpRuntimeDispatchError>',773>>>>>>> b43f8da0... added totalstaked & fix bug with number in RPC Client774 },775 burn_item: {776 collectionId: 'u32',777 itemId: 'u32',778 value: 'u128',779 },780 burn_from: {781 collectionId: 'u32',782 from: 'PalletEvmAccountBasicCrossAccountIdRepr',783 itemId: 'u32',784 value: 'u128',785 },786 transfer: {787 recipient: 'PalletEvmAccountBasicCrossAccountIdRepr',788 collectionId: 'u32',789 itemId: 'u32',790 value: 'u128',791 },792 approve: {793 spender: 'PalletEvmAccountBasicCrossAccountIdRepr',794 collectionId: 'u32',795 itemId: 'u32',796 amount: 'u128',797 },798 transfer_from: {799 from: 'PalletEvmAccountBasicCrossAccountIdRepr',800 recipient: 'PalletEvmAccountBasicCrossAccountIdRepr',801 collectionId: 'u32',802 itemId: 'u32',803 value: 'u128',804 },805 set_collection_limits: {806 collectionId: 'u32',807 newLimit: 'UpDataStructsCollectionLimits',808 },809 set_collection_permissions: {810 collectionId: 'u32',811 newPermission: 'UpDataStructsCollectionPermissions',812 },813 repartition: {814 collectionId: 'u32',815 tokenId: 'u32',816 amount: 'u128'817 }818 }819 },820 /**821 * Lookup226: up_data_structs::CollectionMode822 **/823 UpDataStructsCollectionMode: {824 _enum: {825 NFT: 'Null',826 Fungible: 'u8',827 ReFungible: 'Null'828 }829 },830 /**831 * Lookup227: up_data_structs::CreateCollectionData<sp_core::crypto::AccountId32>832 **/833 UpDataStructsCreateCollectionData: {834 mode: 'UpDataStructsCollectionMode',835 access: 'Option<UpDataStructsAccessMode>',836 name: 'Vec<u16>',837 description: 'Vec<u16>',838 tokenPrefix: 'Bytes',839 pendingSponsor: 'Option<AccountId32>',840 limits: 'Option<UpDataStructsCollectionLimits>',841 permissions: 'Option<UpDataStructsCollectionPermissions>',842 tokenPropertyPermissions: 'Vec<UpDataStructsPropertyKeyPermission>',843 properties: 'Vec<UpDataStructsProperty>'844 },845 /**846 * Lookup229: up_data_structs::AccessMode847 **/848 UpDataStructsAccessMode: {849 _enum: ['Normal', 'AllowList']850 },851 /**852 * Lookup231: up_data_structs::CollectionLimits853 **/854 UpDataStructsCollectionLimits: {855 accountTokenOwnershipLimit: 'Option<u32>',856 sponsoredDataSize: 'Option<u32>',857 sponsoredDataRateLimit: 'Option<UpDataStructsSponsoringRateLimit>',858 tokenLimit: 'Option<u32>',859 sponsorTransferTimeout: 'Option<u32>',860 sponsorApproveTimeout: 'Option<u32>',861 ownerCanTransfer: 'Option<bool>',862 ownerCanDestroy: 'Option<bool>',863 transfersEnabled: 'Option<bool>'864 },865 /**866 * Lookup233: up_data_structs::SponsoringRateLimit867 **/868 UpDataStructsSponsoringRateLimit: {869 _enum: {870 SponsoringDisabled: 'Null',871 Blocks: 'u32'872 }873 },874 /**875 * Lookup236: up_data_structs::CollectionPermissions876 **/877 UpDataStructsCollectionPermissions: {878 access: 'Option<UpDataStructsAccessMode>',879 mintMode: 'Option<bool>',880 nesting: 'Option<UpDataStructsNestingPermissions>'881 },882 /**883 * Lookup238: up_data_structs::NestingPermissions884 **/885 UpDataStructsNestingPermissions: {886 tokenOwner: 'bool',887 collectionAdmin: 'bool',888 restricted: 'Option<UpDataStructsOwnerRestrictedSet>'889 },890 /**891 * Lookup240: up_data_structs::OwnerRestrictedSet892 **/893 UpDataStructsOwnerRestrictedSet: 'BTreeSet<u32>',894 /**895 * Lookup245: up_data_structs::PropertyKeyPermission896 **/897 UpDataStructsPropertyKeyPermission: {898 key: 'Bytes',899 permission: 'UpDataStructsPropertyPermission'900 },901 /**902 * Lookup246: up_data_structs::PropertyPermission903 **/904 UpDataStructsPropertyPermission: {905 mutable: 'bool',906 collectionAdmin: 'bool',907 tokenOwner: 'bool'908 },909 /**910 * Lookup249: up_data_structs::Property911 **/912 UpDataStructsProperty: {913 key: 'Bytes',914 value: 'Bytes'915 },916 /**917 * Lookup252: up_data_structs::CreateItemData918 **/919 UpDataStructsCreateItemData: {920 _enum: {921 NFT: 'UpDataStructsCreateNftData',922 Fungible: 'UpDataStructsCreateFungibleData',923 ReFungible: 'UpDataStructsCreateReFungibleData'924 }925 },926 /**927 * Lookup253: up_data_structs::CreateNftData928 **/929 UpDataStructsCreateNftData: {930 properties: 'Vec<UpDataStructsProperty>'931 },932 /**933 * Lookup254: up_data_structs::CreateFungibleData934 **/935 UpDataStructsCreateFungibleData: {936 value: 'u128'937 },938 /**939 * Lookup255: up_data_structs::CreateReFungibleData940 **/941 UpDataStructsCreateReFungibleData: {942 pieces: 'u128',943 properties: 'Vec<UpDataStructsProperty>'944 },945 /**946 * Lookup258: up_data_structs::CreateItemExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>947 **/948 UpDataStructsCreateItemExData: {949 _enum: {950 NFT: 'Vec<UpDataStructsCreateNftExData>',951 Fungible: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>',952 RefungibleMultipleItems: 'Vec<UpDataStructsCreateRefungibleExSingleOwner>',953 RefungibleMultipleOwners: 'UpDataStructsCreateRefungibleExMultipleOwners'954 }955 },956 /**957 * Lookup260: up_data_structs::CreateNftExData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>958 **/959 UpDataStructsCreateNftExData: {960 properties: 'Vec<UpDataStructsProperty>',961 owner: 'PalletEvmAccountBasicCrossAccountIdRepr'962 },963 /**964 * Lookup267: up_data_structs::CreateRefungibleExSingleOwner<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>965 **/966 UpDataStructsCreateRefungibleExSingleOwner: {967 user: 'PalletEvmAccountBasicCrossAccountIdRepr',968 pieces: 'u128',969 properties: 'Vec<UpDataStructsProperty>'970 },971 /**972 * Lookup269: up_data_structs::CreateRefungibleExMultipleOwners<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>973 **/974 UpDataStructsCreateRefungibleExMultipleOwners: {975 users: 'BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>',976 properties: 'Vec<UpDataStructsProperty>'977 },978 /**979 * Lookup270: pallet_unique_scheduler::pallet::Call<T>980 **/981 PalletUniqueSchedulerCall: {982 _enum: {983 schedule_named: {984 id: '[u8;16]',985 when: 'u32',986 maybePeriodic: 'Option<(u32,u32)>',987 priority: 'u8',988 call: 'FrameSupportScheduleMaybeHashed',989 },990 cancel_named: {991 id: '[u8;16]',992 },993 schedule_named_after: {994 id: '[u8;16]',995 after: 'u32',996 maybePeriodic: 'Option<(u32,u32)>',997 priority: 'u8',998 call: 'FrameSupportScheduleMaybeHashed'999 }1000 }1001 },1002 /**1003 * Lookup272: frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>1004 **/1005 FrameSupportScheduleMaybeHashed: {1006 _enum: {1007 Value: 'Call',1008 Hash: 'H256'1009 }1010 },1011 /**1012 * Lookup273: pallet_configuration::pallet::Call<T>1013 **/1014 PalletConfigurationCall: {1015 _enum: {1016 set_weight_to_fee_coefficient_override: {1017 coeff: 'Option<u32>',1018 },1019 set_min_gas_price_override: {1020 coeff: 'Option<u64>'1021 }1022 }1023 },1024 /**1025 * Lookup274: pallet_template_transaction_payment::Call<T>1026 **/1027 PalletTemplateTransactionPaymentCall: 'Null',1028 /**1029 * Lookup275: pallet_structure::pallet::Call<T>1030 **/1031 PalletStructureCall: 'Null',1032 /**1033 * Lookup276: pallet_rmrk_core::pallet::Call<T>1034 **/1035 PalletRmrkCoreCall: {1036 _enum: {1037 create_collection: {1038 metadata: 'Bytes',1039 max: 'Option<u32>',1040 symbol: 'Bytes',1041 },1042 destroy_collection: {1043 collectionId: 'u32',1044 },1045 change_collection_issuer: {1046 collectionId: 'u32',1047 newIssuer: 'MultiAddress',1048 },1049 lock_collection: {1050 collectionId: 'u32',1051 },1052 mint_nft: {1053 owner: 'Option<AccountId32>',1054 collectionId: 'u32',1055 recipient: 'Option<AccountId32>',1056 royaltyAmount: 'Option<Permill>',1057 metadata: 'Bytes',1058 transferable: 'bool',1059 resources: 'Option<Vec<RmrkTraitsResourceResourceTypes>>',1060 },1061 burn_nft: {1062 collectionId: 'u32',1063 nftId: 'u32',1064 maxBurns: 'u32',1065 },1066 send: {1067 rmrkCollectionId: 'u32',1068 rmrkNftId: 'u32',1069 newOwner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',1070 },1071 accept_nft: {1072 rmrkCollectionId: 'u32',1073 rmrkNftId: 'u32',1074 newOwner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',1075 },1076 reject_nft: {1077 rmrkCollectionId: 'u32',1078 rmrkNftId: 'u32',1079 },1080 accept_resource: {1081 rmrkCollectionId: 'u32',1082 rmrkNftId: 'u32',1083 resourceId: 'u32',1084 },1085 accept_resource_removal: {1086 rmrkCollectionId: 'u32',1087 rmrkNftId: 'u32',1088 resourceId: 'u32',1089 },1090 set_property: {1091 rmrkCollectionId: 'Compact<u32>',1092 maybeNftId: 'Option<u32>',1093 key: 'Bytes',1094 value: 'Bytes',1095 },1096 set_priority: {1097 rmrkCollectionId: 'u32',1098 rmrkNftId: 'u32',1099 priorities: 'Vec<u32>',1100 },1101 add_basic_resource: {1102 rmrkCollectionId: 'u32',1103 nftId: 'u32',1104 resource: 'RmrkTraitsResourceBasicResource',1105 },1106 add_composable_resource: {1107 rmrkCollectionId: 'u32',1108 nftId: 'u32',1109 resource: 'RmrkTraitsResourceComposableResource',1110 },1111 add_slot_resource: {1112 rmrkCollectionId: 'u32',1113 nftId: 'u32',1114 resource: 'RmrkTraitsResourceSlotResource',1115 },1116 remove_resource: {1117 rmrkCollectionId: 'u32',1118 nftId: 'u32',1119 resourceId: 'u32'1120 }1121 }1122 },1123 /**1124 * Lookup282: rmrk_traits::resource::ResourceTypes<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1125 **/1126 RmrkTraitsResourceResourceTypes: {1127 _enum: {1128 Basic: 'RmrkTraitsResourceBasicResource',1129 Composable: 'RmrkTraitsResourceComposableResource',1130 Slot: 'RmrkTraitsResourceSlotResource'1131 }1132 },1133 /**1134 * Lookup284: rmrk_traits::resource::BasicResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1135 **/1136 RmrkTraitsResourceBasicResource: {1137 src: 'Option<Bytes>',1138 metadata: 'Option<Bytes>',1139 license: 'Option<Bytes>',1140 thumb: 'Option<Bytes>'1141 },1142 /**1143 * Lookup286: rmrk_traits::resource::ComposableResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1144 **/1145 RmrkTraitsResourceComposableResource: {1146 parts: 'Vec<u32>',1147 base: 'u32',1148 src: 'Option<Bytes>',1149 metadata: 'Option<Bytes>',1150 license: 'Option<Bytes>',1151 thumb: 'Option<Bytes>'1152 },1153 /**1154 * Lookup287: rmrk_traits::resource::SlotResource<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1155 **/1156 RmrkTraitsResourceSlotResource: {1157 base: 'u32',1158 src: 'Option<Bytes>',1159 metadata: 'Option<Bytes>',1160 slot: 'u32',1161 license: 'Option<Bytes>',1162 thumb: 'Option<Bytes>'1163 },1164 /**1165 * Lookup290: pallet_rmrk_equip::pallet::Call<T>1166 **/1167 PalletRmrkEquipCall: {1168 _enum: {1169 create_base: {1170 baseType: 'Bytes',1171 symbol: 'Bytes',1172 parts: 'Vec<RmrkTraitsPartPartType>',1173 },1174 theme_add: {1175 baseId: 'u32',1176 theme: 'RmrkTraitsTheme',1177 },1178 equippable: {1179 baseId: 'u32',1180 slotId: 'u32',1181 equippables: 'RmrkTraitsPartEquippableList'1182 }1183 }1184 },1185 /**1186 * Lookup293: rmrk_traits::part::PartType<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1187 **/1188 RmrkTraitsPartPartType: {1189 _enum: {1190 FixedPart: 'RmrkTraitsPartFixedPart',1191 SlotPart: 'RmrkTraitsPartSlotPart'1192 }1193 },1194 /**1195 * Lookup295: rmrk_traits::part::FixedPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1196 **/1197 RmrkTraitsPartFixedPart: {1198 id: 'u32',1199 z: 'u32',1200 src: 'Bytes'1201 },1202 /**1203 * Lookup296: rmrk_traits::part::SlotPart<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1204 **/1205 RmrkTraitsPartSlotPart: {1206 id: 'u32',1207 equippable: 'RmrkTraitsPartEquippableList',1208 src: 'Bytes',1209 z: 'u32'1210 },1211 /**1212 * Lookup297: rmrk_traits::part::EquippableList<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1213 **/1214 RmrkTraitsPartEquippableList: {1215 _enum: {1216 All: 'Null',1217 Empty: 'Null',1218 Custom: 'Vec<u32>'1219 }1220 },1221 /**1222 * Lookup299: rmrk_traits::theme::Theme<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>, sp_runtime::bounded::bounded_vec::BoundedVec<rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>, S>>1223 **/1224 RmrkTraitsTheme: {1225 name: 'Bytes',1226 properties: 'Vec<RmrkTraitsThemeThemeProperty>',1227 inherit: 'bool'1228 },1229 /**1230 * Lookup301: rmrk_traits::theme::ThemeProperty<sp_runtime::bounded::bounded_vec::BoundedVec<T, S>>1231 **/1232 RmrkTraitsThemeThemeProperty: {1233 key: 'Bytes',1234 value: 'Bytes'1235 },1236 /**1237 * Lookup303: pallet_evm::pallet::Call<T>1238 **/1239 PalletEvmCall: {1240 _enum: {1241 withdraw: {1242 address: 'H160',1243 value: 'u128',1244 },1245 call: {1246 source: 'H160',1247 target: 'H160',1248 input: 'Bytes',1249 value: 'U256',1250 gasLimit: 'u64',1251 maxFeePerGas: 'U256',1252 maxPriorityFeePerGas: 'Option<U256>',1253 nonce: 'Option<U256>',1254 accessList: 'Vec<(H160,Vec<H256>)>',1255 },1256 create: {1257 source: 'H160',1258 init: 'Bytes',1259 value: 'U256',1260 gasLimit: 'u64',1261 maxFeePerGas: 'U256',1262 maxPriorityFeePerGas: 'Option<U256>',1263 nonce: 'Option<U256>',1264 accessList: 'Vec<(H160,Vec<H256>)>',1265 },1266 create2: {1267 source: 'H160',1268 init: 'Bytes',1269 salt: 'H256',1270 value: 'U256',1271 gasLimit: 'u64',1272 maxFeePerGas: 'U256',1273 maxPriorityFeePerGas: 'Option<U256>',1274 nonce: 'Option<U256>',1275 accessList: 'Vec<(H160,Vec<H256>)>'1276 }1277 }1278 },1279 /**1280 * Lookup307: pallet_ethereum::pallet::Call<T>1281 **/1282 PalletEthereumCall: {1283 _enum: {1284 transact: {1285 transaction: 'EthereumTransactionTransactionV2'1286 }1287 }1288 },1289 /**1290 * Lookup308: ethereum::transaction::TransactionV21291 **/1292 EthereumTransactionTransactionV2: {1293 _enum: {1294 Legacy: 'EthereumTransactionLegacyTransaction',1295 EIP2930: 'EthereumTransactionEip2930Transaction',1296 EIP1559: 'EthereumTransactionEip1559Transaction'1297 }1298 },1299 /**1300 * Lookup309: ethereum::transaction::LegacyTransaction1301 **/1302 EthereumTransactionLegacyTransaction: {1303 nonce: 'U256',1304 gasPrice: 'U256',1305 gasLimit: 'U256',1306 action: 'EthereumTransactionTransactionAction',1307 value: 'U256',1308 input: 'Bytes',1309 signature: 'EthereumTransactionTransactionSignature'1310 },1311 /**1312 * Lookup310: ethereum::transaction::TransactionAction1313 **/1314 EthereumTransactionTransactionAction: {1315 _enum: {1316 Call: 'H160',1317 Create: 'Null'1318 }1319 },1320 /**1321 * Lookup311: ethereum::transaction::TransactionSignature1322 **/1323 EthereumTransactionTransactionSignature: {1324 v: 'u64',1325 r: 'H256',1326 s: 'H256'1327 },1328 /**1329 * Lookup313: ethereum::transaction::EIP2930Transaction1330 **/1331 EthereumTransactionEip2930Transaction: {1332 chainId: 'u64',1333 nonce: 'U256',1334 gasPrice: 'U256',1335 gasLimit: 'U256',1336 action: 'EthereumTransactionTransactionAction',1337 value: 'U256',1338 input: 'Bytes',1339 accessList: 'Vec<EthereumTransactionAccessListItem>',1340 oddYParity: 'bool',1341 r: 'H256',1342 s: 'H256'1343 },1344 /**1345 * Lookup315: ethereum::transaction::AccessListItem1346 **/1347 EthereumTransactionAccessListItem: {1348 address: 'H160',1349 storageKeys: 'Vec<H256>'1350 },1351 /**1352 * Lookup316: ethereum::transaction::EIP1559Transaction1353 **/1354 EthereumTransactionEip1559Transaction: {1355 chainId: 'u64',1356 nonce: 'U256',1357 maxPriorityFeePerGas: 'U256',1358 maxFeePerGas: 'U256',1359 gasLimit: 'U256',1360 action: 'EthereumTransactionTransactionAction',1361 value: 'U256',1362 input: 'Bytes',1363 accessList: 'Vec<EthereumTransactionAccessListItem>',1364 oddYParity: 'bool',1365 r: 'H256',1366 s: 'H256'1367 },1368 /**1369 * Lookup317: pallet_evm_migration::pallet::Call<T>1370 **/1371 PalletEvmMigrationCall: {1372 _enum: {1373 begin: {1374 address: 'H160',1375 },1376 set_data: {1377 address: 'H160',1378 data: 'Vec<(H256,H256)>',1379 },1380 finish: {1381 address: 'H160',1382 code: 'Bytes'1383 }1384 }1385 },1386 /**1387 * Lookup320: pallet_sudo::pallet::Error<T>1388 **/1389 PalletSudoError: {1390 _enum: ['RequireSudo']1391 },1392 /**1393 * Lookup322: orml_vesting::module::Error<T>1394 **/1395 OrmlVestingModuleError: {1396 _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']1397 },1398 /**1399 * Lookup324: cumulus_pallet_xcmp_queue::InboundChannelDetails1400 **/1401 CumulusPalletXcmpQueueInboundChannelDetails: {1402 sender: 'u32',1403 state: 'CumulusPalletXcmpQueueInboundState',1404 messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'1405 },1406 /**1407 * Lookup325: cumulus_pallet_xcmp_queue::InboundState1408 **/1409 CumulusPalletXcmpQueueInboundState: {1410 _enum: ['Ok', 'Suspended']1411 },1412 /**1413 * Lookup328: polkadot_parachain::primitives::XcmpMessageFormat1414 **/1415 PolkadotParachainPrimitivesXcmpMessageFormat: {1416 _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']1417 },1418 /**1419 * Lookup331: cumulus_pallet_xcmp_queue::OutboundChannelDetails1420 **/1421 CumulusPalletXcmpQueueOutboundChannelDetails: {1422 recipient: 'u32',1423 state: 'CumulusPalletXcmpQueueOutboundState',1424 signalsExist: 'bool',1425 firstIndex: 'u16',1426 lastIndex: 'u16'1427 },1428 /**1429 * Lookup332: cumulus_pallet_xcmp_queue::OutboundState1430 **/1431 CumulusPalletXcmpQueueOutboundState: {1432 _enum: ['Ok', 'Suspended']1433 },1434 /**1435 * Lookup334: cumulus_pallet_xcmp_queue::QueueConfigData1436 **/1437 CumulusPalletXcmpQueueQueueConfigData: {1438 suspendThreshold: 'u32',1439 dropThreshold: 'u32',1440 resumeThreshold: 'u32',1441 thresholdWeight: 'u64',1442 weightRestrictDecay: 'u64',1443 xcmpMaxIndividualWeight: 'u64'1444 },1445 /**1446 * Lookup336: cumulus_pallet_xcmp_queue::pallet::Error<T>1447 **/1448 CumulusPalletXcmpQueueError: {1449 _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']1450 },1451 /**1452 * Lookup337: pallet_xcm::pallet::Error<T>1453 **/1454 PalletXcmError: {1455 _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']1456 },1457 /**1458 * Lookup338: cumulus_pallet_xcm::pallet::Error<T>1459 **/1460 CumulusPalletXcmError: 'Null',1461 /**1462 * Lookup339: cumulus_pallet_dmp_queue::ConfigData1463 **/1464 CumulusPalletDmpQueueConfigData: {1465 maxIndividual: 'u64'1466 },1467 /**1468 * Lookup340: cumulus_pallet_dmp_queue::PageIndexData1469 **/1470 CumulusPalletDmpQueuePageIndexData: {1471 beginUsed: 'u32',1472 endUsed: 'u32',1473 overweightCount: 'u64'1474 },1475 /**1476 * Lookup343: cumulus_pallet_dmp_queue::pallet::Error<T>1477 **/1478 CumulusPalletDmpQueueError: {1479 _enum: ['Unknown', 'OverLimit']1480 },1481 /**1482 * Lookup346: pallet_unique::Error<T>1483 **/1484 PalletUniqueError: {1485 _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument', 'RepartitionCalledOnNonRefungibleCollection']1486 },1487 /**1488 * Lookup349: pallet_unique_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<opal_runtime::Call, primitive_types::H256>, BlockNumber, opal_runtime::OriginCaller, sp_core::crypto::AccountId32>1489 **/1490 PalletUniqueSchedulerScheduledV3: {1491 maybeId: 'Option<[u8;16]>',1492 priority: 'u8',1493 call: 'FrameSupportScheduleMaybeHashed',1494 maybePeriodic: 'Option<(u32,u32)>',1495 origin: 'OpalRuntimeOriginCaller'1496 },1497 /**1498 * Lookup350: opal_runtime::OriginCaller1499 **/1500 OpalRuntimeOriginCaller: {1501 _enum: {1502 system: 'FrameSupportDispatchRawOrigin',1503 __Unused1: 'Null',1504 __Unused2: 'Null',1505 __Unused3: 'Null',1506 Void: 'SpCoreVoid',1507 __Unused5: 'Null',1508 __Unused6: 'Null',1509 __Unused7: 'Null',1510 __Unused8: 'Null',1511 __Unused9: 'Null',1512 __Unused10: 'Null',1513 __Unused11: 'Null',1514 __Unused12: 'Null',1515 __Unused13: 'Null',1516 __Unused14: 'Null',1517 __Unused15: 'Null',1518 __Unused16: 'Null',1519 __Unused17: 'Null',1520 __Unused18: 'Null',1521 __Unused19: 'Null',1522 __Unused20: 'Null',1523 __Unused21: 'Null',1524 __Unused22: 'Null',1525 __Unused23: 'Null',1526 __Unused24: 'Null',1527 __Unused25: 'Null',1528 __Unused26: 'Null',1529 __Unused27: 'Null',1530 __Unused28: 'Null',1531 __Unused29: 'Null',1532 __Unused30: 'Null',1533 __Unused31: 'Null',1534 __Unused32: 'Null',1535 __Unused33: 'Null',1536 __Unused34: 'Null',1537 __Unused35: 'Null',1538 __Unused36: 'Null',1539 __Unused37: 'Null',1540 __Unused38: 'Null',1541 __Unused39: 'Null',1542 __Unused40: 'Null',1543 __Unused41: 'Null',1544 __Unused42: 'Null',1545 __Unused43: 'Null',1546 __Unused44: 'Null',1547 __Unused45: 'Null',1548 __Unused46: 'Null',1549 __Unused47: 'Null',1550 __Unused48: 'Null',1551 __Unused49: 'Null',1552 __Unused50: 'Null',1553 PolkadotXcm: 'PalletXcmOrigin',1554 CumulusXcm: 'CumulusPalletXcmOrigin',1555 __Unused53: 'Null',1556 __Unused54: 'Null',1557 __Unused55: 'Null',1558 __Unused56: 'Null',1559 __Unused57: 'Null',1560 __Unused58: 'Null',1561 __Unused59: 'Null',1562 __Unused60: 'Null',1563 __Unused61: 'Null',1564 __Unused62: 'Null',1565 __Unused63: 'Null',1566 __Unused64: 'Null',1567 __Unused65: 'Null',1568 __Unused66: 'Null',1569 __Unused67: 'Null',1570 __Unused68: 'Null',1571 __Unused69: 'Null',1572 __Unused70: 'Null',1573 __Unused71: 'Null',1574 __Unused72: 'Null',1575 __Unused73: 'Null',1576 __Unused74: 'Null',1577 __Unused75: 'Null',1578 __Unused76: 'Null',1579 __Unused77: 'Null',1580 __Unused78: 'Null',1581 __Unused79: 'Null',1582 __Unused80: 'Null',1583 __Unused81: 'Null',1584 __Unused82: 'Null',1585 __Unused83: 'Null',1586 __Unused84: 'Null',1587 __Unused85: 'Null',1588 __Unused86: 'Null',1589 __Unused87: 'Null',1590 __Unused88: 'Null',1591 __Unused89: 'Null',1592 __Unused90: 'Null',1593 __Unused91: 'Null',1594 __Unused92: 'Null',1595 __Unused93: 'Null',1596 __Unused94: 'Null',1597 __Unused95: 'Null',1598 __Unused96: 'Null',1599 __Unused97: 'Null',1600 __Unused98: 'Null',1601 __Unused99: 'Null',1602 __Unused100: 'Null',1603 Ethereum: 'PalletEthereumRawOrigin'1604 }1605 },1606 /**1607 * Lookup351: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>1608 **/1609 FrameSupportDispatchRawOrigin: {1610 _enum: {1611 Root: 'Null',1612 Signed: 'AccountId32',1613 None: 'Null'1614 }1615 },1616 /**1617 * Lookup352: pallet_xcm::pallet::Origin1618 **/1619 PalletXcmOrigin: {1620 _enum: {1621 Xcm: 'XcmV1MultiLocation',1622 Response: 'XcmV1MultiLocation'1623 }1624 },1625 /**1626 * Lookup353: cumulus_pallet_xcm::pallet::Origin1627 **/1628 CumulusPalletXcmOrigin: {1629 _enum: {1630 Relay: 'Null',1631 SiblingParachain: 'u32'1632 }1633 },1634 /**1635 * Lookup354: pallet_ethereum::RawOrigin1636 **/1637 PalletEthereumRawOrigin: {1638 _enum: {1639 EthereumTransaction: 'H160'1640 }1641 },1642 /**1643 * Lookup355: sp_core::Void1644 **/1645 SpCoreVoid: 'Null',1646 /**1647 * Lookup356: pallet_unique_scheduler::pallet::Error<T>1648 **/1649 PalletUniqueSchedulerError: {1650 _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']1651 },1652 /**1653 * Lookup357: up_data_structs::Collection<sp_core::crypto::AccountId32>1654 **/1655 UpDataStructsCollection: {1656 owner: 'AccountId32',1657 mode: 'UpDataStructsCollectionMode',1658 name: 'Vec<u16>',1659 description: 'Vec<u16>',1660 tokenPrefix: 'Bytes',1661 sponsorship: 'UpDataStructsSponsorshipState',1662 limits: 'UpDataStructsCollectionLimits',1663 permissions: 'UpDataStructsCollectionPermissions',1664 externalCollection: 'bool'1665 },1666 /**1667 * Lookup358: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>1668 **/1669 UpDataStructsSponsorshipState: {1670 _enum: {1671 Disabled: 'Null',1672 Unconfirmed: 'AccountId32',1673 Confirmed: 'AccountId32'1674 }1675 },1676 /**1677 * Lookup359: up_data_structs::Properties1678 **/1679 UpDataStructsProperties: {1680 map: 'UpDataStructsPropertiesMapBoundedVec',1681 consumedSpace: 'u32',1682 spaceLimit: 'u32'1683 },1684 /**1685 * Lookup360: up_data_structs::PropertiesMap<frame_support::storage::bounded_vec::BoundedVec<T, S>>1686 **/1687 UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',1688 /**1689 * Lookup366: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>1690 **/1691 UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',1692 /**1693 * Lookup372: up_data_structs::CollectionStats1694 **/1695 UpDataStructsCollectionStats: {1696 created: 'u32',1697 destroyed: 'u32',1698 alive: 'u32'1699 },1700 /**1701 * Lookup373: up_data_structs::TokenChild1702 **/1703 UpDataStructsTokenChild: {1704 token: 'u32',1705 collection: 'u32'1706 },1707 /**1708 * Lookup374: PhantomType::up_data_structs<T>1709 **/1710 PhantomTypeUpDataStructs: '[(UpDataStructsTokenData,UpDataStructsRpcCollection,RmrkTraitsCollectionCollectionInfo,RmrkTraitsNftNftInfo,RmrkTraitsResourceResourceInfo,RmrkTraitsPropertyPropertyInfo,RmrkTraitsBaseBaseInfo,RmrkTraitsPartPartType,RmrkTraitsTheme,RmrkTraitsNftNftChild);0]',1711 /**1712 * Lookup376: up_data_structs::TokenData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>1713 **/1714 UpDataStructsTokenData: {1715 properties: 'Vec<UpDataStructsProperty>',1716 owner: 'Option<PalletEvmAccountBasicCrossAccountIdRepr>',1717 pieces: 'u128'1718 },1719 /**1720 * Lookup378: up_data_structs::RpcCollection<sp_core::crypto::AccountId32>1721 **/1722 UpDataStructsRpcCollection: {1723 owner: 'AccountId32',1724 mode: 'UpDataStructsCollectionMode',1725 name: 'Vec<u16>',1726 description: 'Vec<u16>',1727 tokenPrefix: 'Bytes',1728 sponsorship: 'UpDataStructsSponsorshipState',1729 limits: 'UpDataStructsCollectionLimits',1730 permissions: 'UpDataStructsCollectionPermissions',1731 tokenPropertyPermissions: 'Vec<UpDataStructsPropertyKeyPermission>',1732 properties: 'Vec<UpDataStructsProperty>',1733 readOnly: 'bool'1734 },1735 /**1736 * Lookup379: rmrk_traits::collection::CollectionInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>1737 **/1738 RmrkTraitsCollectionCollectionInfo: {1739 issuer: 'AccountId32',1740 metadata: 'Bytes',1741 max: 'Option<u32>',1742 symbol: 'Bytes',1743 nftsCount: 'u32'1744 },1745 /**1746 * Lookup380: rmrk_traits::nft::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, frame_support::storage::bounded_vec::BoundedVec<T, S>>1747 **/1748 RmrkTraitsNftNftInfo: {1749 owner: 'RmrkTraitsNftAccountIdOrCollectionNftTuple',1750 royalty: 'Option<RmrkTraitsNftRoyaltyInfo>',1751 metadata: 'Bytes',1752 equipped: 'bool',1753 pending: 'bool'1754 },1755 /**1756 * Lookup382: rmrk_traits::nft::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>1757 **/1758 RmrkTraitsNftRoyaltyInfo: {1759 recipient: 'AccountId32',1760 amount: 'Permill'1761 },1762 /**1763 * Lookup383: rmrk_traits::resource::ResourceInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>1764 **/1765 RmrkTraitsResourceResourceInfo: {1766 id: 'u32',1767 resource: 'RmrkTraitsResourceResourceTypes',1768 pending: 'bool',1769 pendingRemoval: 'bool'1770 },1771 /**1772 * Lookup384: rmrk_traits::property::PropertyInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>1773 **/1774 RmrkTraitsPropertyPropertyInfo: {1775 key: 'Bytes',1776 value: 'Bytes'1777 },1778 /**1779 * Lookup385: rmrk_traits::base::BaseInfo<sp_core::crypto::AccountId32, frame_support::storage::bounded_vec::BoundedVec<T, S>>1780 **/1781 RmrkTraitsBaseBaseInfo: {1782 issuer: 'AccountId32',1783 baseType: 'Bytes',1784 symbol: 'Bytes'1785 },1786 /**1787 * Lookup386: rmrk_traits::nft::NftChild1788 **/1789 RmrkTraitsNftNftChild: {1790 collectionId: 'u32',1791 nftId: 'u32'1792 },1793 /**1794 * Lookup388: pallet_common::pallet::Error<T>1795 **/1796 PalletCommonError: {1797 _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']1798 },1799 /**1800 * Lookup390: pallet_fungible::pallet::Error<T>1801 **/1802 PalletFungibleError: {1803 _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']1804 },1805 /**1806 * Lookup391: pallet_refungible::ItemData1807 **/1808 PalletRefungibleItemData: {1809 constData: 'Bytes'1810 },1811 /**1812 * Lookup394: pallet_refungible::pallet::Error<T>1813 **/1814 PalletRefungibleError: {1815 _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RepartitionWhileNotOwningAllPieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']1816 },1817 /**1818 * Lookup395: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>1819 **/1820 PalletNonfungibleItemData: {1821 owner: 'PalletEvmAccountBasicCrossAccountIdRepr'1822 },1823 /**1824 * Lookup397: up_data_structs::PropertyScope1825 **/1826 UpDataStructsPropertyScope: {1827 _enum: ['None', 'Rmrk', 'Eth']1828 },1829 /**1830 * Lookup399: pallet_nonfungible::pallet::Error<T>1831 **/1832 PalletNonfungibleError: {1833 _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount', 'CantBurnNftWithChildren']1834 },1835 /**1836 * Lookup400: pallet_structure::pallet::Error<T>1837 **/1838 PalletStructureError: {1839 _enum: ['OuroborosDetected', 'DepthLimit', 'BreadthLimit', 'TokenNotFound']1840 },1841 /**1842 * Lookup401: pallet_rmrk_core::pallet::Error<T>1843 **/1844 PalletRmrkCoreError: {1845 _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']1846 },1847 /**1848 * Lookup403: pallet_rmrk_equip::pallet::Error<T>1849 **/1850 PalletRmrkEquipError: {1851 _enum: ['PermissionError', 'NoAvailableBaseId', 'NoAvailablePartId', 'BaseDoesntExist', 'NeedsDefaultThemeFirst', 'PartDoesntExist', 'NoEquippableOnFixedPart']1852 },1853 /**1854 * Lookup406: pallet_evm::pallet::Error<T>1855 **/1856 PalletEvmError: {1857 _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']1858 },1859 /**1860 * Lookup409: fp_rpc::TransactionStatus1861 **/1862 FpRpcTransactionStatus: {1863 transactionHash: 'H256',1864 transactionIndex: 'u32',1865 from: 'H160',1866 to: 'Option<H160>',1867 contractAddress: 'Option<H160>',1868 logs: 'Vec<EthereumLog>',1869 logsBloom: 'EthbloomBloom'1870 },1871 /**1872 * Lookup411: ethbloom::Bloom1873 **/1874 EthbloomBloom: '[u8;256]',1875 /**1876 * Lookup413: ethereum::receipt::ReceiptV31877 **/1878 EthereumReceiptReceiptV3: {1879 _enum: {1880 Legacy: 'EthereumReceiptEip658ReceiptData',1881 EIP2930: 'EthereumReceiptEip658ReceiptData',1882 EIP1559: 'EthereumReceiptEip658ReceiptData'1883 }1884 },1885 /**1886 * Lookup414: ethereum::receipt::EIP658ReceiptData1887 **/1888 EthereumReceiptEip658ReceiptData: {1889 statusCode: 'u8',1890 usedGas: 'U256',1891 logsBloom: 'EthbloomBloom',1892 logs: 'Vec<EthereumLog>'1893 },1894 /**1895 * Lookup415: ethereum::block::Block<ethereum::transaction::TransactionV2>1896 **/1897 EthereumBlock: {1898 header: 'EthereumHeader',1899 transactions: 'Vec<EthereumTransactionTransactionV2>',1900 ommers: 'Vec<EthereumHeader>'1901 },1902 /**1903 * Lookup416: ethereum::header::Header1904 **/1905 EthereumHeader: {1906 parentHash: 'H256',1907 ommersHash: 'H256',1908 beneficiary: 'H160',1909 stateRoot: 'H256',1910 transactionsRoot: 'H256',1911 receiptsRoot: 'H256',1912 logsBloom: 'EthbloomBloom',1913 difficulty: 'U256',1914 number: 'U256',1915 gasLimit: 'U256',1916 gasUsed: 'U256',1917 timestamp: 'u64',1918 extraData: 'Bytes',1919 mixHash: 'H256',1920 nonce: 'EthereumTypesHashH64'1921 },1922 /**1923 * Lookup417: ethereum_types::hash::H641924 **/1925 EthereumTypesHashH64: '[u8;8]',1926 /**1927 * Lookup422: pallet_ethereum::pallet::Error<T>1928 **/1929 PalletEthereumError: {1930 _enum: ['InvalidSignature', 'PreLogExists']1931 },1932 /**1933 * Lookup423: pallet_evm_coder_substrate::pallet::Error<T>1934 **/1935 PalletEvmCoderSubstrateError: {1936 _enum: ['OutOfGas', 'OutOfFund']1937 },1938 /**1939 * Lookup424: pallet_evm_contract_helpers::SponsoringModeT1940 **/1941 PalletEvmContractHelpersSponsoringModeT: {1942 _enum: ['Disabled', 'Allowlisted', 'Generous']1943 },1944 /**1945 * Lookup426: pallet_evm_contract_helpers::pallet::Error<T>1946 **/1947 PalletEvmContractHelpersError: {1948 _enum: ['NoPermission']1949 },1950 /**1951 * Lookup427: pallet_evm_migration::pallet::Error<T>1952 **/1953 PalletEvmMigrationError: {1954 _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']1955 },1956 /**1957 * Lookup429: sp_runtime::MultiSignature1958 **/1959 SpRuntimeMultiSignature: {1960 _enum: {1961 Ed25519: 'SpCoreEd25519Signature',1962 Sr25519: 'SpCoreSr25519Signature',1963 Ecdsa: 'SpCoreEcdsaSignature'1964 }1965 },1966 /**1967 * Lookup430: sp_core::ed25519::Signature1968 **/1969 SpCoreEd25519Signature: '[u8;64]',1970 /**1971 * Lookup434: sp_core::sr25519::Signature1972 **/1973 SpCoreSr25519Signature: '[u8;64]',1974 /**1975 * Lookup435: sp_core::ecdsa::Signature1976 **/1977 SpCoreEcdsaSignature: '[u8;65]',1978 /**1979 * Lookup438: frame_system::extensions::check_spec_version::CheckSpecVersion<T>1980 **/1981 FrameSystemExtensionsCheckSpecVersion: 'Null',1982 /**1983 * Lookup439: frame_system::extensions::check_genesis::CheckGenesis<T>1984 **/1985 FrameSystemExtensionsCheckGenesis: 'Null',1986 /**1987 * Lookup442: frame_system::extensions::check_nonce::CheckNonce<T>1988 **/1989 FrameSystemExtensionsCheckNonce: 'Compact<u32>',1990 /**1991 * Lookup443: frame_system::extensions::check_weight::CheckWeight<T>1992 **/1993 FrameSystemExtensionsCheckWeight: 'Null',1994 /**1995 * Lookup444: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>1996 **/1997 PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',1998 /**1999 * Lookup445: opal_runtime::Runtime2000 **/2001 OpalRuntimeRuntime: 'Null',2002 /**2003 * Lookup444: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>2004 **/2005 PalletEthereumFakeTransactionFinalizer: 'Null'2006};tests/src/interfaces/types-lookup.tsdiffbeforeafterboth--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -1393,28 +1393,7 @@
readonly type: 'StartInflation';
}
- /** @name PalletAppPromotionCall (148) */
- export interface PalletAppPromotionCall extends Enum {
- readonly isSetAdminAddress: boolean;
- readonly asSetAdminAddress: {
- readonly admin: AccountId32;
- } & Struct;
- readonly isStartAppPromotion: boolean;
- readonly asStartAppPromotion: {
- readonly promotionStartRelayBlock: u32;
- } & Struct;
- readonly isStake: boolean;
- readonly asStake: {
- readonly amount: u128;
- } & Struct;
- readonly isUnstake: boolean;
- readonly asUnstake: {
- readonly amount: u128;
- } & Struct;
- readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake';
- }
-
- /** @name PalletUniqueCall (149) */
+ /** @name PalletUniqueCall (148) */
export interface PalletUniqueCall extends Enum {
readonly isCreateCollection: boolean;
readonly asCreateCollection: {
@@ -1629,164 +1608,28 @@
readonly nftId: u32;
readonly resourceId: u32;
} & Struct;
- readonly isResourceRemovalAccepted: boolean;
- readonly asResourceRemovalAccepted: {
- readonly nftId: u32;
- readonly resourceId: u32;
- } & Struct;
- readonly isPrioritySet: boolean;
- readonly asPrioritySet: {
+ readonly isCreateMultipleItemsEx: boolean;
+ readonly asCreateMultipleItemsEx: {
readonly collectionId: u32;
- readonly nftId: u32;
- } & Struct;
- readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'NftSent' | 'NftAccepted' | 'NftRejected' | 'PropertySet' | 'ResourceAdded' | 'ResourceRemoval' | 'ResourceAccepted' | 'ResourceRemovalAccepted' | 'PrioritySet';
- }
-
-<<<<<<< HEAD
- /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (97) */
- interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {
- readonly isAccountId: boolean;
- readonly asAccountId: AccountId32;
- readonly isCollectionAndNftTuple: boolean;
- readonly asCollectionAndNftTuple: ITuple<[u32, u32]>;
- readonly type: 'AccountId' | 'CollectionAndNftTuple';
- }
-
- /** @name PalletRmrkEquipEvent (102) */
- interface PalletRmrkEquipEvent extends Enum {
- readonly isBaseCreated: boolean;
- readonly asBaseCreated: {
- readonly issuer: AccountId32;
- readonly baseId: u32;
+ readonly data: UpDataStructsCreateItemExData;
} & Struct;
- readonly isEquippablesUpdated: boolean;
- readonly asEquippablesUpdated: {
- readonly baseId: u32;
- readonly slotId: u32;
- } & Struct;
- readonly type: 'BaseCreated' | 'EquippablesUpdated';
- }
-
- /** @name PalletEvmEvent (103) */
- interface PalletEvmEvent extends Enum {
- readonly isLog: boolean;
- readonly asLog: EthereumLog;
- readonly isCreated: boolean;
- readonly asCreated: H160;
- readonly isCreatedFailed: boolean;
- readonly asCreatedFailed: H160;
- readonly isExecuted: boolean;
- readonly asExecuted: H160;
- readonly isExecutedFailed: boolean;
- readonly asExecutedFailed: H160;
- readonly isBalanceDeposit: boolean;
- readonly asBalanceDeposit: ITuple<[AccountId32, H160, U256]>;
- readonly isBalanceWithdraw: boolean;
- readonly asBalanceWithdraw: ITuple<[AccountId32, H160, U256]>;
- readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw';
- }
-
- /** @name EthereumLog (104) */
- interface EthereumLog extends Struct {
- readonly address: H160;
- readonly topics: Vec<H256>;
- readonly data: Bytes;
- }
-
- /** @name PalletEthereumEvent (108) */
- interface PalletEthereumEvent extends Enum {
- readonly isExecuted: boolean;
- readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>;
- readonly type: 'Executed';
- }
-
- /** @name EvmCoreErrorExitReason (109) */
- interface EvmCoreErrorExitReason extends Enum {
- readonly isSucceed: boolean;
- readonly asSucceed: EvmCoreErrorExitSucceed;
- readonly isError: boolean;
- readonly asError: EvmCoreErrorExitError;
- readonly isRevert: boolean;
- readonly asRevert: EvmCoreErrorExitRevert;
- readonly isFatal: boolean;
- readonly asFatal: EvmCoreErrorExitFatal;
- readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal';
- }
-
- /** @name EvmCoreErrorExitSucceed (110) */
- interface EvmCoreErrorExitSucceed extends Enum {
- readonly isStopped: boolean;
- readonly isReturned: boolean;
- readonly isSuicided: boolean;
- readonly type: 'Stopped' | 'Returned' | 'Suicided';
- }
-
- /** @name EvmCoreErrorExitError (111) */
- interface EvmCoreErrorExitError extends Enum {
- readonly isStackUnderflow: boolean;
- readonly isStackOverflow: boolean;
- readonly isInvalidJump: boolean;
- readonly isInvalidRange: boolean;
- readonly isDesignatedInvalid: boolean;
- readonly isCallTooDeep: boolean;
- readonly isCreateCollision: boolean;
- readonly isCreateContractLimit: boolean;
- readonly isOutOfOffset: boolean;
- readonly isOutOfGas: boolean;
- readonly isOutOfFund: boolean;
- readonly isPcUnderflow: boolean;
- readonly isCreateEmpty: boolean;
- readonly isOther: boolean;
- readonly asOther: Text;
- readonly isInvalidCode: boolean;
- readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode';
- }
-
- /** @name EvmCoreErrorExitRevert (114) */
- interface EvmCoreErrorExitRevert extends Enum {
- readonly isReverted: boolean;
- readonly type: 'Reverted';
- }
-
- /** @name EvmCoreErrorExitFatal (115) */
- interface EvmCoreErrorExitFatal extends Enum {
- readonly isNotSupported: boolean;
- readonly isUnhandledInterrupt: boolean;
- readonly isCallErrorAsFatal: boolean;
- readonly asCallErrorAsFatal: EvmCoreErrorExitError;
- readonly isOther: boolean;
- readonly asOther: Text;
- readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other';
- }
-
- /** @name FrameSystemPhase (116) */
- interface FrameSystemPhase extends Enum {
- readonly isApplyExtrinsic: boolean;
- readonly asApplyExtrinsic: u32;
- readonly isFinalization: boolean;
- readonly isInitialization: boolean;
- readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization';
- }
-
- /** @name FrameSystemLastRuntimeUpgradeInfo (118) */
- interface FrameSystemLastRuntimeUpgradeInfo extends Struct {
- readonly specVersion: Compact<u32>;
- readonly specName: Text;
- }
-
- /** @name FrameSystemCall (119) */
- interface FrameSystemCall extends Enum {
- readonly isFillBlock: boolean;
- readonly asFillBlock: {
- readonly ratio: Perbill;
+ readonly isSetTransfersEnabledFlag: boolean;
+ readonly asSetTransfersEnabledFlag: {
+ readonly collectionId: u32;
+ readonly value: bool;
} & Struct;
- readonly isRemark: boolean;
- readonly asRemark: {
- readonly remark: Bytes;
+ readonly isBurnItem: boolean;
+ readonly asBurnItem: {
+ readonly collectionId: u32;
+ readonly itemId: u32;
+ readonly value: u128;
} & Struct;
- readonly isSetHeapPages: boolean;
- readonly asSetHeapPages: {
- readonly pages: u64;
+ readonly isBurnFrom: boolean;
+ readonly asBurnFrom: {
+ readonly collectionId: u32;
+ readonly from: PalletEvmAccountBasicCrossAccountIdRepr;
+ readonly itemId: u32;
+ readonly value: u128;
} & Struct;
readonly isSetCode: boolean;
readonly asSetCode: {
@@ -1813,21 +1656,7 @@
readonly asRemarkWithEvent: {
readonly remark: Bytes;
} & Struct;
- readonly type: 'FillBlock' | 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent';
- }
-
- /** @name FrameSystemLimitsBlockWeights (124) */
- interface FrameSystemLimitsBlockWeights extends Struct {
- readonly baseBlock: u64;
- readonly maxBlock: u64;
- readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass;
- }
-
- /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (125) */
- interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct {
- readonly normal: FrameSystemLimitsWeightsPerClass;
- readonly operational: FrameSystemLimitsWeightsPerClass;
- readonly mandatory: FrameSystemLimitsWeightsPerClass;
+ 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 (155) */
@@ -1839,7 +1668,7 @@
readonly type: 'Nft' | 'Fungible' | 'ReFungible';
}
- /** @name UpDataStructsCreateCollectionData (156) */
+ /** @name UpDataStructsCreateCollectionData (155) */
export interface UpDataStructsCreateCollectionData extends Struct {
readonly mode: UpDataStructsCollectionMode;
readonly access: Option<UpDataStructsAccessMode>;
@@ -1853,14 +1682,14 @@
readonly properties: Vec<UpDataStructsProperty>;
}
- /** @name UpDataStructsAccessMode (158) */
+ /** @name UpDataStructsAccessMode (157) */
export interface UpDataStructsAccessMode extends Enum {
readonly isNormal: boolean;
readonly isAllowList: boolean;
readonly type: 'Normal' | 'AllowList';
}
- /** @name UpDataStructsCollectionLimits (161) */
+ /** @name UpDataStructsCollectionLimits (160) */
export interface UpDataStructsCollectionLimits extends Struct {
readonly accountTokenOwnershipLimit: Option<u32>;
readonly sponsoredDataSize: Option<u32>;
@@ -1873,7 +1702,7 @@
readonly transfersEnabled: Option<bool>;
}
- /** @name UpDataStructsSponsoringRateLimit (163) */
+ /** @name UpDataStructsSponsoringRateLimit (162) */
export interface UpDataStructsSponsoringRateLimit extends Enum {
readonly isSponsoringDisabled: boolean;
readonly isBlocks: boolean;
@@ -1881,43 +1710,43 @@
readonly type: 'SponsoringDisabled' | 'Blocks';
}
- /** @name UpDataStructsCollectionPermissions (166) */
+ /** @name UpDataStructsCollectionPermissions (165) */
export interface UpDataStructsCollectionPermissions extends Struct {
readonly access: Option<UpDataStructsAccessMode>;
readonly mintMode: Option<bool>;
readonly nesting: Option<UpDataStructsNestingPermissions>;
}
- /** @name UpDataStructsNestingPermissions (168) */
+ /** @name UpDataStructsNestingPermissions (167) */
export interface UpDataStructsNestingPermissions extends Struct {
readonly tokenOwner: bool;
readonly collectionAdmin: bool;
readonly restricted: Option<UpDataStructsOwnerRestrictedSet>;
}
- /** @name UpDataStructsOwnerRestrictedSet (170) */
+ /** @name UpDataStructsOwnerRestrictedSet (169) */
export interface UpDataStructsOwnerRestrictedSet extends BTreeSet<u32> {}
- /** @name UpDataStructsPropertyKeyPermission (176) */
+ /** @name UpDataStructsPropertyKeyPermission (175) */
export interface UpDataStructsPropertyKeyPermission extends Struct {
readonly key: Bytes;
readonly permission: UpDataStructsPropertyPermission;
}
- /** @name UpDataStructsPropertyPermission (178) */
+ /** @name UpDataStructsPropertyPermission (177) */
export interface UpDataStructsPropertyPermission extends Struct {
readonly mutable: bool;
readonly collectionAdmin: bool;
readonly tokenOwner: bool;
}
- /** @name UpDataStructsProperty (181) */
+ /** @name UpDataStructsProperty (180) */
export interface UpDataStructsProperty extends Struct {
readonly key: Bytes;
readonly value: Bytes;
}
- /** @name PalletEvmAccountBasicCrossAccountIdRepr (184) */
+ /** @name PalletEvmAccountBasicCrossAccountIdRepr (183) */
export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum {
readonly isSubstrate: boolean;
readonly asSubstrate: AccountId32;
@@ -1926,7 +1755,7 @@
readonly type: 'Substrate' | 'Ethereum';
}
- /** @name UpDataStructsCreateItemData (186) */
+ /** @name UpDataStructsCreateItemData (185) */
export interface UpDataStructsCreateItemData extends Enum {
readonly isNft: boolean;
readonly asNft: UpDataStructsCreateNftData;
@@ -1937,17 +1766,17 @@
readonly type: 'Nft' | 'Fungible' | 'ReFungible';
}
- /** @name UpDataStructsCreateNftData (187) */
+ /** @name UpDataStructsCreateNftData (186) */
export interface UpDataStructsCreateNftData extends Struct {
readonly properties: Vec<UpDataStructsProperty>;
}
- /** @name UpDataStructsCreateFungibleData (188) */
+ /** @name UpDataStructsCreateFungibleData (187) */
export interface UpDataStructsCreateFungibleData extends Struct {
readonly value: u128;
}
- /** @name UpDataStructsCreateReFungibleData (189) */
+ /** @name UpDataStructsCreateReFungibleData (188) */
export interface UpDataStructsCreateReFungibleData extends Struct {
readonly pieces: u128;
readonly properties: Vec<UpDataStructsProperty>;
@@ -2028,7 +1857,7 @@
readonly properties: Vec<UpDataStructsProperty>;
}
- /** @name PalletUniqueSchedulerCall (205) */
+ /** @name PalletUniqueSchedulerCall (204) */
export interface PalletUniqueSchedulerCall extends Enum {
readonly isScheduleNamed: boolean;
readonly asScheduleNamed: {
@@ -2053,7 +1882,7 @@
readonly type: 'ScheduleNamed' | 'CancelNamed' | 'ScheduleNamedAfter';
}
- /** @name FrameSupportScheduleMaybeHashed (207) */
+ /** @name FrameSupportScheduleMaybeHashed (206) */
export interface FrameSupportScheduleMaybeHashed extends Enum {
readonly isValue: boolean;
readonly asValue: Call;
@@ -2062,13 +1891,13 @@
readonly type: 'Value' | 'Hash';
}
- /** @name PalletTemplateTransactionPaymentCall (208) */
+ /** @name PalletTemplateTransactionPaymentCall (207) */
export type PalletTemplateTransactionPaymentCall = Null;
- /** @name PalletStructureCall (209) */
+ /** @name PalletStructureCall (208) */
export type PalletStructureCall = Null;
- /** @name PalletRmrkCoreCall (210) */
+ /** @name PalletRmrkCoreCall (209) */
export interface PalletRmrkCoreCall extends Enum {
readonly isCreateCollection: boolean;
readonly asCreateCollection: {
@@ -2174,7 +2003,7 @@
readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'Send' | 'AcceptNft' | 'RejectNft' | 'AcceptResource' | 'AcceptResourceRemoval' | 'SetProperty' | 'SetPriority' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource' | 'RemoveResource';
}
- /** @name RmrkTraitsResourceResourceTypes (216) */
+ /** @name RmrkTraitsResourceResourceTypes (215) */
export interface RmrkTraitsResourceResourceTypes extends Enum {
readonly isBasic: boolean;
readonly asBasic: RmrkTraitsResourceBasicResource;
@@ -2185,7 +2014,7 @@
readonly type: 'Basic' | 'Composable' | 'Slot';
}
- /** @name RmrkTraitsResourceBasicResource (218) */
+ /** @name RmrkTraitsResourceBasicResource (217) */
export interface RmrkTraitsResourceBasicResource extends Struct {
readonly src: Option<Bytes>;
readonly metadata: Option<Bytes>;
@@ -2193,7 +2022,7 @@
readonly thumb: Option<Bytes>;
}
- /** @name RmrkTraitsResourceComposableResource (220) */
+ /** @name RmrkTraitsResourceComposableResource (219) */
export interface RmrkTraitsResourceComposableResource extends Struct {
readonly parts: Vec<u32>;
readonly base: u32;
@@ -2203,7 +2032,7 @@
readonly thumb: Option<Bytes>;
}
- /** @name RmrkTraitsResourceSlotResource (221) */
+ /** @name RmrkTraitsResourceSlotResource (220) */
export interface RmrkTraitsResourceSlotResource extends Struct {
readonly base: u32;
readonly src: Option<Bytes>;
@@ -2213,7 +2042,7 @@
readonly thumb: Option<Bytes>;
}
- /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (223) */
+ /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (222) */
export interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {
readonly isAccountId: boolean;
readonly asAccountId: AccountId32;
@@ -2222,7 +2051,7 @@
readonly type: 'AccountId' | 'CollectionAndNftTuple';
}
- /** @name PalletRmrkEquipCall (227) */
+ /** @name PalletRmrkEquipCall (226) */
export interface PalletRmrkEquipCall extends Enum {
readonly isCreateBase: boolean;
readonly asCreateBase: {
@@ -2244,7 +2073,7 @@
readonly type: 'CreateBase' | 'ThemeAdd' | 'Equippable';
}
- /** @name RmrkTraitsPartPartType (230) */
+ /** @name RmrkTraitsPartPartType (229) */
export interface RmrkTraitsPartPartType extends Enum {
readonly isFixedPart: boolean;
readonly asFixedPart: RmrkTraitsPartFixedPart;
@@ -2253,14 +2082,14 @@
readonly type: 'FixedPart' | 'SlotPart';
}
- /** @name RmrkTraitsPartFixedPart (232) */
+ /** @name RmrkTraitsPartFixedPart (231) */
export interface RmrkTraitsPartFixedPart extends Struct {
readonly id: u32;
readonly z: u32;
readonly src: Bytes;
}
- /** @name RmrkTraitsPartSlotPart (233) */
+ /** @name RmrkTraitsPartSlotPart (232) */
export interface RmrkTraitsPartSlotPart extends Struct {
readonly id: u32;
readonly equippable: RmrkTraitsPartEquippableList;
@@ -2268,25 +2097,46 @@
readonly z: u32;
}
- /** @name RmrkTraitsPartEquippableList (234) */
+ /** @name RmrkTraitsPartEquippableList (233) */
export interface RmrkTraitsPartEquippableList extends Enum {
readonly isAll: boolean;
readonly type: 'Fee' | 'Misc' | 'All';
}
- /** @name RmrkTraitsTheme (236) */
+ /** @name RmrkTraitsTheme (235) */
export interface RmrkTraitsTheme extends Struct {
readonly name: Bytes;
readonly properties: Vec<RmrkTraitsThemeThemeProperty>;
readonly inherit: bool;
}
- /** @name RmrkTraitsThemeThemeProperty (238) */
+ /** @name RmrkTraitsThemeThemeProperty (237) */
export interface RmrkTraitsThemeThemeProperty extends Struct {
readonly key: Bytes;
readonly value: Bytes;
}
+ /** @name PalletAppPromotionCall (239) */
+ export interface PalletAppPromotionCall extends Enum {
+ readonly isSetAdminAddress: boolean;
+ readonly asSetAdminAddress: {
+ readonly admin: AccountId32;
+ } & Struct;
+ readonly isStartAppPromotion: boolean;
+ readonly asStartAppPromotion: {
+ readonly promotionStartRelayBlock: u32;
+ } & Struct;
+ readonly isStake: boolean;
+ readonly asStake: {
+ readonly amount: u128;
+ } & Struct;
+ readonly isUnstake: boolean;
+ readonly asUnstake: {
+ readonly amount: u128;
+ } & Struct;
+ readonly type: 'SetAdminAddress' | 'StartAppPromotion' | 'Stake' | 'Unstake';
+ }
+
/** @name PalletEvmCall (240) */
export interface PalletEvmCall extends Enum {
readonly isWithdraw: boolean;
@@ -3213,7 +3063,7 @@
readonly type: 'Unknown' | 'OverLimit';
}
- /** @name PalletUniqueError (346) */
+ /** @name PalletUniqueError (345) */
export interface PalletUniqueError extends Enum {
readonly isCollectionDecimalPointLimitExceeded: boolean;
readonly isConfirmUnsetSponsorFail: boolean;
@@ -3222,7 +3072,7 @@
readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument' | 'RepartitionCalledOnNonRefungibleCollection';
}
- /** @name PalletUniqueSchedulerScheduledV3 (349) */
+ /** @name PalletUniqueSchedulerScheduledV3 (348) */
export interface PalletUniqueSchedulerScheduledV3 extends Struct {
readonly maybeId: Option<U8aFixed>;
readonly priority: u8;
@@ -3231,7 +3081,7 @@
readonly origin: OpalRuntimeOriginCaller;
}
- /** @name OpalRuntimeOriginCaller (350) */
+ /** @name OpalRuntimeOriginCaller (349) */
export interface OpalRuntimeOriginCaller extends Enum {
readonly isVoid: boolean;
readonly isSystem: boolean;
@@ -3246,7 +3096,7 @@
readonly type: 'System' | 'Void' | 'PolkadotXcm' | 'CumulusXcm' | 'Ethereum';
}
- /** @name FrameSupportDispatchRawOrigin (351) */
+ /** @name FrameSupportDispatchRawOrigin (350) */
export interface FrameSupportDispatchRawOrigin extends Enum {
readonly isRoot: boolean;
readonly isSigned: boolean;
@@ -3255,7 +3105,7 @@
readonly type: 'Root' | 'Signed' | 'None';
}
- /** @name PalletXcmOrigin (352) */
+ /** @name PalletXcmOrigin (351) */
export interface PalletXcmOrigin extends Enum {
readonly isXcm: boolean;
readonly asXcm: XcmV1MultiLocation;
@@ -3264,7 +3114,7 @@
readonly type: 'Xcm' | 'Response';
}
- /** @name CumulusPalletXcmOrigin (353) */
+ /** @name CumulusPalletXcmOrigin (352) */
export interface CumulusPalletXcmOrigin extends Enum {
readonly isRelay: boolean;
readonly isSiblingParachain: boolean;
@@ -3272,17 +3122,17 @@
readonly type: 'Relay' | 'SiblingParachain';
}
- /** @name PalletEthereumRawOrigin (354) */
+ /** @name PalletEthereumRawOrigin (353) */
export interface PalletEthereumRawOrigin extends Enum {
readonly isEthereumTransaction: boolean;
readonly asEthereumTransaction: H160;
readonly type: 'EthereumTransaction';
}
- /** @name SpCoreVoid (355) */
+ /** @name SpCoreVoid (354) */
export type SpCoreVoid = Null;
- /** @name PalletUniqueSchedulerError (356) */
+ /** @name PalletUniqueSchedulerError (355) */
export interface PalletUniqueSchedulerError extends Enum {
readonly isFailedToSchedule: boolean;
readonly isNotFound: boolean;
@@ -3291,7 +3141,7 @@
readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange';
}
- /** @name UpDataStructsCollection (357) */
+ /** @name UpDataStructsCollection (356) */
export interface UpDataStructsCollection extends Struct {
readonly owner: AccountId32;
readonly mode: UpDataStructsCollectionMode;
@@ -3304,7 +3154,7 @@
readonly externalCollection: bool;
}
- /** @name UpDataStructsSponsorshipState (358) */
+ /** @name UpDataStructsSponsorshipState (357) */
export interface UpDataStructsSponsorshipState extends Enum {
readonly isDisabled: boolean;
readonly isUnconfirmed: boolean;
@@ -3314,43 +3164,43 @@
readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';
}
- /** @name UpDataStructsProperties (359) */
+ /** @name UpDataStructsProperties (358) */
export interface UpDataStructsProperties extends Struct {
readonly map: UpDataStructsPropertiesMapBoundedVec;
readonly consumedSpace: u32;
readonly spaceLimit: u32;
}
- /** @name UpDataStructsPropertiesMapBoundedVec (360) */
+ /** @name UpDataStructsPropertiesMapBoundedVec (359) */
export interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap<Bytes, Bytes> {}
- /** @name UpDataStructsPropertiesMapPropertyPermission (365) */
+ /** @name UpDataStructsPropertiesMapPropertyPermission (364) */
export interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap<Bytes, UpDataStructsPropertyPermission> {}
- /** @name UpDataStructsCollectionStats (372) */
+ /** @name UpDataStructsCollectionStats (371) */
export interface UpDataStructsCollectionStats extends Struct {
readonly created: u32;
readonly destroyed: u32;
readonly alive: u32;
}
- /** @name UpDataStructsTokenChild (373) */
+ /** @name UpDataStructsTokenChild (372) */
export interface UpDataStructsTokenChild extends Struct {
readonly token: u32;
readonly collection: u32;
}
- /** @name PhantomTypeUpDataStructs (374) */
+ /** @name PhantomTypeUpDataStructs (373) */
export interface PhantomTypeUpDataStructs extends Vec<ITuple<[UpDataStructsTokenData, UpDataStructsRpcCollection, RmrkTraitsCollectionCollectionInfo, RmrkTraitsNftNftInfo, RmrkTraitsResourceResourceInfo, RmrkTraitsPropertyPropertyInfo, RmrkTraitsBaseBaseInfo, RmrkTraitsPartPartType, RmrkTraitsTheme, RmrkTraitsNftNftChild]>> {}
- /** @name UpDataStructsTokenData (376) */
+ /** @name UpDataStructsTokenData (375) */
export interface UpDataStructsTokenData extends Struct {
readonly properties: Vec<UpDataStructsProperty>;
readonly owner: Option<PalletEvmAccountBasicCrossAccountIdRepr>;
readonly pieces: u128;
}
- /** @name UpDataStructsRpcCollection (378) */
+ /** @name UpDataStructsRpcCollection (377) */
export interface UpDataStructsRpcCollection extends Struct {
readonly owner: AccountId32;
readonly mode: UpDataStructsCollectionMode;
@@ -3365,7 +3215,7 @@
readonly readOnly: bool;
}
- /** @name RmrkTraitsCollectionCollectionInfo (379) */
+ /** @name RmrkTraitsCollectionCollectionInfo (378) */
export interface RmrkTraitsCollectionCollectionInfo extends Struct {
readonly issuer: AccountId32;
readonly metadata: Bytes;
@@ -3374,7 +3224,7 @@
readonly nftsCount: u32;
}
- /** @name RmrkTraitsNftNftInfo (380) */
+ /** @name RmrkTraitsNftNftInfo (379) */
export interface RmrkTraitsNftNftInfo extends Struct {
readonly owner: RmrkTraitsNftAccountIdOrCollectionNftTuple;
readonly royalty: Option<RmrkTraitsNftRoyaltyInfo>;
@@ -3383,13 +3233,13 @@
readonly pending: bool;
}
- /** @name RmrkTraitsNftRoyaltyInfo (382) */
+ /** @name RmrkTraitsNftRoyaltyInfo (381) */
export interface RmrkTraitsNftRoyaltyInfo extends Struct {
readonly recipient: AccountId32;
readonly amount: Permill;
}
- /** @name RmrkTraitsResourceResourceInfo (383) */
+ /** @name RmrkTraitsResourceResourceInfo (382) */
export interface RmrkTraitsResourceResourceInfo extends Struct {
readonly id: u32;
readonly resource: RmrkTraitsResourceResourceTypes;
@@ -3397,26 +3247,26 @@
readonly pendingRemoval: bool;
}
- /** @name RmrkTraitsPropertyPropertyInfo (384) */
+ /** @name RmrkTraitsPropertyPropertyInfo (383) */
export interface RmrkTraitsPropertyPropertyInfo extends Struct {
readonly key: Bytes;
readonly value: Bytes;
}
- /** @name RmrkTraitsBaseBaseInfo (385) */
+ /** @name RmrkTraitsBaseBaseInfo (384) */
export interface RmrkTraitsBaseBaseInfo extends Struct {
readonly issuer: AccountId32;
readonly baseType: Bytes;
readonly symbol: Bytes;
}
- /** @name RmrkTraitsNftNftChild (386) */
+ /** @name RmrkTraitsNftNftChild (385) */
export interface RmrkTraitsNftNftChild extends Struct {
readonly collectionId: u32;
readonly nftId: u32;
}
- /** @name PalletCommonError (388) */
+ /** @name PalletCommonError (387) */
export interface PalletCommonError extends Enum {
readonly isCollectionNotFound: boolean;
readonly isMustBeTokenOwner: boolean;
@@ -3455,7 +3305,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 (390) */
+ /** @name PalletFungibleError (389) */
export interface PalletFungibleError extends Enum {
readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean;
readonly isFungibleItemsHaveNoId: boolean;
@@ -3465,13 +3315,13 @@
readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
}
- /** @name PalletRefungibleItemData (391) */
+ /** @name PalletRefungibleItemData (390) */
export interface PalletRefungibleItemData extends Struct {
readonly constData: Bytes;
}
- /** @name PalletRefungibleError (397) */
- interface PalletRefungibleError extends Enum {
+ /** @name PalletRefungibleError (394) */
+ export interface PalletRefungibleError extends Enum {
readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean;
readonly isWrongRefungiblePieces: boolean;
readonly isRepartitionWhileNotOwningAllPieces: boolean;
@@ -3480,29 +3330,29 @@
readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RepartitionWhileNotOwningAllPieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
}
- /** @name PalletNonfungibleItemData (398) */
- interface PalletNonfungibleItemData extends Struct {
+ /** @name PalletNonfungibleItemData (395) */
+ export interface PalletNonfungibleItemData extends Struct {
readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
}
- /** @name UpDataStructsPropertyScope (400) */
- interface UpDataStructsPropertyScope extends Enum {
+ /** @name UpDataStructsPropertyScope (397) */
+ export interface UpDataStructsPropertyScope extends Enum {
readonly isNone: boolean;
readonly isRmrk: boolean;
readonly isEth: boolean;
readonly type: 'None' | 'Rmrk' | 'Eth';
}
- /** @name PalletNonfungibleError (402) */
- interface PalletNonfungibleError extends Enum {
+ /** @name PalletNonfungibleError (399) */
+ export interface PalletNonfungibleError extends Enum {
readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean;
readonly isNonfungibleItemsHaveNoAmount: boolean;
readonly isCantBurnNftWithChildren: boolean;
readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount' | 'CantBurnNftWithChildren';
}
- /** @name PalletStructureError (403) */
- interface PalletStructureError extends Enum {
+ /** @name PalletStructureError (400) */
+ export interface PalletStructureError extends Enum {
readonly isOuroborosDetected: boolean;
readonly isDepthLimit: boolean;
readonly isBreadthLimit: boolean;
@@ -3510,8 +3360,8 @@
readonly type: 'OuroborosDetected' | 'DepthLimit' | 'BreadthLimit' | 'TokenNotFound';
}
- /** @name PalletRmrkCoreError (404) */
- interface PalletRmrkCoreError extends Enum {
+ /** @name PalletRmrkCoreError (401) */
+ export interface PalletRmrkCoreError extends Enum {
readonly isCorruptedCollectionType: boolean;
readonly isRmrkPropertyKeyIsTooLong: boolean;
readonly isRmrkPropertyValueIsTooLong: boolean;
@@ -3534,8 +3384,8 @@
readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
}
- /** @name PalletRmrkEquipError (406) */
- interface PalletRmrkEquipError extends Enum {
+ /** @name PalletRmrkEquipError (403) */
+ export interface PalletRmrkEquipError extends Enum {
readonly isPermissionError: boolean;
readonly isNoAvailableBaseId: boolean;
readonly isNoAvailablePartId: boolean;
@@ -3546,8 +3396,8 @@
readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst' | 'PartDoesntExist' | 'NoEquippableOnFixedPart';
}
- /** @name PalletEvmError (409) */
- interface PalletEvmError extends Enum {
+ /** @name PalletEvmError (406) */
+ export interface PalletEvmError extends Enum {
readonly isBalanceLow: boolean;
readonly isFeeOverflow: boolean;
readonly isPaymentOverflow: boolean;
@@ -3557,8 +3407,8 @@
readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';
}
- /** @name FpRpcTransactionStatus (412) */
- interface FpRpcTransactionStatus extends Struct {
+ /** @name FpRpcTransactionStatus (409) */
+ export interface FpRpcTransactionStatus extends Struct {
readonly transactionHash: H256;
readonly transactionIndex: u32;
readonly from: H160;
@@ -3568,11 +3418,11 @@
readonly logsBloom: EthbloomBloom;
}
- /** @name EthbloomBloom (414) */
- interface EthbloomBloom extends U8aFixed {}
+ /** @name EthbloomBloom (411) */
+ export interface EthbloomBloom extends U8aFixed {}
- /** @name EthereumReceiptReceiptV3 (416) */
- interface EthereumReceiptReceiptV3 extends Enum {
+ /** @name EthereumReceiptReceiptV3 (413) */
+ export interface EthereumReceiptReceiptV3 extends Enum {
readonly isLegacy: boolean;
readonly asLegacy: EthereumReceiptEip658ReceiptData;
readonly isEip2930: boolean;
@@ -3582,23 +3432,23 @@
readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
}
- /** @name EthereumReceiptEip658ReceiptData (417) */
- interface EthereumReceiptEip658ReceiptData extends Struct {
+ /** @name EthereumReceiptEip658ReceiptData (414) */
+ export interface EthereumReceiptEip658ReceiptData extends Struct {
readonly statusCode: u8;
readonly usedGas: U256;
readonly logsBloom: EthbloomBloom;
readonly logs: Vec<EthereumLog>;
}
- /** @name EthereumBlock (418) */
- interface EthereumBlock extends Struct {
+ /** @name EthereumBlock (415) */
+ export interface EthereumBlock extends Struct {
readonly header: EthereumHeader;
readonly transactions: Vec<EthereumTransactionTransactionV2>;
readonly ommers: Vec<EthereumHeader>;
}
- /** @name EthereumHeader (419) */
- interface EthereumHeader extends Struct {
+ /** @name EthereumHeader (416) */
+ export interface EthereumHeader extends Struct {
readonly parentHash: H256;
readonly ommersHash: H256;
readonly beneficiary: H160;
@@ -3616,46 +3466,46 @@
readonly nonce: EthereumTypesHashH64;
}
- /** @name EthereumTypesHashH64 (420) */
- interface EthereumTypesHashH64 extends U8aFixed {}
+ /** @name EthereumTypesHashH64 (417) */
+ export interface EthereumTypesHashH64 extends U8aFixed {}
- /** @name PalletEthereumError (425) */
- interface PalletEthereumError extends Enum {
+ /** @name PalletEthereumError (422) */
+ export interface PalletEthereumError extends Enum {
readonly isInvalidSignature: boolean;
readonly isPreLogExists: boolean;
readonly type: 'InvalidSignature' | 'PreLogExists';
}
- /** @name PalletEvmCoderSubstrateError (426) */
- interface PalletEvmCoderSubstrateError extends Enum {
+ /** @name PalletEvmCoderSubstrateError (423) */
+ export interface PalletEvmCoderSubstrateError extends Enum {
readonly isOutOfGas: boolean;
readonly isOutOfFund: boolean;
readonly type: 'OutOfGas' | 'OutOfFund';
}
- /** @name PalletEvmContractHelpersSponsoringModeT (427) */
- interface PalletEvmContractHelpersSponsoringModeT extends Enum {
+ /** @name PalletEvmContractHelpersSponsoringModeT (424) */
+ export interface PalletEvmContractHelpersSponsoringModeT extends Enum {
readonly isDisabled: boolean;
readonly isAllowlisted: boolean;
readonly isGenerous: boolean;
readonly type: 'Disabled' | 'Allowlisted' | 'Generous';
}
- /** @name PalletEvmContractHelpersError (429) */
- interface PalletEvmContractHelpersError extends Enum {
+ /** @name PalletEvmContractHelpersError (426) */
+ export interface PalletEvmContractHelpersError extends Enum {
readonly isNoPermission: boolean;
readonly type: 'NoPermission';
}
- /** @name PalletEvmMigrationError (430) */
- interface PalletEvmMigrationError extends Enum {
+ /** @name PalletEvmMigrationError (427) */
+ export interface PalletEvmMigrationError extends Enum {
readonly isAccountNotEmpty: boolean;
readonly isAccountIsNotMigrating: boolean;
readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';
}
- /** @name SpRuntimeMultiSignature (432) */
- interface SpRuntimeMultiSignature extends Enum {
+ /** @name SpRuntimeMultiSignature (429) */
+ export interface SpRuntimeMultiSignature extends Enum {
readonly isEd25519: boolean;
readonly asEd25519: SpCoreEd25519Signature;
readonly isSr25519: boolean;
@@ -3665,34 +3515,34 @@
readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';
}
- /** @name SpCoreEd25519Signature (433) */
- interface SpCoreEd25519Signature extends U8aFixed {}
+ /** @name SpCoreEd25519Signature (430) */
+ export interface SpCoreEd25519Signature extends U8aFixed {}
- /** @name SpCoreSr25519Signature (435) */
- interface SpCoreSr25519Signature extends U8aFixed {}
+ /** @name SpCoreSr25519Signature (434) */
+ export interface SpCoreSr25519Signature extends U8aFixed {}
- /** @name SpCoreEcdsaSignature (436) */
- interface SpCoreEcdsaSignature extends U8aFixed {}
+ /** @name SpCoreEcdsaSignature (435) */
+ export interface SpCoreEcdsaSignature extends U8aFixed {}
- /** @name FrameSystemExtensionsCheckSpecVersion (439) */
- type FrameSystemExtensionsCheckSpecVersion = Null;
+ /** @name FrameSystemExtensionsCheckSpecVersion (438) */
+ export type FrameSystemExtensionsCheckSpecVersion = Null;
- /** @name FrameSystemExtensionsCheckGenesis (440) */
- type FrameSystemExtensionsCheckGenesis = Null;
+ /** @name FrameSystemExtensionsCheckGenesis (439) */
+ export type FrameSystemExtensionsCheckGenesis = Null;
- /** @name FrameSystemExtensionsCheckNonce (443) */
- interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
+ /** @name FrameSystemExtensionsCheckNonce (442) */
+ export interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
- /** @name FrameSystemExtensionsCheckWeight (444) */
- type FrameSystemExtensionsCheckWeight = Null;
+ /** @name FrameSystemExtensionsCheckWeight (443) */
+ export type FrameSystemExtensionsCheckWeight = Null;
- /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (445) */
- interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
+ /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (444) */
+ export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
- /** @name OpalRuntimeRuntime (446) */
- type OpalRuntimeRuntime = Null;
+ /** @name OpalRuntimeRuntime (445) */
+ export type OpalRuntimeRuntime = Null;
- /** @name PalletEthereumFakeTransactionFinalizer (447) */
- type PalletEthereumFakeTransactionFinalizer = Null;
+ /** @name PalletEthereumFakeTransactionFinalizer (444) */
+ export type PalletEthereumFakeTransactionFinalizer = Null;
} // declare module
tests/src/interfaces/unique/definitions.tsdiffbeforeafterboth--- a/tests/src/interfaces/unique/definitions.ts
+++ b/tests/src/interfaces/unique/definitions.ts
@@ -190,5 +190,10 @@
[crossAccountParam('staker')],
'u128',
),
+ pendingUnstake: fun(
+ 'Returns the total amount of unstaked tokens',
+ [{name: 'staker', type: CROSS_ACCOUNT_ID_TYPE, isOptional: true}],
+ 'u128',
+ ),
},
};
tests/src/pallet-presence.test.tsdiffbeforeafterboth--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -68,9 +68,10 @@
const refungible = 'refungible';
const scheduler = 'scheduler';
const rmrkPallets = ['rmrkcore', 'rmrkequip'];
+ const appPromotion = 'promotion';
if (chain.eq('OPAL by UNIQUE')) {
- requiredPallets.push(refungible, scheduler, ...rmrkPallets);
+ requiredPallets.push(refungible, scheduler, appPromotion, ...rmrkPallets);
} else if (chain.eq('QUARTZ by UNIQUE')) {
// Insert Quartz additional pallets here
} else if (chain.eq('UNIQUE')) {
tests/src/util/helpers.tsdiffbeforeafterboth--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -48,6 +48,7 @@
Fungible = 'fungible',
NFT = 'nonfungible',
Scheduler = 'scheduler',
+ AppPromotion = 'promotion',
}
export async function isUnique(): Promise<boolean> {
tests/src/util/playgrounds/index.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/index.ts
+++ b/tests/src/util/playgrounds/index.ts
@@ -4,7 +4,10 @@
import {IKeyringPair} from '@polkadot/types/types';
import config from '../../config';
import '../../interfaces/augment-api-events';
-import {DevUniqueHelper} from './unique.dev';
+import * as defs from '../../interfaces/definitions';
+import {ApiPromise, WsProvider} from '@polkadot/api';
+import { UniqueHelper } from './unique';
+
class SilentLogger {
log(msg: any, level: any): void { }
@@ -15,13 +18,53 @@
};
}
-export const usingPlaygrounds = async (code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+
+class DevUniqueHelper extends UniqueHelper {
+ async connect(wsEndpoint: string, listeners?: any): Promise<void> {
+ const wsProvider = new WsProvider(wsEndpoint);
+ this.api = new ApiPromise({
+ provider: wsProvider,
+ signedExtensions: {
+ ContractHelpers: {
+ extrinsic: {},
+ payload: {},
+ },
+ FakeTransactionFinalizer: {
+ extrinsic: {},
+ payload: {},
+ },
+ },
+ rpc: {
+ unique: defs.unique.rpc,
+ rmrk: defs.rmrk.rpc,
+ eth: {
+ feeHistory: {
+ description: 'Dummy',
+ params: [],
+ type: 'u8',
+ },
+ maxPriorityFeePerGas: {
+ description: 'Dummy',
+ params: [],
+ type: 'u8',
+ },
+ },
+ },
+ });
+ await this.api.isReadyOrError;
+ this.network = await UniqueHelper.detectNetwork(this.api);
+ }
+}
+
+
+export const usingPlaygrounds = async <T = void> (code: (helper: UniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<T>) => {
// TODO: Remove, this is temporary: Filter unneeded API output
// (Jaco promised it will be removed in the next version)
const consoleErr = console.error;
const consoleLog = console.log;
const consoleWarn = console.warn;
-
+ let result: T = null as unknown as T;
+
const outFn = (printer: any) => (...args: any[]) => {
for (const arg of args) {
if (typeof arg !== 'string')
@@ -41,7 +84,7 @@
await helper.connect(config.substrateUrl);
const ss58Format = helper.chain.getChainProperties().ss58Format;
const privateKey = (seed: string) => helper.util.fromSeed(seed, ss58Format);
- await code(helper, privateKey);
+ result = await code(helper, privateKey);
}
finally {
await helper.disconnect();
@@ -49,4 +92,5 @@
console.log = consoleLog;
console.warn = consoleWarn;
}
+ return result as T;
};
\ No newline at end of file