diff --git a/src/interfaces/augment-api-consts.ts b/src/interfaces/augment-api-consts.ts new file mode 100644 index 0000000..1b19936 --- /dev/null +++ b/src/interfaces/augment-api-consts.ts @@ -0,0 +1,272 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +// import type lookup before we augment - in some environments +// this is required to allow for ambient/previous definitions +import '@polkadot/api-base/types/consts'; + +import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types'; +import type { u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { Codec } from '@polkadot/types-codec/types'; + +export type __AugmentedConst = AugmentedConst; + +declare module '@polkadot/api-base/types/consts' { + interface AugmentedConsts { + asset: { + /** + * The minimum balance to create class + **/ + createAssetClassDeposit: u128 & AugmentedConst; + maxAssetMetadata: u32 & AugmentedConst; + maxClassMetadata: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bag: { + /** + * The minimum balance to create bag + **/ + createBagDeposit: u128 & AugmentedConst; + /** + * Max number of owners + **/ + maxOwners: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + balances: { + /** + * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO! + * + * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for + * this pallet. However, you do so at your own risk: this will open up a major DoS vector. + * In case you have multiple sources of provider references, you may also get unexpected + * behaviour if you set this to zero. + * + * Bottom line: Do yourself a favour and make it at least one! + **/ + existentialDeposit: u128 & AugmentedConst; + /** + * The maximum number of individual freeze locks that can exist on an account at any time. + **/ + maxFreezes: u32 & AugmentedConst; + /** + * The maximum number of holds that can exist on an account at any time. + **/ + maxHolds: u32 & AugmentedConst; + /** + * The maximum number of locks that should exist on an account. + * Not strictly enforced, but used for weight estimation. + **/ + maxLocks: u32 & AugmentedConst; + /** + * The maximum number of named reserves that can exist on an account. + **/ + maxReserves: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bundle: { + /** + * Max number of asset classes and per asset_id in a bundle + **/ + maxAssets: u32 & AugmentedConst; + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + council: { + /** + * The maximum weight of a dispatch call that can be proposed and executed. + **/ + maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + fula: { + maxManifestMetadata: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + grandpa: { + /** + * Max Authorities in use + **/ + maxAuthorities: u32 & AugmentedConst; + /** + * The maximum number of entries to keep in the set id to session index mapping. + * + * Since the `SetIdSession` map is only used for validating equivocations this + * value should relate to the bonding duration of whatever staking system is + * being used (if any). If equivocation handling is not enabled then this value + * can be zero. + **/ + maxSetIdSessionEntries: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + imOnline: { + /** + * A configuration for base priority of unsigned transactions. + * + * This is exposed so that it can be tuned for particular runtime, when + * multiple pallets send unsigned transactions. + **/ + unsignedPriority: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + market: { + /** + * Max metadata size + **/ + maxMetadata: u32 & AugmentedConst; + /** + * Max number of rates per market_rate + **/ + maxRates: u32 & AugmentedConst; + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + pool: { + /** + * The maximum number of pool participants. We are aiming at `u8::MAX`. + **/ + maxPoolParticipants: u32 & AugmentedConst; + /** + * The maximum length of a name or symbol stored on-chain. See if this can be limited to + * `u8::MAX`. + **/ + stringLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + scheduler: { + /** + * The maximum weight that may be scheduled per block for any dispatchables. + **/ + maximumWeight: SpWeightsWeightV2Weight & AugmentedConst; + /** + * The maximum number of scheduled calls in the queue for a single block. + * + * NOTE: + * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a + * higher limit under `runtime-benchmarks` feature. + **/ + maxScheduledPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + system: { + /** + * Maximum number of block number to block hash mappings to keep (oldest pruned first). + **/ + blockHashCount: u32 & AugmentedConst; + /** + * The maximum length of a block (in bytes). + **/ + blockLength: FrameSystemLimitsBlockLength & AugmentedConst; + /** + * Block & extrinsics weights: base values and limits. + **/ + blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst; + /** + * The weight of runtime database operations the runtime can invoke. + **/ + dbWeight: SpWeightsRuntimeDbWeight & AugmentedConst; + /** + * The designated SS58 prefix of this chain. + * + * This replaces the "ss58Format" property declared in the chain spec. Reason is + * that the runtime should know about the prefix in order to make use of it as + * an identifier of the chain. + **/ + ss58Prefix: u16 & AugmentedConst; + /** + * Get the chain's current version. + **/ + version: SpVersionRuntimeVersion & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + timestamp: { + /** + * The minimum period between blocks. Beware that this is different to the *expected* + * period that the block production apparatus provides. Your chosen consensus system will + * generally work with this to determine a sensible block time. e.g. For Aura, it will be + * double this period on default settings. + **/ + minimumPeriod: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + transactionPayment: { + /** + * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their + * `priority` + * + * This value is multipled by the `final_fee` to obtain a "virtual tip" that is later + * added to a tip component in regular `priority` calculations. + * It means that a `Normal` transaction can front-run a similarly-sized `Operational` + * extrinsic (with no tip), by including a tip value greater than the virtual tip. + * + * ```rust,ignore + * // For `Normal` + * let priority = priority_calc(tip); + * + * // For `Operational` + * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; + * let priority = priority_calc(tip + virtual_tip); + * ``` + * + * Note that since we use `final_fee` the multiplier applies also to the regular `tip` + * sent with the transaction. So, not only does the transaction get a priority bump based + * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` + * transactions. + **/ + operationalFeeMultiplier: u8 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + utility: { + /** + * The limit on the number of batched calls. + **/ + batchedCallsLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + } // AugmentedConsts +} // declare module diff --git a/src/interfaces/augment-api-errors.ts b/src/interfaces/augment-api-errors.ts index fe23497..99f7e6b 100644 --- a/src/interfaces/augment-api-errors.ts +++ b/src/interfaces/augment-api-errors.ts @@ -202,6 +202,7 @@ declare module '@polkadot/api-base/types/errors' { AccountNotUploader: AugmentedError; ErrorPickingAccountToChallenge: AugmentedError; ErrorPickingCIDToChallenge: AugmentedError; + FileAlreadyUploadedbyUser: AugmentedError; InvalidArrayLength: AugmentedError; ManifestAlreadyExist: AugmentedError; ManifestNotFound: AugmentedError; @@ -254,6 +255,20 @@ declare module '@polkadot/api-base/types/errors' { **/ [key: string]: AugmentedError; }; + imOnline: { + /** + * Duplicated heartbeat. + **/ + DuplicatedHeartbeat: AugmentedError; + /** + * Non existent public key. + **/ + InvalidKey: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; market: { InsufficientAmount: AugmentedError; InsufficientLiquidity: AugmentedError; @@ -423,6 +438,16 @@ declare module '@polkadot/api-base/types/errors' { **/ [key: string]: AugmentedError; }; + utility: { + /** + * Too many calls batched. + **/ + TooManyCalls: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; validatorSet: { /** * Only the validator can add itself back after coming online. diff --git a/src/interfaces/augment-api-events.ts b/src/interfaces/augment-api-events.ts new file mode 100644 index 0000000..85dd332 --- /dev/null +++ b/src/interfaces/augment-api-events.ts @@ -0,0 +1,447 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +// import type lookup before we augment - in some environments +// this is required to allow for ambient/previous definitions +import '@polkadot/api-base/types/events'; + +import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types'; +import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, i32, u128, u16, u32, u64 } from '@polkadot/types-codec'; +import type { ITuple } from '@polkadot/types-codec/types'; +import type { AccountId32, H256 } from '@polkadot/types/interfaces/runtime'; + +export type __AugmentedEvent = AugmentedEvent; + +declare module '@polkadot/api-base/types/events' { + interface AugmentedEvents { + asset: { + AssetCreated: AugmentedEvent; + AssetMetadataUpdated: AugmentedEvent; + BatchBurn: AugmentedEvent, amounts: Vec], { who: AccountId32, from: AccountId32, classId: u64, assetIds: Vec, amounts: Vec }>; + BatchMint: AugmentedEvent, amounts: Vec], { who: AccountId32, to: AccountId32, classId: u64, assetIds: Vec, amounts: Vec }>; + BatchTransferred: AugmentedEvent, amounts: Vec], { who: AccountId32, from: AccountId32, to: AccountId32, classId: u64, assetIds: Vec, amounts: Vec }>; + Burn: AugmentedEvent; + ClassCreated: AugmentedEvent; + Mint: AugmentedEvent; + OperatorApprovalForAll: AugmentedEvent; + Transferred: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bag: { + Created: AugmentedEvent], { bag: AccountId32, who: AccountId32, classId: u64, assetId: u64, owners: Vec }>; + Deposit: AugmentedEvent; + Register: AugmentedEvent; + Sweep: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + balances: { + /** + * A balance was set by root. + **/ + BalanceSet: AugmentedEvent; + /** + * Some amount was burned from an account. + **/ + Burned: AugmentedEvent; + /** + * Some amount was deposited (e.g. for transaction fees). + **/ + Deposit: AugmentedEvent; + /** + * An account was removed whose balance was non-zero but below ExistentialDeposit, + * resulting in an outright loss. + **/ + DustLost: AugmentedEvent; + /** + * An account was created with some free balance. + **/ + Endowed: AugmentedEvent; + /** + * Some balance was frozen. + **/ + Frozen: AugmentedEvent; + /** + * Total issuance was increased by `amount`, creating a credit to be balanced. + **/ + Issued: AugmentedEvent; + /** + * Some balance was locked. + **/ + Locked: AugmentedEvent; + /** + * Some amount was minted into an account. + **/ + Minted: AugmentedEvent; + /** + * Total issuance was decreased by `amount`, creating a debt to be balanced. + **/ + Rescinded: AugmentedEvent; + /** + * Some balance was reserved (moved from free to reserved). + **/ + Reserved: AugmentedEvent; + /** + * Some balance was moved from the reserve of the first account to the second account. + * Final argument indicates the destination balance type. + **/ + ReserveRepatriated: AugmentedEvent; + /** + * Some amount was restored into an account. + **/ + Restored: AugmentedEvent; + /** + * Some amount was removed from the account (e.g. for misbehavior). + **/ + Slashed: AugmentedEvent; + /** + * Some amount was suspended from an account (it can be restored later). + **/ + Suspended: AugmentedEvent; + /** + * Some balance was thawed. + **/ + Thawed: AugmentedEvent; + /** + * Transfer succeeded. + **/ + Transfer: AugmentedEvent; + /** + * Some balance was unlocked. + **/ + Unlocked: AugmentedEvent; + /** + * Some balance was unreserved (moved from reserved to free). + **/ + Unreserved: AugmentedEvent; + /** + * An account was upgraded. + **/ + Upgraded: AugmentedEvent; + /** + * Some amount was withdrawn from the account (e.g. for transaction fees). + **/ + Withdraw: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bundle: { + Burn: AugmentedEvent; + Mint: AugmentedEvent; + Register: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + council: { + /** + * A motion was approved by the required threshold. + **/ + Approved: AugmentedEvent; + /** + * A proposal was closed because its threshold was reached or after its duration was up. + **/ + Closed: AugmentedEvent; + /** + * A motion was not approved by the required threshold. + **/ + Disapproved: AugmentedEvent; + /** + * A motion was executed; result will be `Ok` if it returned without error. + **/ + Executed: AugmentedEvent], { proposalHash: H256, result: Result }>; + /** + * A single member did some action; result will be `Ok` if it returned without error. + **/ + MemberExecuted: AugmentedEvent], { proposalHash: H256, result: Result }>; + /** + * A motion (given hash) has been proposed (by given account) with a threshold (given + * `MemberCount`). + **/ + Proposed: AugmentedEvent; + /** + * A motion (given hash) has been voted on by given account, leaving + * a tally (yes votes and no votes given respectively as `MemberCount`). + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + dao: { + /** + * Event documentation should end with an array that provides descriptive names for event + * parameters. [something, who] + **/ + SomethingStored: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + exgine: { + /** + * Event documentation should end with an array that provides descriptive names for event + * parameters. [something, who] + **/ + SomethingStored: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + fula: { + BatchManifestOutput: AugmentedEvent, manifests: Vec], { uploader: AccountId32, poolIds: Vec, manifests: Vec }>; + BatchManifestRemoved: AugmentedEvent, cids: Vec], { uploader: AccountId32, poolIds: Vec, cids: Vec }>; + BatchRemoveStorerOutput: AugmentedEvent], { storer: AccountId32, poolId: u32, cids: Vec }>; + BatchStorageManifestOutput: AugmentedEvent], { storer: AccountId32, poolId: u32, cids: Vec }>; + Challenge: AugmentedEvent; + GetAvailableManifests: AugmentedEvent], { manifests: Vec }>; + GetManifests: AugmentedEvent], { manifests: Vec }>; + GetManifestsStorerData: AugmentedEvent], { manifests: Vec }>; + ManifestOutput: AugmentedEvent, poolId: u32, manifest: Bytes], { uploader: AccountId32, storer: Vec, poolId: u32, manifest: Bytes }>; + ManifestRemoved: AugmentedEvent; + ManifestStorageUpdated: AugmentedEvent; + MintedLaborTokens: AugmentedEvent; + RemoveStorerOutput: AugmentedEvent, poolId: u32, cid: Bytes], { storer: Option, poolId: u32, cid: Bytes }>; + StorageManifestOutput: AugmentedEvent; + UpdateFileSizeOutput: AugmentedEvent; + UpdateFileSizesOutput: AugmentedEvent, sizes: Vec], { account: AccountId32, poolId: u32, cids: Vec, sizes: Vec }>; + VerifiedChallenges: AugmentedEvent, failed: Vec], { challenged: AccountId32, successful: Vec, failed: Vec }>; + VerifiedStorerManifests: AugmentedEvent, invalidCids: Vec], { storer: AccountId32, validCids: Vec, invalidCids: Vec }>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + grandpa: { + /** + * New authority set has been applied. + **/ + NewAuthorities: AugmentedEvent>], { authoritySet: Vec> }>; + /** + * Current authority set has been paused. + **/ + Paused: AugmentedEvent; + /** + * Current authority set has been resumed. + **/ + Resumed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + imOnline: { + /** + * At the end of the session, no offence was committed. + **/ + AllGood: AugmentedEvent; + /** + * A new heartbeat was received from `AuthorityId`. + **/ + HeartbeatReceived: AugmentedEvent; + /** + * At the end of the session, at least one validator was found to be offline. + **/ + SomeOffline: AugmentedEvent>], { offline: Vec> }>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + market: { + Created: AugmentedEvent; + Deposit: AugmentedEvent, success: bool], { who: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec, success: bool }>; + Exchanged: AugmentedEvent, success: bool], { buyer: AccountId32, marketId: u64, marketRateId: u64, amount: u128, balances: Vec, success: bool }>; + LiquidityAdded: AugmentedEvent, assetIds: Vec>, amounts: Vec>], { who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec, assetIds: Vec>, amounts: Vec> }>; + LiquidityRemoved: AugmentedEvent, assetIds: Vec>, amounts: Vec>], { who: AccountId32, marketId: u64, marketRateId: u64, classIds: Vec, assetIds: Vec>, amounts: Vec> }>; + RateCreated: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + pool: { + /** + * Pool's capacity has been reached, + **/ + CapacityReached: AugmentedEvent; + /** + * A user requested to join a pool. + **/ + JoinRequested: AugmentedEvent; + /** + * Pool participant left. + **/ + ParticipantLeft: AugmentedEvent; + /** + * A pool has been created. + **/ + PoolCreated: AugmentedEvent, poolId: u32], { owner: Option, poolId: u32 }>; + /** + * A user has withdrawn their request to join a pool. + **/ + RequestWithdrawn: AugmentedEvent; + VotingResult: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + scheduler: { + /** + * The call for the provided hash was not found so the task has been aborted. + **/ + CallUnavailable: AugmentedEvent, id: Option], { task: ITuple<[u32, u32]>, id: Option }>; + /** + * Canceled some task. + **/ + Canceled: AugmentedEvent; + /** + * Dispatched some task. + **/ + Dispatched: AugmentedEvent, id: Option, result: Result], { task: ITuple<[u32, u32]>, id: Option, result: Result }>; + /** + * The given task was unable to be renewed since the agenda is full at that block. + **/ + PeriodicFailed: AugmentedEvent, id: Option], { task: ITuple<[u32, u32]>, id: Option }>; + /** + * The given task can never be executed since it is overweight. + **/ + PermanentlyOverweight: AugmentedEvent, id: Option], { task: ITuple<[u32, u32]>, id: Option }>; + /** + * Scheduled some task. + **/ + Scheduled: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + session: { + /** + * New session has happened. Note that the argument is the session index, not the + * block number as the type might suggest. + **/ + NewSession: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + sudo: { + /** + * The \[sudoer\] just switched identity; the old key is supplied if one existed. + **/ + KeyChanged: AugmentedEvent], { oldSudoer: Option }>; + /** + * A sudo just took place. \[result\] + **/ + Sudid: AugmentedEvent], { sudoResult: Result }>; + /** + * A sudo just took place. \[result\] + **/ + SudoAsDone: AugmentedEvent], { sudoResult: Result }>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + system: { + /** + * `:code` was updated. + **/ + CodeUpdated: AugmentedEvent; + /** + * An extrinsic failed. + **/ + ExtrinsicFailed: AugmentedEvent; + /** + * An extrinsic completed successfully. + **/ + ExtrinsicSuccess: AugmentedEvent; + /** + * An account was reaped. + **/ + KilledAccount: AugmentedEvent; + /** + * A new account was created. + **/ + NewAccount: AugmentedEvent; + /** + * On on-chain remark happened. + **/ + Remarked: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + transactionPayment: { + /** + * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, + * has been paid by `who`. + **/ + TransactionFeePaid: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + utility: { + /** + * Batch of dispatches completed fully with no error. + **/ + BatchCompleted: AugmentedEvent; + /** + * Batch of dispatches completed but has errors. + **/ + BatchCompletedWithErrors: AugmentedEvent; + /** + * Batch of dispatches did not complete fully. Index of first failing dispatch given, as + * well as the error. + **/ + BatchInterrupted: AugmentedEvent; + /** + * A call was dispatched. + **/ + DispatchedAs: AugmentedEvent], { result: Result }>; + /** + * A single item within a Batch of dispatches has completed with no error. + **/ + ItemCompleted: AugmentedEvent; + /** + * A single item within a Batch of dispatches has completed with error. + **/ + ItemFailed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + validatorSet: { + /** + * New validator addition initiated. Effective in ~2 sessions. + **/ + ValidatorAdditionInitiated: AugmentedEvent; + /** + * Validator removal initiated. Effective in ~2 sessions. + **/ + ValidatorRemovalInitiated: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + } // AugmentedEvents +} // declare module diff --git a/src/interfaces/augment-api-query.ts b/src/interfaces/augment-api-query.ts new file mode 100644 index 0000000..9e6dce4 --- /dev/null +++ b/src/interfaces/augment-api-query.ts @@ -0,0 +1,465 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +// import type lookup before we augment - in some environments +// this is required to allow for ambient/previous definitions +import '@polkadot/api-base/types/storage'; + +import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types'; +import type { Bytes, Option, U8aFixed, Vec, WrapperOpaque, bool, u128, u32, u64 } from '@polkadot/types-codec'; +import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; +import type { AccountId32, Call, H256 } from '@polkadot/types/interfaces/runtime'; +import type { Observable } from '@polkadot/types/types'; + +export type __AugmentedQuery = AugmentedQuery unknown>; +export type __QueryableStorageEntry = QueryableStorageEntry; + +declare module '@polkadot/api-base/types/storage' { + interface AugmentedQueries { + asset: { + assetCount: AugmentedQuery Observable, [u64]> & QueryableStorageEntry; + assets: AugmentedQuery Observable>, [u64, u64]> & QueryableStorageEntry; + balances: AugmentedQuery Observable, [AccountId32, u64, u64]> & QueryableStorageEntry; + classes: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + authorship: { + /** + * Author of current block. + **/ + author: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bag: { + bagClasses: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + bags: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + nextBagId: AugmentedQuery Observable, [u64]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + balances: { + /** + * The Balances pallet example of storing the balance of an account. + * + * # Example + * + * ```nocompile + * impl pallet_balances::Config for Runtime { + * type AccountStore = StorageMapShim, frame_system::Provider, AccountId, Self::AccountData> + * } + * ``` + * + * You can also store the balance of an account in the `System` pallet. + * + * # Example + * + * ```nocompile + * impl pallet_balances::Config for Runtime { + * type AccountStore = System + * } + * ``` + * + * But this comes with tradeoffs, storing account balances in the system pallet stores + * `frame_system` data alongside the account data contrary to storing account balances in the + * `Balances` pallet, which uses a `StorageMap` to store balances data only. + * NOTE: This is only used in the case that this pallet is used to store balances. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Freeze locks on account balances. + **/ + freezes: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Holds on account balances. + **/ + holds: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The total units of outstanding deactivated balance in the system. + **/ + inactiveIssuance: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Any liquidity locks on some account balances. + * NOTE: Should only be accessed when setting, changing and freeing a lock. + **/ + locks: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Named reserves on some account balances. + **/ + reserves: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The total units issued in the system. + **/ + totalIssuance: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bundle: { + assetBundles: AugmentedQuery Observable>, [u64, u64]> & QueryableStorageEntry; + bundles: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + council: { + /** + * The current members of the collective. This is stored sorted (just by value). + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The prime member that helps determine the default vote behavior in case of absentations. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Proposals so far. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Actual proposal for a given hash, if it's current. + **/ + proposalOf: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The hashes of the active proposals. + **/ + proposals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes on a given proposal, if it is ongoing. + **/ + voting: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + dao: { + something: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + exgine: { + something: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + fula: { + challengeRequests: AugmentedQuery Observable>, [AccountId32, Bytes]> & QueryableStorageEntry; + claims: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + manifests: AugmentedQuery Observable>, [u32, Bytes]> & QueryableStorageEntry; + manifestsStorerData: AugmentedQuery Observable>, [u32, AccountId32, Bytes]> & QueryableStorageEntry; + networkSize: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + grandpa: { + /** + * The number of changes (both in terms of keys and underlying economic responsibilities) + * in the "set" of Grandpa validators from genesis. + **/ + currentSetId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * next block number where we can force a change. + **/ + nextForced: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Pending change: (signaled at, scheduled change). + **/ + pendingChange: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * A mapping from grandpa set ID to the index of the *most recent* session for which its + * members were responsible. + * + * This is only used for validating equivocation proofs. An equivocation proof must + * contains a key-ownership proof for a given session, therefore we need a way to tie + * together sessions and GRANDPA set ids, i.e. we need to validate that a validator + * was the owner of a given key on a given session, and what the active set ID was + * during that session. + * + * TWOX-NOTE: `SetId` is not under user control. + **/ + setIdSession: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * `true` if we are currently stalled. + **/ + stalled: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * State of the current authority set. + **/ + state: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + imOnline: { + /** + * For each session index, we keep a mapping of `ValidatorId` to the + * number of blocks authored by the given authority. + **/ + authoredBlocks: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The block number after which it's ok to send heartbeats in the current + * session. + * + * At the beginning of each session we set this to a value that should fall + * roughly in the middle of the session duration. The idea is to first wait for + * the validators to produce a block in the current session, so that the + * heartbeat later on will not be necessary. + * + * This value will only be used as a fallback if we fail to get a proper session + * progress estimate from `NextSessionRotation`, as those estimates should be + * more accurate then the value we calculate for `HeartbeatAfter`. + **/ + heartbeatAfter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current set of keys that may issue a heartbeat. + **/ + keys: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to + * `WrapperOpaque`. + **/ + receivedHeartbeats: AugmentedQuery Observable>>, [u32, u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + market: { + marketRates: AugmentedQuery Observable>>, [u64, u64]> & QueryableStorageEntry; + marketRatesMetadata: AugmentedQuery Observable>, [u64, u64]> & QueryableStorageEntry; + markets: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + pool: { + /** + * An incremental value reflecting all pools created so far. + **/ + lastPoolId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Maximum number of pools that can exist. If `None`, then an unbounded number of + * pools can exist. + **/ + maxPools: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * PoolRequests storage + **/ + poolRequests: AugmentedQuery Observable>, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Pools storage + **/ + pools: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Users storage, useful in case a user wants to leave or join a pool. + **/ + users: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + scheduler: { + /** + * Items to be executed, indexed by the block number that they should be executed on. + **/ + agenda: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + incompleteSince: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Lookup from a name to the block number and index of the task. + * + * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4 + * identities. + **/ + lookup: AugmentedQuery Observable>>, [U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + session: { + /** + * Current index of the session. + **/ + currentIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Indices of disabled validators. + * + * The vec is always kept sorted so that we can find whether a given validator is + * disabled using binary search. It gets cleared when `on_session_ending` returns + * a new set of identities. + **/ + disabledValidators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The owner of a key. The key is the `KeyTypeId` + the encoded key. + **/ + keyOwner: AugmentedQuery | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry]>; + /** + * The next session keys for a validator. + **/ + nextKeys: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * True if the underlying economic identities or weighting behind the validators + * has changed in the queued validator set. + **/ + queuedChanged: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The queued keys for the next session. When the next session begins, these keys + * will be used to determine the validator's session keys. + **/ + queuedKeys: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The current set of validators. + **/ + validators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + sudo: { + /** + * The `AccountId` of the sudo key. + **/ + key: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + system: { + /** + * The full account information for a particular account ID. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Total length (in bytes) for all extrinsics put together, for the current block. + **/ + allExtrinsicsLen: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map of block numbers to block hashes. + **/ + blockHash: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The current weight for the block. + **/ + blockWeight: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Digest of the current block, also part of the block header. + **/ + digest: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The number of events in the `Events` list. + **/ + eventCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Events deposited for the current block. + * + * NOTE: The item is unbound and should therefore never be read on chain. + * It could otherwise inflate the PoV size of a block. + * + * Events have a large in-memory size. Box the events to not go out-of-memory + * just in case someone still reads them from within the runtime. + **/ + events: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Mapping between a topic (represented by T::Hash) and a vector of indexes + * of events in the `>` list. + * + * All topic vectors have deterministic storage locations depending on the topic. This + * allows light-clients to leverage the changes trie storage tracking mechanism and + * in case of changes fetch the list of events of interest. + * + * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just + * the `EventIndex` then in case if the topic has the same contents on the next block + * no notification will be triggered thus the event might be lost. + **/ + eventTopics: AugmentedQuery Observable>>, [H256]> & QueryableStorageEntry; + /** + * The execution phase of the block. + **/ + executionPhase: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Total extrinsics count for the current block. + **/ + extrinsicCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Extrinsics data for the current block (maps an extrinsic's index to its data). + **/ + extrinsicData: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. + **/ + lastRuntimeUpgrade: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current block number being processed. Set by `execute_block`. + **/ + number: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Hash of the previous block. + **/ + parentHash: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False + * (default) if not. + **/ + upgradedToTripleRefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. + **/ + upgradedToU32RefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + timestamp: { + /** + * Did the timestamp get updated in this block? + **/ + didUpdate: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Current time for the current block. + **/ + now: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + transactionPayment: { + nextFeeMultiplier: AugmentedQuery Observable, []> & QueryableStorageEntry; + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + validatorSet: { + approvedValidators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + offlineValidators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + validators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + } // AugmentedQueries +} // declare module diff --git a/src/interfaces/augment-api-rpc.ts b/src/interfaces/augment-api-rpc.ts index bd142eb..0ca0d6c 100644 --- a/src/interfaces/augment-api-rpc.ts +++ b/src/interfaces/augment-api-rpc.ts @@ -11,7 +11,7 @@ import type { Bytes, HashMap, Json, Null, Option, Text, U256, U64, Vec, bool, f6 import type { AnyNumber, Codec } from '@polkadot/types-codec/types'; import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author'; import type { EpochAuthorship } from '@polkadot/types/interfaces/babe'; -import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy'; +import type { BeefyVersionedFinalityProof } from '@polkadot/types/interfaces/beefy'; import type { BlockHash } from '@polkadot/types/interfaces/chain'; import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate'; import type { AuthorityId } from '@polkadot/types/interfaces/consensus'; @@ -80,9 +80,9 @@ declare module '@polkadot/rpc-core/types/jsonrpc' { **/ getFinalizedHead: AugmentedRpc<() => Observable>; /** - * Returns the block most recently finalized by BEEFY, alongside side its justification. + * Returns the block most recently finalized by BEEFY, alongside its justification. **/ - subscribeJustifications: AugmentedRpc<() => Observable>; + subscribeJustifications: AugmentedRpc<() => Observable>; }; chain: { /** diff --git a/src/interfaces/augment-api-tx.ts b/src/interfaces/augment-api-tx.ts new file mode 100644 index 0000000..8c3f234 --- /dev/null +++ b/src/interfaces/augment-api-tx.ts @@ -0,0 +1,708 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +// import type lookup before we augment - in some environments +// this is required to allow for ambient/previous definitions +import '@polkadot/api-base/types/submittable'; + +import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types'; +import type { Bytes, Compact, Option, U8aFixed, Vec, bool, i32, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types'; +import type { AccountId32, Call, H256, MultiAddress } from '@polkadot/types/interfaces/runtime'; + +export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>; +export type __SubmittableExtrinsic = SubmittableExtrinsic; +export type __SubmittableExtrinsicFunction = SubmittableExtrinsicFunction; + +declare module '@polkadot/api-base/types/submittable' { + interface AugmentedSubmittables { + asset: { + batchBurn: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec | (u64 | AnyNumber | Uint8Array)[], amounts: Vec | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [AccountId32, u64, Vec, Vec]>; + batchMint: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec | (u64 | AnyNumber | Uint8Array)[], amounts: Vec | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [AccountId32, u64, Vec, Vec]>; + batchTransferFrom: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetIds: Vec | (u64 | AnyNumber | Uint8Array)[], amounts: Vec | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [AccountId32, AccountId32, u64, Vec, Vec]>; + burn: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u64, u64, u128]>; + createAsset: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u64, u64, Bytes]>; + createClass: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, u64, Bytes]>; + mint: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u64, u64, u128]>; + transferFrom: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32, u64, u64, u128]>; + updateAssetMetadata: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u64, u64, Bytes]>; + updateClassMetadata: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u64, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bag: { + create: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, owners: Vec | (AccountId32 | string | Uint8Array)[], shares: Vec | (u128 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [u64, Vec, Vec]>; + deposit: AugmentedSubmittable<(bag: AccountId32 | string | Uint8Array, classIds: Vec | (u64 | AnyNumber | Uint8Array)[], assetIds: Vec>, amounts: Vec>) => SubmittableExtrinsic, [AccountId32, Vec, Vec>, Vec>]>; + register: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u64, Bytes]>; + sweep: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, bag: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + balances: { + /** + * Set the regular balance of a given account. + * + * The dispatch origin for this call is `root`. + **/ + forceSetBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Exactly as `transfer_allow_death`, except the origin must be root and the source account + * may be specified. + **/ + forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, MultiAddress, Compact]>; + /** + * Unreserve some balance from a user by force. + * + * Can only be called by ROOT. + **/ + forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, u128]>; + /** + * Set the regular balance of a given account; it also takes a reserved balance but this + * must be the same as the account's current reserved balance. + * + * The dispatch origin for this call is `root`. + * + * WARNING: This call is DEPRECATED! Use `force_set_balance` instead. + **/ + setBalanceDeprecated: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact | AnyNumber | Uint8Array, oldReserved: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact, Compact]>; + /** + * Alias for `transfer_allow_death`, provided only for name-wise compatibility. + * + * WARNING: DEPRECATED! Will be released in approximately 3 months. + **/ + transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Transfer the entire transferable balance from the caller account. + * + * NOTE: This function only attempts to transfer _transferable_ balances. This means that + * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be + * transferred by this function. To ensure that this function results in a killed account, + * you might need to prepare the account by removing any reference counters, storage + * deposits, etc... + * + * The dispatch origin of this call must be Signed. + * + * - `dest`: The recipient of the transfer. + * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all + * of the funds the account has, causing the sender account to be killed (false), or + * transfer everything except at least the existential deposit, which will guarantee to + * keep the sender account alive (true). + **/ + transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * Transfer some liquid free balance to another account. + * + * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. + * If the sender's account is below the existential deposit as a result + * of the transfer, the account will be reaped. + * + * The dispatch origin for this call must be `Signed` by the transactor. + **/ + transferAllowDeath: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not + * kill the origin account. + * + * 99% of the time you want [`transfer_allow_death`] instead. + * + * [`transfer_allow_death`]: struct.Pallet.html#method.transfer + **/ + transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Upgrade a specified account. + * + * - `origin`: Must be `Signed`. + * - `who`: The account to be upgraded. + * + * This will waive the transaction fee if at least all but 10% of the accounts needed to + * be upgraded. (We let some not have to be upgraded just in order to allow for the + * possibililty of churn). + **/ + upgradeAccounts: AugmentedSubmittable<(who: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bundle: { + burnBundle: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, bundleId: H256 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32, H256, u128]>; + mintBundle: AugmentedSubmittable<(from: AccountId32 | string | Uint8Array, to: AccountId32 | string | Uint8Array, bundleId: H256 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32, H256, u128]>; + registerBundle: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, bundleId: H256 | string | Uint8Array, schema: ITuple<[Vec, Vec>, Vec>]> | [Vec | (u64 | AnyNumber | Uint8Array)[], Vec>, Vec>], metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u64, u64, H256, ITuple<[Vec, Vec>, Vec>]>, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + council: { + /** + * Close a vote that is either approved, disapproved or whose voting period has ended. + * + * May be called by any signed account in order to finish voting and close the proposal. + * + * If called before the end of the voting period it will only close the vote if it is + * has enough votes to be approved or disapproved. + * + * If called after the end of the voting period abstentions are counted as rejections + * unless there is a prime member set and the prime member cast an approval. + * + * If the close operation completes successfully with disapproval, the transaction fee will + * be waived. Otherwise execution of the approved operation will be charged to the caller. + * + * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed + * proposal. + * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via + * `storage::read` so it is `size_of::() == 4` larger than the pure length. + * + * ## Complexity + * - `O(B + M + P1 + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - `P1` is the complexity of `proposal` preimage. + * - `P2` is proposal-count (code-bounded) + **/ + close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact, SpWeightsWeightV2Weight, Compact]>; + /** + * Disapprove a proposal, close, and remove it from the system, regardless of its current + * state. + * + * Must be called by the Root origin. + * + * Parameters: + * * `proposal_hash`: The hash of the proposal that should be disapproved. + * + * ## Complexity + * O(P) where P is the number of max proposals + **/ + disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Dispatch a proposal from a member using the `Member` origin. + * + * Origin must be a member of the collective. + * + * ## Complexity: + * - `O(B + M + P)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` members-count (code-bounded) + * - `P` complexity of dispatching `proposal` + **/ + execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Call, Compact]>; + /** + * Add a new proposal to either be voted on or executed directly. + * + * Requires the sender to be member. + * + * `threshold` determines whether `proposal` is executed directly (`threshold < 2`) + * or put up for voting. + * + * ## Complexity + * - `O(B + M + P1)` or `O(B + M + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - branching is influenced by `threshold` where: + * - `P1` is proposal execution complexity (`threshold < 2`) + * - `P2` is proposals-count (code-bounded) (`threshold >= 2`) + **/ + propose: AugmentedSubmittable<(threshold: Compact | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Call, Compact]>; + /** + * Set the collective's membership. + * + * - `new_members`: The new member list. Be nice to the chain and provide it sorted. + * - `prime`: The prime member whose vote sets the default. + * - `old_count`: The upper bound for the previous number of members in storage. Used for + * weight estimation. + * + * The dispatch of this call must be `SetMembersOrigin`. + * + * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but + * the weight estimations rely on it to estimate dispatchable weight. + * + * # WARNING: + * + * The `pallet-collective` can also be managed by logic outside of the pallet through the + * implementation of the trait [`ChangeMembers`]. + * Any call to `set_members` must be careful that the member set doesn't get out of sync + * with other logic managing the member set. + * + * ## Complexity: + * - `O(MP + N)` where: + * - `M` old-members-count (code- and governance-bounded) + * - `N` new-members-count (code- and governance-bounded) + * - `P` proposals-count (code-bounded) + **/ + setMembers: AugmentedSubmittable<(newMembers: Vec | (AccountId32 | string | Uint8Array)[], prime: Option | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Option, u32]>; + /** + * Add an aye or nay vote for the sender to the given proposal. + * + * Requires the sender to be a member. + * + * Transaction fees will be waived if the member is voting on any particular proposal + * for the first time and the call is successful. Subsequent vote changes will charge a + * fee. + * ## Complexity + * - `O(M)` where `M` is members-count (code- and governance-bounded) + **/ + vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [H256, Compact, bool]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + dao: { + /** + * An example dispatchable that may throw a custom error. + **/ + causeError: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * An example dispatchable that takes a singles value as a parameter, writes the value to + * storage and emits an event. This function must be dispatched by a signed extrinsic. + **/ + doSomething: AugmentedSubmittable<(something: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + exgine: { + /** + * An example dispatchable that may throw a custom error. + **/ + causeError: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * An example dispatchable that takes a singles value as a parameter, writes the value to + * storage and emits an event. This function must be dispatched by a signed extrinsic. + **/ + doSomething: AugmentedSubmittable<(something: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + fula: { + batchRemoveManifest: AugmentedSubmittable<(cids: Vec | (Bytes | string | Uint8Array)[], poolIds: Vec | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [Vec, Vec]>; + batchRemoveStoredManifest: AugmentedSubmittable<(cids: Vec | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, u32]>; + batchStorageManifest: AugmentedSubmittable<(cids: Vec | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, u32]>; + batchUploadManifest: AugmentedSubmittable<(manifest: Vec | (Bytes | string | Uint8Array)[], cids: Vec | (Bytes | string | Uint8Array)[], poolId: Vec | (u32 | AnyNumber | Uint8Array)[], replicationFactor: Vec | (u16 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [Vec, Vec, Vec, Vec]>; + generateChallenge: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + getAvailableManifests: AugmentedSubmittable<(poolId: Option | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic, [Option]>; + getManifests: AugmentedSubmittable<(poolId: Option | null | Uint8Array | u32 | AnyNumber, uploader: Option | null | Uint8Array | AccountId32 | string, storer: Option | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic, [Option, Option, Option]>; + getManifestsStorerData: AugmentedSubmittable<(poolId: Option | null | Uint8Array | u32 | AnyNumber, storer: Option | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic, [Option, Option]>; + mintLaborTokens: AugmentedSubmittable<(classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64, u64, u128]>; + removeManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + removeStoredManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + storageManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + updateFileSize: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, size: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, u64]>; + updateFileSizes: AugmentedSubmittable<(cids: Vec | (Bytes | string | Uint8Array)[], poolId: u32 | AnyNumber | Uint8Array, sizes: Vec | (u64 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [Vec, u32, Vec]>; + /** + * Updates the values of the manifest storer data given the specific data + **/ + updateManifest: AugmentedSubmittable<(cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, activeCycles: u16 | AnyNumber | Uint8Array, missedCycles: u16 | AnyNumber | Uint8Array, activeDays: i32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, u16, u16, i32]>; + uploadManifest: AugmentedSubmittable<(manifest: Bytes | string | Uint8Array, cid: Bytes | string | Uint8Array, poolId: u32 | AnyNumber | Uint8Array, replicationFactor: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, Bytes, u32, u16]>; + verifyChallenge: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, cids: Vec | (Bytes | string | Uint8Array)[], classId: u64 | AnyNumber | Uint8Array, assetId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, Vec, u64, u64]>; + verifyManifests: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + grandpa: { + /** + * Note that the current authority set of the GRANDPA finality gadget has stalled. + * + * This will trigger a forced authority set change at the beginning of the next session, to + * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume + * that the block signalling the forced change will not be re-orged e.g. 1000 blocks. + * The block production rate (which may be slowed down because of finality lagging) should + * be taken into account when choosing the `delay`. The GRANDPA voters based on the new + * authority will start voting on top of `best_finalized_block_number` for new finalized + * blocks. `best_finalized_block_number` should be the highest of the latest finalized + * block of all validators of the new authority set. + * + * Only callable by root. + **/ + noteStalled: AugmentedSubmittable<(delay: u32 | AnyNumber | Uint8Array, bestFinalizedBlockNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + **/ + reportEquivocation: AugmentedSubmittable<(equivocationProof: SpConsensusGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpCoreVoid | null) => SubmittableExtrinsic, [SpConsensusGrandpaEquivocationProof, SpCoreVoid]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + * + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + **/ + reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpConsensusGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpCoreVoid | null) => SubmittableExtrinsic, [SpConsensusGrandpaEquivocationProof, SpCoreVoid]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + imOnline: { + /** + * ## Complexity: + * - `O(K + E)` where K is length of `Keys` (heartbeat.validators_len) and E is length of + * `heartbeat.network_state.external_address` + * - `O(K)`: decoding of length `K` + * - `O(E)`: decoding/encoding of length `E` + **/ + heartbeat: AugmentedSubmittable<(heartbeat: PalletImOnlineHeartbeat | { blockNumber?: any; networkState?: any; sessionIndex?: any; authorityIndex?: any; validatorsLen?: any } | string | Uint8Array, signature: PalletImOnlineSr25519AppSr25519Signature | string | Uint8Array) => SubmittableExtrinsic, [PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Signature]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + market: { + createMarket: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + createMarketRate: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, rates: Vec | (SugarfungeMarketAssetRate | { classId?: any; assetId?: any; action?: any; from?: any; to?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [u64, u64, Vec]>; + deposit: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64, u64, u128]>; + exchangeAssets: AugmentedSubmittable<(marketId: u64 | AnyNumber | Uint8Array, marketRateId: u64 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64, u64, u128]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + pool: { + /** + * Cancel a `PoolRequest`, useful if a user decides to join another pool or they are stuck in + * the voting queue for too long. + **/ + cancelJoin: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, targetAccount: Option | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic, [u32, Option]>; + /** + * Creates a new pool. `peer_id` is a libp2p peerID validated on the client-side. + * + * TODO: Deposit; check the current pool number. Currently we check the PoolId to retrieve + * the pool number, but if we want to delete empty pools - then we need to retrieve the + * actual pool number from storage, for which a CountedMap should be used. + **/ + create: AugmentedSubmittable<(name: Bytes | string | Uint8Array, region: Bytes | string | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes, Bytes, Bytes]>; + /** + * Open a `PoolRequest` to join the pool. + **/ + join: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Allows for the user to leave a pool. + **/ + leavePool: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, targetAccount: Option | null | Uint8Array | AccountId32 | string) => SubmittableExtrinsic, [u32, Option]>; + /** + * Vote for a `PoolRequest`. If `positive` is set to `false` - that's voting against. + * This method also calculates votes each time it's called and takes action once the result + * is conclusive. + * TODO: Currently does not cover pool overflow scenario and simply fails then. + **/ + vote: AugmentedSubmittable<(poolId: u32 | AnyNumber | Uint8Array, account: AccountId32 | string | Uint8Array, positive: bool | boolean | Uint8Array, peerId: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, AccountId32, bool, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + scheduler: { + /** + * Cancel an anonymously scheduled task. + **/ + cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Cancel a named scheduled task. + **/ + cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed]>; + /** + * Anonymously schedule a task. + **/ + schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, Call]>; + /** + * Anonymously schedule a task after a delay. + **/ + scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, Call]>; + /** + * Schedule a named task. + **/ + scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u32, Option>, u8, Call]>; + /** + * Schedule a named task after a delay. + **/ + scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [U8aFixed, u32, Option>, u8, Call]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + session: { + /** + * Removes any session key(s) of the function caller. + * + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be Signed and the account must be either be + * convertible to a validator ID using the chain's typical addressing system (this usually + * means being a controller account) or directly convertible into a validator ID (which + * usually means being a stash account). + * + * ## Complexity + * - `O(1)` in number of key types. Actual cost depends on the number of length of + * `T::Keys::key_ids()` which is fixed. + **/ + purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Sets the session key(s) of the function caller to `keys`. + * Allows an account to set its session key prior to becoming a validator. + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be signed. + * + * ## Complexity + * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is + * fixed. + **/ + setKeys: AugmentedSubmittable<(keys: SugarfungeRuntimeOpaqueSessionKeys | { aura?: any; grandpa?: any; imOnline?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic, [SugarfungeRuntimeOpaqueSessionKeys, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + sudo: { + /** + * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo + * key. + * + * The dispatch origin for this call must be _Signed_. + * + * ## Complexity + * - O(1). + **/ + setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + * + * The dispatch origin for this call must be _Signed_. + * + * ## Complexity + * - O(1). + **/ + sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [Call]>; + /** + * Authenticates the sudo key and dispatches a function call with `Signed` origin from + * a given account. + * + * The dispatch origin for this call must be _Signed_. + * + * ## Complexity + * - O(1). + **/ + sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Call]>; + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + * This function does not check the weight of the call, and instead allows the + * Sudo user to specify the weight of the call. + * + * The dispatch origin for this call must be _Signed_. + * + * ## Complexity + * - O(1). + **/ + sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic, [Call, SpWeightsWeightV2Weight]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + system: { + /** + * Kill all storage items with a key that starts with the given prefix. + * + * **NOTE:** We rely on the Root origin to provide us the number of subkeys under + * the prefix we are removing to accurately calculate the weight of this function. + **/ + killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + /** + * Kill some items from storage. + **/ + killStorage: AugmentedSubmittable<(keys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Make some on-chain remark. + * + * - `O(1)` + **/ + remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Make some on-chain remark and emit event. + **/ + remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code. + **/ + setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code without doing any checks of the given `code`. + **/ + setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the number of pages in the WebAssembly environment's heap. + **/ + setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Set some items of storage. + **/ + setStorage: AugmentedSubmittable<(items: Vec> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + timestamp: { + /** + * Set the current time. + * + * This call should be invoked exactly once per block. It will panic at the finalization + * phase, if this call hasn't been invoked by that time. + * + * The timestamp should be greater than the previous one by the amount specified by + * `MinimumPeriod`. + * + * The dispatch origin for this call must be `Inherent`. + * + * ## Complexity + * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) + * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in + * `on_finalize`) + * - 1 event handler `on_timestamp_set`. Must be `O(1)`. + **/ + set: AugmentedSubmittable<(now: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + utility: { + /** + * Send a call through an indexed pseudonym of the sender. + * + * Filter from origin are passed along. The call will be dispatched with an origin which + * use the same filter as the origin of this call. + * + * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. + * because you expect `proxy` to have been used prior in the call stack and you do not want + * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` + * in the Multisig pallet instead. + * + * NOTE: Prior to version *12, this was called `as_limited_sub`. + * + * The dispatch origin for this call must be _Signed_. + **/ + asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [u16, Call]>; + /** + * Send a batch of dispatch calls. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + * + * This will return `Ok` in all circumstances. To determine the success of the batch, an + * event is deposited. If a call failed and the batch was interrupted, then the + * `BatchInterrupted` event is deposited, along with the number of successful calls made + * and the error of the failed call. If all were successful, then the `BatchCompleted` + * event is deposited. + **/ + batch: AugmentedSubmittable<(calls: Vec | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Send a batch of dispatch calls and atomically execute them. + * The whole transaction will rollback and fail if any of the calls failed. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + **/ + batchAll: AugmentedSubmittable<(calls: Vec | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Dispatches a function call with a provided origin. + * + * The dispatch origin for this call must be _Root_. + * + * ## Complexity + * - O(1). + **/ + dispatchAs: AugmentedSubmittable<(asOrigin: SugarfungeRuntimeOriginCaller | { system: any } | { Void: any } | { Council: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic, [SugarfungeRuntimeOriginCaller, Call]>; + /** + * Send a batch of dispatch calls. + * Unlike `batch`, it allows errors and won't interrupt. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatch without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + **/ + forceBatch: AugmentedSubmittable<(calls: Vec | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Dispatch a function call with a specified weight. + * + * This function does not check the weight of the call, and instead allows the + * Root origin to specify the weight of the call. + * + * The dispatch origin for this call must be _Root_. + **/ + withWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic, [Call, SpWeightsWeightV2Weight]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + validatorSet: { + /** + * Add a new validator. + * + * New validator's session keys should be set in Session pallet before + * calling this. + * + * The origin can be configured using the `AddRemoveOrigin` type in the + * host runtime. Can also be set to sudo/root. + **/ + addValidator: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Add an approved validator again when it comes back online. + * + * For this call, the dispatch origin must be the validator itself. + **/ + addValidatorAgain: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Remove a validator. + * + * The origin can be configured using the `AddRemoveOrigin` type in the + * host runtime. Can also be set to sudo/root. + **/ + removeValidator: AugmentedSubmittable<(validatorId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + } // AugmentedSubmittables +} // declare module diff --git a/src/interfaces/augment-types.ts b/src/interfaces/augment-types.ts index 5bfea32..5b77684 100644 --- a/src/interfaces/augment-types.ts +++ b/src/interfaces/augment-types.ts @@ -7,6 +7,7 @@ import '@polkadot/types/types/registry'; import type { Data, StorageKey } from '@polkadot/types'; import type { BitVec, Bool, Bytes, F32, F64, I128, I16, I256, I32, I64, I8, ISize, Json, Null, OptionBool, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, f32, f64, i128, i16, i256, i32, i64, i8, isize, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec'; +import type { TAssetConversion } from '@polkadot/types/interfaces/assetConversion'; import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets'; import type { BlockAttestations, IncludedBlocks, MoreAttestations } from '@polkadot/types/interfaces/attestations'; import type { RawAuraPreDigest } from '@polkadot/types/interfaces/aura'; @@ -14,7 +15,7 @@ import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interface import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship'; import type { AllowedSlots, BabeAuthorityWeight, BabeBlockWeight, BabeEpochConfiguration, BabeEquivocationProof, BabeGenesisConfiguration, BabeGenesisConfigurationV1, BabeWeight, Epoch, EpochAuthorship, MaybeRandomness, MaybeVrf, NextConfigDescriptor, NextConfigDescriptorV1, OpaqueKeyOwnershipProof, Randomness, RawBabePreDigest, RawBabePreDigestCompat, RawBabePreDigestPrimary, RawBabePreDigestPrimaryTo159, RawBabePreDigestSecondaryPlain, RawBabePreDigestSecondaryTo159, RawBabePreDigestSecondaryVRF, RawBabePreDigestTo159, SlotNumber, VrfData, VrfOutput, VrfProof } from '@polkadot/types/interfaces/babe'; import type { AccountData, BalanceLock, BalanceLockTo212, BalanceStatus, Reasons, ReserveData, ReserveIdentifier, VestingSchedule, WithdrawReasons } from '@polkadot/types/interfaces/balances'; -import type { BeefyAuthoritySet, BeefyCommitment, BeefyEquivocationProof, BeefyId, BeefyNextAuthoritySet, BeefyPayload, BeefyPayloadId, BeefySignedCommitment, BeefyVoteMessage, MmrRootHash, ValidatorSet, ValidatorSetId } from '@polkadot/types/interfaces/beefy'; +import type { BeefyAuthoritySet, BeefyCommitment, BeefyCompactSignedCommitment, BeefyEquivocationProof, BeefyId, BeefyNextAuthoritySet, BeefyPayload, BeefyPayloadId, BeefySignedCommitment, BeefyVersionedFinalityProof, BeefyVoteMessage, MmrRootHash, ValidatorSet, ValidatorSetId } from '@polkadot/types/interfaces/beefy'; import type { BenchmarkBatch, BenchmarkConfig, BenchmarkList, BenchmarkMetadata, BenchmarkParameter, BenchmarkResult } from '@polkadot/types/interfaces/benchmark'; import type { CheckInherentsResult, InherentData, InherentIdentifier } from '@polkadot/types/interfaces/blockbuilder'; import type { BridgeMessageId, BridgedBlockHash, BridgedBlockNumber, BridgedHeader, CallOrigin, ChainId, DeliveredMessages, DispatchFeePayment, InboundLaneData, InboundRelayer, InitializationData, LaneId, MessageData, MessageKey, MessageNonce, MessagesDeliveryProofOf, MessagesProofOf, OperatingMode, OutboundLaneData, OutboundMessageFee, OutboundPayload, Parameter, RelayerId, UnrewardedRelayer, UnrewardedRelayersState } from '@polkadot/types/interfaces/bridges'; @@ -24,43 +25,47 @@ import type { StatementKind } from '@polkadot/types/interfaces/claims'; import type { CollectiveOrigin, MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective'; import type { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus'; import type { AliveContractInfo, CodeHash, CodeSource, CodeUploadRequest, CodeUploadResult, CodeUploadResultValue, ContractCallFlags, ContractCallRequest, ContractExecResult, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractExecResultU64, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractInstantiateResultTo299, ContractInstantiateResultU64, ContractReturnFlags, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateRequestV1, InstantiateRequestV2, InstantiateReturnValue, InstantiateReturnValueOk, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, StorageDeposit, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts'; -import type { ContractConstructorSpecLatest, ContractConstructorSpecV0, ContractConstructorSpecV1, ContractConstructorSpecV2, ContractConstructorSpecV3, ContractConstructorSpecV4, ContractContractSpecV0, ContractContractSpecV1, ContractContractSpecV2, ContractContractSpecV3, ContractContractSpecV4, ContractCryptoHasher, ContractDiscriminant, ContractDisplayName, ContractEnvironmentV4, ContractEventParamSpecLatest, ContractEventParamSpecV0, ContractEventParamSpecV2, ContractEventSpecLatest, ContractEventSpecV0, ContractEventSpecV1, ContractEventSpecV2, ContractLayoutArray, ContractLayoutCell, ContractLayoutEnum, ContractLayoutHash, ContractLayoutHashingStrategy, ContractLayoutKey, ContractLayoutStruct, ContractLayoutStructField, ContractMessageParamSpecLatest, ContractMessageParamSpecV0, ContractMessageParamSpecV2, ContractMessageSpecLatest, ContractMessageSpecV0, ContractMessageSpecV1, ContractMessageSpecV2, ContractMessageSpecV3, ContractMetadata, ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1, ContractMetadataV2, ContractMetadataV3, ContractMetadataV4, ContractProject, ContractProjectContract, ContractProjectInfo, ContractProjectSource, ContractProjectV0, ContractSelector, ContractStorageLayout, ContractTypeSpec } from '@polkadot/types/interfaces/contractsAbi'; +import type { ContractConstructorSpecLatest, ContractConstructorSpecV0, ContractConstructorSpecV1, ContractConstructorSpecV2, ContractConstructorSpecV3, ContractConstructorSpecV4, ContractContractSpecV0, ContractContractSpecV1, ContractContractSpecV2, ContractContractSpecV3, ContractContractSpecV4, ContractContractSpecV5, ContractCryptoHasher, ContractDiscriminant, ContractDisplayName, ContractEnvironmentV4, ContractEventParamSpecLatest, ContractEventParamSpecV0, ContractEventParamSpecV2, ContractEventSpecLatest, ContractEventSpecV0, ContractEventSpecV1, ContractEventSpecV2, ContractEventSpecV3, ContractLayoutArray, ContractLayoutCell, ContractLayoutEnum, ContractLayoutHash, ContractLayoutHashingStrategy, ContractLayoutKey, ContractLayoutStruct, ContractLayoutStructField, ContractMessageParamSpecLatest, ContractMessageParamSpecV0, ContractMessageParamSpecV2, ContractMessageSpecLatest, ContractMessageSpecV0, ContractMessageSpecV1, ContractMessageSpecV2, ContractMessageSpecV3, ContractMetadata, ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1, ContractMetadataV2, ContractMetadataV3, ContractMetadataV4, ContractMetadataV5, ContractProject, ContractProjectContract, ContractProjectInfo, ContractProjectSource, ContractProjectV0, ContractSelector, ContractStorageLayout, ContractTypeSpec } from '@polkadot/types/interfaces/contractsAbi'; import type { FundIndex, FundInfo, LastContribution, TrieIndex } from '@polkadot/types/interfaces/crowdloan'; import type { CollationInfo, CollationInfoV1, ConfigData, MessageId, OverweightIndex, PageCounter, PageIndexData } from '@polkadot/types/interfaces/cumulus'; import type { AccountVote, AccountVoteSplit, AccountVoteStandard, Conviction, Delegations, PreimageStatus, PreimageStatusAvailable, PriorLock, PropIndex, Proposal, ProxyState, ReferendumIndex, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, ReferendumStatus, Tally, Voting, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces/democracy'; import type { BlockStats } from '@polkadot/types/interfaces/dev'; +import type { CallDryRunEffects, DispatchResultWithPostInfo, PostDispatchInfo, XcmDryRunApiError, XcmDryRunEffects } from '@polkadot/types/interfaces/dryRunApi'; import type { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex, VoteThreshold, VoterInfo } from '@polkadot/types/interfaces/elections'; import type { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine'; import type { BlockV0, BlockV1, BlockV2, EIP1559Transaction, EIP2930Transaction, EthAccessList, EthAccessListItem, EthAccount, EthAddress, EthBlock, EthBloom, EthCallRequest, EthFeeHistory, EthFilter, EthFilterAddress, EthFilterChanges, EthFilterTopic, EthFilterTopicEntry, EthFilterTopicInner, EthHeader, EthLog, EthReceipt, EthReceiptV0, EthReceiptV3, EthRichBlock, EthRichHeader, EthStorageProof, EthSubKind, EthSubParams, EthSubResult, EthSyncInfo, EthSyncStatus, EthTransaction, EthTransactionAction, EthTransactionCondition, EthTransactionRequest, EthTransactionSignature, EthTransactionStatus, EthWork, EthereumAccountId, EthereumAddress, EthereumLookupSource, EthereumSignature, LegacyTransaction, TransactionV0, TransactionV1, TransactionV2 } from '@polkadot/types/interfaces/eth'; import type { EvmAccount, EvmCallInfo, EvmCallInfoV2, EvmCreateInfo, EvmCreateInfoV2, EvmLog, EvmVicinity, EvmWeightInfo, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed } from '@polkadot/types/interfaces/evm'; -import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics'; +import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicPayloadV5, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicSignatureV5, ExtrinsicUnknown, ExtrinsicV4, ExtrinsicV5, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics'; import type { FungiblesAccessError } from '@polkadot/types/interfaces/fungibles'; import type { AssetOptions, Owner, PermissionLatest, PermissionVersions, PermissionsV1 } from '@polkadot/types/interfaces/genericAsset'; +import type { GenesisBuildErr } from '@polkadot/types/interfaces/genesisBuilder'; import type { ActiveGilt, ActiveGiltsTotal, ActiveIndex, GiltBid } from '@polkadot/types/interfaces/gilt'; import type { AuthorityIndex, AuthorityList, AuthoritySet, AuthoritySetChange, AuthoritySetChanges, AuthorityWeight, DelayKind, DelayKindBest, EncodedFinalityProofs, ForkTreePendingChange, ForkTreePendingChangeNode, GrandpaCommit, GrandpaEquivocation, GrandpaEquivocationProof, GrandpaEquivocationValue, GrandpaJustification, GrandpaPrecommit, GrandpaPrevote, GrandpaSignedPrecommit, JustificationNotification, KeyOwnerProof, NextAuthority, PendingChange, PendingPause, PendingResume, Precommits, Prevotes, ReportedRoundStates, RoundState, SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa'; import type { IdentityFields, IdentityInfo, IdentityInfoAdditional, IdentityInfoTo198, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement, RegistrationTo198 } from '@polkadot/types/interfaces/identity'; import type { AuthIndex, AuthoritySignature, Heartbeat, HeartbeatTo244, OpaqueMultiaddr, OpaqueNetworkState, OpaquePeerId } from '@polkadot/types/interfaces/imOnline'; import type { CallIndex, LotteryConfig } from '@polkadot/types/interfaces/lottery'; import type { CustomMetadata15, CustomValueMetadata15, ErrorMetadataLatest, ErrorMetadataV10, ErrorMetadataV11, ErrorMetadataV12, ErrorMetadataV13, ErrorMetadataV14, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV14, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, ExtrinsicMetadataV15, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV14, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, FunctionMetadataV14, FunctionMetadataV9, MetadataAll, MetadataLatest, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV15, MetadataV9, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV12, ModuleConstantMetadataV13, ModuleConstantMetadataV9, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV12, ModuleMetadataV13, ModuleMetadataV9, OpaqueMetadata, OuterEnums15, PalletCallMetadataLatest, PalletCallMetadataV14, PalletConstantMetadataLatest, PalletConstantMetadataV14, PalletErrorMetadataLatest, PalletErrorMetadataV14, PalletEventMetadataLatest, PalletEventMetadataV14, PalletMetadataLatest, PalletMetadataV14, PalletMetadataV15, PalletStorageMetadataLatest, PalletStorageMetadataV14, PortableType, PortableTypeV14, RuntimeApiMetadataLatest, RuntimeApiMetadataV15, RuntimeApiMethodMetadataV15, RuntimeApiMethodParamMetadataV15, SignedExtensionMetadataLatest, SignedExtensionMetadataV14, StorageEntryMetadataLatest, StorageEntryMetadataV10, StorageEntryMetadataV11, StorageEntryMetadataV12, StorageEntryMetadataV13, StorageEntryMetadataV14, StorageEntryMetadataV9, StorageEntryModifierLatest, StorageEntryModifierV10, StorageEntryModifierV11, StorageEntryModifierV12, StorageEntryModifierV13, StorageEntryModifierV14, StorageEntryModifierV9, StorageEntryTypeLatest, StorageEntryTypeV10, StorageEntryTypeV11, StorageEntryTypeV12, StorageEntryTypeV13, StorageEntryTypeV14, StorageEntryTypeV9, StorageHasher, StorageHasherV10, StorageHasherV11, StorageHasherV12, StorageHasherV13, StorageHasherV14, StorageHasherV9, StorageMetadataV10, StorageMetadataV11, StorageMetadataV12, StorageMetadataV13, StorageMetadataV9 } from '@polkadot/types/interfaces/metadata'; +import type { Mixnode, MixnodesErr, SessionPhase, SessionStatus } from '@polkadot/types/interfaces/mixnet'; import type { MmrBatchProof, MmrEncodableOpaqueLeaf, MmrError, MmrHash, MmrLeafBatchProof, MmrLeafIndex, MmrLeafProof, MmrNodeIndex, MmrProof } from '@polkadot/types/interfaces/mmr'; import type { NftCollectionId, NftItemId } from '@polkadot/types/interfaces/nfts'; import type { NpApiError, NpPoolId } from '@polkadot/types/interfaces/nompools'; import type { StorageKind } from '@polkadot/types/interfaces/offchain'; import type { DeferredOffenceOf, Kind, OffenceDetails, Offender, OpaqueTimeSlot, ReportIdOf, Reporter } from '@polkadot/types/interfaces/offences'; -import type { AbridgedCandidateReceipt, AbridgedHostConfiguration, AbridgedHrmpChannel, AssignmentId, AssignmentKind, AttestedCandidate, AuctionIndex, AuthorityDiscoveryId, AvailabilityBitfield, AvailabilityBitfieldRecord, BackedCandidate, Bidder, BufferedSessionChange, CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateInfo, CandidatePendingAvailability, CandidateReceipt, CollatorId, CollatorSignature, CommittedCandidateReceipt, CoreAssignment, CoreIndex, CoreOccupied, CoreState, DisputeLocation, DisputeProof, DisputeResult, DisputeState, DisputeStatement, DisputeStatementSet, DisputesTimeSlot, DoubleVoteReport, DownwardMessage, ExecutorParam, ExecutorParams, ExecutorParamsHash, ExplicitDisputeStatement, GlobalValidationData, GlobalValidationSchedule, GroupIndex, GroupRotationInfo, HeadData, HostConfiguration, HrmpChannel, HrmpChannelId, HrmpOpenChannelRequest, InboundDownwardMessage, InboundHrmpMessage, InboundHrmpMessages, IncomingParachain, IncomingParachainDeploy, IncomingParachainFixed, InvalidDisputeStatementKind, LeasePeriod, LeasePeriodOf, LocalValidationData, MessageIngestionType, MessageQueueChain, MessagingStateSnapshot, MessagingStateSnapshotEgressEntry, MultiDisputeStatementSet, NewBidder, OccupiedCore, OccupiedCoreAssumption, OldV1SessionInfo, OutboundHrmpMessage, ParaGenesisArgs, ParaId, ParaInfo, ParaLifecycle, ParaPastCodeMeta, ParaScheduling, ParaValidatorIndex, ParachainDispatchOrigin, ParachainInherentData, ParachainProposal, ParachainsInherentData, ParathreadClaim, ParathreadClaimQueue, ParathreadEntry, PendingSlashes, PersistedValidationData, PvfCheckStatement, PvfExecTimeoutKind, PvfPrepTimeoutKind, QueuedParathread, RegisteredParachainInfo, RelayBlockNumber, RelayChainBlockNumber, RelayChainHash, RelayHash, Remark, ReplacementTimes, Retriable, ScheduledCore, Scheduling, ScrapedOnChainVotes, ServiceQuality, SessionInfo, SessionInfoValidatorGroup, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SigningContext, SlashingOffenceKind, SlotRange, SlotRange10, Statement, SubId, SystemInherentData, TransientValidationData, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidationData, ValidationDataType, ValidationFunctionParams, ValidatorSignature, ValidityAttestation, VecInboundHrmpMessage, WinnersData, WinnersData10, WinnersDataTuple, WinnersDataTuple10, WinningData, WinningData10, WinningDataEntry } from '@polkadot/types/interfaces/parachains'; +import type { AbridgedCandidateReceipt, AbridgedHostConfiguration, AbridgedHrmpChannel, ApprovalVotingParams, AssignmentId, AssignmentKind, AsyncBackingParams, AttestedCandidate, AuctionIndex, AuthorityDiscoveryId, AvailabilityBitfield, AvailabilityBitfieldRecord, BackedCandidate, BackingState, Bidder, BufferedSessionChange, CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateInfo, CandidatePendingAvailability, CandidateReceipt, CollatorId, CollatorSignature, CommittedCandidateReceipt, Constraints, CoreAssignment, CoreIndex, CoreOccupied, CoreState, DisputeLocation, DisputeProof, DisputeResult, DisputeState, DisputeStatement, DisputeStatementSet, DisputesTimeSlot, DoubleVoteReport, DownwardMessage, ExecutorParam, ExecutorParams, ExecutorParamsHash, ExplicitDisputeStatement, GlobalValidationData, GlobalValidationSchedule, GroupIndex, GroupRotationInfo, HeadData, HostConfiguration, HrmpChannel, HrmpChannelId, HrmpOpenChannelRequest, InboundDownwardMessage, InboundHrmpLimitations, InboundHrmpMessage, InboundHrmpMessages, IncomingParachain, IncomingParachainDeploy, IncomingParachainFixed, InvalidDisputeStatementKind, LeasePeriod, LeasePeriodOf, LocalValidationData, MessageIngestionType, MessageQueueChain, MessagingStateSnapshot, MessagingStateSnapshotEgressEntry, MultiDisputeStatementSet, NewBidder, NodeFeatures, OccupiedCore, OccupiedCoreAssumption, OldV1SessionInfo, OutboundHrmpChannelLimitations, OutboundHrmpMessage, ParaGenesisArgs, ParaId, ParaInfo, ParaLifecycle, ParaPastCodeMeta, ParaScheduling, ParaValidatorIndex, ParachainDispatchOrigin, ParachainInherentData, ParachainProposal, ParachainsInherentData, ParathreadClaim, ParathreadClaimQueue, ParathreadEntry, PendingSlashes, PersistedValidationData, PvfCheckStatement, PvfExecTimeoutKind, PvfPrepTimeoutKind, QueuedParathread, RegisteredParachainInfo, RelayBlockNumber, RelayChainBlockNumber, RelayChainHash, RelayHash, Remark, ReplacementTimes, Retriable, ScheduledCore, Scheduling, ScrapedOnChainVotes, ServiceQuality, SessionInfo, SessionInfoValidatorGroup, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SigningContext, SlashingOffenceKind, SlotRange, SlotRange10, Statement, SubId, SystemInherentData, TransientValidationData, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidationData, ValidationDataType, ValidationFunctionParams, ValidatorSignature, ValidityAttestation, VecInboundHrmpMessage, WinnersData, WinnersData10, WinnersDataTuple, WinnersDataTuple10, WinningData, WinningData10, WinningDataEntry } from '@polkadot/types/interfaces/parachains'; import type { FeeDetails, InclusionFee, RuntimeDispatchInfo, RuntimeDispatchInfoV1, RuntimeDispatchInfoV2 } from '@polkadot/types/interfaces/payment'; import type { Approvals } from '@polkadot/types/interfaces/poll'; import type { ProxyAnnouncement, ProxyDefinition, ProxyType } from '@polkadot/types/interfaces/proxy'; import type { AccountStatus, AccountValidity } from '@polkadot/types/interfaces/purchase'; import type { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery'; import type { RpcMethods } from '@polkadot/types/interfaces/rpc'; -import type { AccountId, AccountId20, AccountId32, AccountId33, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, BlockNumberFor, BlockNumberOf, Call, CallHash, CallHashOf, ChangesTrieConfiguration, ChangesTrieSignal, CodecHash, Consensus, ConsensusEngineId, CrateVersion, Digest, DigestItem, EncodedJustification, ExtrinsicsWeight, Fixed128, Fixed64, FixedI128, FixedI64, FixedU128, FixedU64, H1024, H128, H160, H2048, H256, H32, H512, H64, Hash, Header, HeaderPartial, I32F32, Index, IndicesLookupSource, Justification, Justifications, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, ModuleId, Moment, MultiAddress, MultiSigner, OpaqueCall, Origin, OriginCaller, PalletId, PalletVersion, PalletsOrigin, Pays, PerU16, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, Releases, RuntimeCall, RuntimeDbWeight, RuntimeEvent, Seal, SealV0, SignedBlock, SignedBlockWithJustification, SignedBlockWithJustifications, Slot, SlotDuration, StorageData, StorageInfo, StorageProof, TransactionInfo, TransactionLongevity, TransactionPriority, TransactionStorageProof, TransactionTag, U32F32, ValidatorId, ValidatorIdOf, Weight, WeightMultiplier, WeightV0, WeightV1, WeightV2 } from '@polkadot/types/interfaces/runtime'; +import type { AccountId, AccountId20, AccountId32, AccountId33, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, BlockNumberFor, BlockNumberOf, Call, CallHash, CallHashOf, ChangesTrieConfiguration, ChangesTrieSignal, CodecHash, Consensus, ConsensusEngineId, CrateVersion, Digest, DigestItem, EncodedJustification, ExtrinsicInclusionMode, ExtrinsicsWeight, Fixed128, Fixed64, FixedI128, FixedI64, FixedU128, FixedU64, H1024, H128, H160, H2048, H256, H32, H512, H64, Hash, Header, HeaderPartial, I32F32, Index, IndicesLookupSource, Justification, Justifications, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, ModuleId, Moment, MultiAddress, MultiSigner, OpaqueCall, Origin, OriginCaller, PalletId, PalletVersion, PalletsOrigin, Pays, PerU16, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, Releases, RuntimeCall, RuntimeDbWeight, RuntimeEvent, Seal, SealV0, SignedBlock, SignedBlockWithJustification, SignedBlockWithJustifications, Slot, SlotDuration, StorageData, StorageInfo, StorageProof, TransactionInfo, TransactionLongevity, TransactionPriority, TransactionStorageProof, TransactionTag, U32F32, ValidatorId, ValidatorIdOf, Weight, WeightMultiplier, WeightV0, WeightV1, WeightV2 } from '@polkadot/types/interfaces/runtime'; import type { Si0Field, Si0LookupTypeId, Si0Path, Si0Type, Si0TypeDef, Si0TypeDefArray, Si0TypeDefBitSequence, Si0TypeDefCompact, Si0TypeDefComposite, Si0TypeDefPhantom, Si0TypeDefPrimitive, Si0TypeDefSequence, Si0TypeDefTuple, Si0TypeDefVariant, Si0TypeParameter, Si0Variant, Si1Field, Si1LookupTypeId, Si1Path, Si1Type, Si1TypeDef, Si1TypeDefArray, Si1TypeDefBitSequence, Si1TypeDefCompact, Si1TypeDefComposite, Si1TypeDefPrimitive, Si1TypeDefSequence, Si1TypeDefTuple, Si1TypeDefVariant, Si1TypeParameter, Si1Variant, SiField, SiLookupTypeId, SiPath, SiType, SiTypeDef, SiTypeDefArray, SiTypeDefBitSequence, SiTypeDefCompact, SiTypeDefComposite, SiTypeDefPrimitive, SiTypeDefSequence, SiTypeDefTuple, SiTypeDefVariant, SiTypeParameter, SiVariant } from '@polkadot/types/interfaces/scaleInfo'; import type { Period, Priority, SchedulePeriod, SchedulePriority, Scheduled, ScheduledTo254, TaskAddress } from '@polkadot/types/interfaces/scheduler'; import type { BeefyKey, FullIdentification, IdentificationTuple, Keys, MembershipProof, SessionIndex, SessionKeys1, SessionKeys10, SessionKeys10B, SessionKeys2, SessionKeys3, SessionKeys4, SessionKeys5, SessionKeys6, SessionKeys6B, SessionKeys7, SessionKeys7B, SessionKeys8, SessionKeys8B, SessionKeys9, SessionKeys9B, ValidatorCount } from '@polkadot/types/interfaces/session'; import type { Bid, BidKind, SocietyJudgement, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society'; import type { ActiveEraInfo, CompactAssignments, CompactAssignmentsTo257, CompactAssignmentsTo265, CompactAssignmentsWith16, CompactAssignmentsWith24, CompactScore, CompactScoreCompact, ElectionCompute, ElectionPhase, ElectionResult, ElectionScore, ElectionSize, ElectionStatus, EraIndex, EraPoints, EraRewardPoints, EraRewards, Exposure, ExtendedBalance, Forcing, IndividualExposure, KeyType, MomentOf, Nominations, NominatorIndex, NominatorIndexCompact, OffchainAccuracy, OffchainAccuracyCompact, PhragmenScore, Points, RawSolution, RawSolutionTo265, RawSolutionWith16, RawSolutionWith24, ReadySolution, RewardDestination, RewardPoint, RoundSnapshot, SeatHolder, SignedSubmission, SignedSubmissionOf, SignedSubmissionTo276, SlashJournalEntry, SlashingSpans, SlashingSpansTo204, SolutionOrSnapshotSize, SolutionSupport, SolutionSupports, SpanIndex, SpanRecord, StakingLedger, StakingLedgerTo223, StakingLedgerTo240, SubmissionIndicesOf, Supports, UnappliedSlash, UnappliedSlashOther, UnlockChunk, ValidatorIndex, ValidatorIndexCompact, ValidatorPrefs, ValidatorPrefsTo145, ValidatorPrefsTo196, ValidatorPrefsWithBlocked, ValidatorPrefsWithCommission, VoteWeight, Voter } from '@polkadot/types/interfaces/staking'; import type { ApiId, BlockTrace, BlockTraceEvent, BlockTraceEventData, BlockTraceSpan, KeyValueOption, MigrationStatusResult, ReadProof, RuntimeVersion, RuntimeVersionApi, RuntimeVersionPartial, RuntimeVersionPre3, RuntimeVersionPre4, SpecVersion, StorageChangeSet, TraceBlockResponse, TraceError } from '@polkadot/types/interfaces/state'; +import type { StatementStoreInvalidStatement, StatementStoreStatementSource, StatementStoreValidStatement } from '@polkadot/types/interfaces/statement'; import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support'; import type { AccountInfo, AccountInfoWithDualRefCount, AccountInfoWithProviders, AccountInfoWithRefCount, AccountInfoWithRefCountU8, AccountInfoWithTripleRefCount, ApplyExtrinsicResult, ApplyExtrinsicResultPre6, ArithmeticError, BlockLength, BlockWeights, ChainProperties, ChainType, ConsumedWeight, DigestOf, DispatchClass, DispatchError, DispatchErrorModule, DispatchErrorModulePre6, DispatchErrorModuleU8, DispatchErrorModuleU8a, DispatchErrorPre6, DispatchErrorPre6First, DispatchErrorTo198, DispatchInfo, DispatchInfoTo190, DispatchInfoTo244, DispatchOutcome, DispatchOutcomePre6, DispatchResult, DispatchResultOf, DispatchResultTo198, Event, EventId, EventIndex, EventRecord, Health, InvalidTransaction, Key, LastRuntimeUpgradeInfo, NetworkState, NetworkStatePeerset, NetworkStatePeersetInfo, NodeRole, NotConnectedPeer, Peer, PeerEndpoint, PeerEndpointAddr, PeerInfo, PeerPing, PerDispatchClassU32, PerDispatchClassWeight, PerDispatchClassWeightsPerClass, Phase, RawOrigin, RefCount, RefCountTo259, SyncState, SystemOrigin, TokenError, TransactionValidityError, TransactionalError, UnknownTransaction, WeightPerClass } from '@polkadot/types/interfaces/system'; import type { Bounty, BountyIndex, BountyStatus, BountyStatusActive, BountyStatusCuratorProposed, BountyStatusPendingPayout, OpenTip, OpenTipFinderTo225, OpenTipTip, OpenTipTo225, TreasuryProposal } from '@polkadot/types/interfaces/treasury'; @@ -69,7 +74,9 @@ import type { TransactionSource, TransactionValidity, ValidTransaction } from '@ import type { ClassDetails, ClassId, ClassMetadata, DepositBalance, DepositBalanceOf, DestroyWitness, InstanceDetails, InstanceId, InstanceMetadata } from '@polkadot/types/interfaces/uniques'; import type { Multisig, Timepoint } from '@polkadot/types/interfaces/utility'; import type { VestingInfo } from '@polkadot/types/interfaces/vesting'; -import type { AssetInstance, AssetInstanceV0, AssetInstanceV1, AssetInstanceV2, BodyId, BodyPart, DoubleEncodedCall, Fungibility, FungibilityV0, FungibilityV1, FungibilityV2, InboundStatus, InstructionV2, InteriorMultiLocation, Junction, JunctionV0, JunctionV1, JunctionV2, Junctions, JunctionsV1, JunctionsV2, MultiAsset, MultiAssetFilter, MultiAssetFilterV1, MultiAssetFilterV2, MultiAssetV0, MultiAssetV1, MultiAssetV2, MultiAssets, MultiAssetsV1, MultiAssetsV2, MultiLocation, MultiLocationV0, MultiLocationV1, MultiLocationV2, NetworkId, OriginKindV0, OriginKindV1, OriginKindV2, OutboundStatus, Outcome, QueryId, QueryStatus, QueueConfigData, Response, ResponseV0, ResponseV1, ResponseV2, ResponseV2Error, ResponseV2Result, VersionMigrationStage, VersionedMultiAsset, VersionedMultiAssets, VersionedMultiLocation, VersionedResponse, VersionedXcm, WeightLimitV2, WildFungibility, WildFungibilityV0, WildFungibilityV1, WildFungibilityV2, WildMultiAsset, WildMultiAssetV1, WildMultiAssetV2, Xcm, XcmAssetId, XcmError, XcmErrorV0, XcmErrorV1, XcmErrorV2, XcmOrder, XcmOrderV0, XcmOrderV1, XcmOrderV2, XcmOrigin, XcmOriginKind, XcmV0, XcmV1, XcmV2, XcmVersion, XcmpMessageFormat } from '@polkadot/types/interfaces/xcm'; +import type { AssetIdV2, AssetIdV3, AssetIdV4, AssetInstance, AssetInstanceV0, AssetInstanceV1, AssetInstanceV2, AssetInstanceV3, AssetInstanceV4, BodyId, BodyIdV2, BodyIdV3, BodyPart, BodyPartV2, BodyPartV3, DoubleEncodedCall, Fungibility, FungibilityV0, FungibilityV1, FungibilityV2, FungibilityV3, FungibilityV4, InboundStatus, InstructionV2, InstructionV3, InstructionV4, InteriorMultiLocation, InteriorMultiLocationV2, InteriorMultiLocationV3, Junction, JunctionV0, JunctionV1, JunctionV2, JunctionV3, JunctionV4, Junctions, JunctionsV1, JunctionsV2, JunctionsV3, JunctionsV4, MaxPalletNameLen, MaxPalletsInfo, MaybeErrorCodeV3, MultiAsset, MultiAssetFilter, MultiAssetFilterV1, MultiAssetFilterV2, MultiAssetFilterV3, MultiAssetFilterV4, MultiAssetV0, MultiAssetV1, MultiAssetV2, MultiAssetV3, MultiAssetV4, MultiAssets, MultiAssetsV1, MultiAssetsV2, MultiAssetsV3, MultiAssetsV4, MultiLocation, MultiLocationV0, MultiLocationV1, MultiLocationV2, MultiLocationV3, MultiLocationV4, NetworkId, NetworkIdV2, NetworkIdV3, NetworkIdV4, OriginKindV0, OriginKindV1, OriginKindV2, OriginKindV3, OriginKindV4, OutboundStatus, Outcome, OutcomeV4, PalletInfoV3, PalletInfoV4, QueryId, QueryResponseInfoV3, QueryResponseInfoV4, QueryStatus, QueueConfigData, Response, ResponseV0, ResponseV1, ResponseV2, ResponseV2Error, ResponseV3, ResponseV3Error, ResponseV3Result, ResponseV4, UncheckedFungibilityV4, VersionMigrationStage, VersionV3, VersionV4, VersionedMultiAsset, VersionedMultiAssets, VersionedMultiLocation, VersionedResponse, VersionedXcm, WeightLimitV2, WeightLimitV3, WildFungibility, WildFungibilityV0, WildFungibilityV1, WildFungibilityV2, WildFungibilityV3, WildFungibilityV4, WildMultiAsset, WildMultiAssetV1, WildMultiAssetV2, WildMultiAssetV3, WildMultiAssetV4, Xcm, XcmAssetId, XcmError, XcmErrorV0, XcmErrorV1, XcmErrorV2, XcmErrorV3, XcmErrorV4, XcmOrderV0, XcmOrderV1, XcmOrigin, XcmOriginKind, XcmV0, XcmV1, XcmV2, XcmV3, XcmV4, XcmVersion, XcmpMessageFormat } from '@polkadot/types/interfaces/xcm'; +import type { XcmPaymentApiError } from '@polkadot/types/interfaces/xcmPaymentApi'; +import type { Error } from '@polkadot/types/interfaces/xcmRuntimeApi'; declare module '@polkadot/types/types/registry' { interface InterfaceTypes { @@ -108,6 +115,7 @@ declare module '@polkadot/types/types/registry' { ApplyExtrinsicResultPre6: ApplyExtrinsicResultPre6; ApprovalFlag: ApprovalFlag; Approvals: Approvals; + ApprovalVotingParams: ApprovalVotingParams; ArithmeticError: ArithmeticError; AssetApproval: AssetApproval; AssetApprovalKey: AssetApprovalKey; @@ -115,14 +123,20 @@ declare module '@polkadot/types/types/registry' { AssetDestroyWitness: AssetDestroyWitness; AssetDetails: AssetDetails; AssetId: AssetId; + AssetIdV2: AssetIdV2; + AssetIdV3: AssetIdV3; + AssetIdV4: AssetIdV4; AssetInstance: AssetInstance; AssetInstanceV0: AssetInstanceV0; AssetInstanceV1: AssetInstanceV1; AssetInstanceV2: AssetInstanceV2; + AssetInstanceV3: AssetInstanceV3; + AssetInstanceV4: AssetInstanceV4; AssetMetadata: AssetMetadata; AssetOptions: AssetOptions; AssignmentId: AssignmentId; AssignmentKind: AssignmentKind; + AsyncBackingParams: AsyncBackingParams; AttestedCandidate: AttestedCandidate; AuctionIndex: AuctionIndex; AuthIndex: AuthIndex; @@ -145,6 +159,7 @@ declare module '@polkadot/types/types/registry' { BabeGenesisConfigurationV1: BabeGenesisConfigurationV1; BabeWeight: BabeWeight; BackedCandidate: BackedCandidate; + BackingState: BackingState; Balance: Balance; BalanceLock: BalanceLock; BalanceLockTo212: BalanceLockTo212; @@ -152,6 +167,7 @@ declare module '@polkadot/types/types/registry' { BalanceStatus: BalanceStatus; BeefyAuthoritySet: BeefyAuthoritySet; BeefyCommitment: BeefyCommitment; + BeefyCompactSignedCommitment: BeefyCompactSignedCommitment; BeefyEquivocationProof: BeefyEquivocationProof; BeefyId: BeefyId; BeefyKey: BeefyKey; @@ -159,6 +175,7 @@ declare module '@polkadot/types/types/registry' { BeefyPayload: BeefyPayload; BeefyPayloadId: BeefyPayloadId; BeefySignedCommitment: BeefySignedCommitment; + BeefyVersionedFinalityProof: BeefyVersionedFinalityProof; BeefyVoteMessage: BeefyVoteMessage; BenchmarkBatch: BenchmarkBatch; BenchmarkConfig: BenchmarkConfig; @@ -187,7 +204,11 @@ declare module '@polkadot/types/types/registry' { BlockV2: BlockV2; BlockWeights: BlockWeights; BodyId: BodyId; + BodyIdV2: BodyIdV2; + BodyIdV3: BodyIdV3; BodyPart: BodyPart; + BodyPartV2: BodyPartV2; + BodyPartV3: BodyPartV3; bool: bool; Bool: Bool; Bounty: Bounty; @@ -203,6 +224,7 @@ declare module '@polkadot/types/types/registry' { BufferedSessionChange: BufferedSessionChange; Bytes: Bytes; Call: Call; + CallDryRunEffects: CallDryRunEffects; CallHash: CallHash; CallHashOf: CallHashOf; CallIndex: CallIndex; @@ -245,6 +267,7 @@ declare module '@polkadot/types/types/registry' { ConfigData: ConfigData; Consensus: Consensus; ConsensusEngineId: ConsensusEngineId; + Constraints: Constraints; ConsumedWeight: ConsumedWeight; ContractCallFlags: ContractCallFlags; ContractCallRequest: ContractCallRequest; @@ -259,6 +282,7 @@ declare module '@polkadot/types/types/registry' { ContractContractSpecV2: ContractContractSpecV2; ContractContractSpecV3: ContractContractSpecV3; ContractContractSpecV4: ContractContractSpecV4; + ContractContractSpecV5: ContractContractSpecV5; ContractCryptoHasher: ContractCryptoHasher; ContractDiscriminant: ContractDiscriminant; ContractDisplayName: ContractDisplayName; @@ -270,6 +294,7 @@ declare module '@polkadot/types/types/registry' { ContractEventSpecV0: ContractEventSpecV0; ContractEventSpecV1: ContractEventSpecV1; ContractEventSpecV2: ContractEventSpecV2; + ContractEventSpecV3: ContractEventSpecV3; ContractExecResult: ContractExecResult; ContractExecResultOk: ContractExecResultOk; ContractExecResultResult: ContractExecResultResult; @@ -307,6 +332,7 @@ declare module '@polkadot/types/types/registry' { ContractMetadataV2: ContractMetadataV2; ContractMetadataV3: ContractMetadataV3; ContractMetadataV4: ContractMetadataV4; + ContractMetadataV5: ContractMetadataV5; ContractProject: ContractProject; ContractProjectContract: ContractProjectContract; ContractProjectInfo: ContractProjectInfo; @@ -358,6 +384,7 @@ declare module '@polkadot/types/types/registry' { DispatchResult: DispatchResult; DispatchResultOf: DispatchResultOf; DispatchResultTo198: DispatchResultTo198; + DispatchResultWithPostInfo: DispatchResultWithPostInfo; DisputeLocation: DisputeLocation; DisputeProof: DisputeProof; DisputeResult: DisputeResult; @@ -387,6 +414,7 @@ declare module '@polkadot/types/types/registry' { EraPoints: EraPoints; EraRewardPoints: EraRewardPoints; EraRewards: EraRewards; + Error: Error; ErrorMetadataLatest: ErrorMetadataLatest; ErrorMetadataV10: ErrorMetadataV10; ErrorMetadataV11: ErrorMetadataV11; @@ -465,6 +493,7 @@ declare module '@polkadot/types/types/registry' { ExtendedBalance: ExtendedBalance; Extrinsic: Extrinsic; ExtrinsicEra: ExtrinsicEra; + ExtrinsicInclusionMode: ExtrinsicInclusionMode; ExtrinsicMetadataLatest: ExtrinsicMetadataLatest; ExtrinsicMetadataV11: ExtrinsicMetadataV11; ExtrinsicMetadataV12: ExtrinsicMetadataV12; @@ -475,12 +504,15 @@ declare module '@polkadot/types/types/registry' { ExtrinsicPayload: ExtrinsicPayload; ExtrinsicPayloadUnknown: ExtrinsicPayloadUnknown; ExtrinsicPayloadV4: ExtrinsicPayloadV4; + ExtrinsicPayloadV5: ExtrinsicPayloadV5; ExtrinsicSignature: ExtrinsicSignature; ExtrinsicSignatureV4: ExtrinsicSignatureV4; + ExtrinsicSignatureV5: ExtrinsicSignatureV5; ExtrinsicStatus: ExtrinsicStatus; ExtrinsicsWeight: ExtrinsicsWeight; ExtrinsicUnknown: ExtrinsicUnknown; ExtrinsicV4: ExtrinsicV4; + ExtrinsicV5: ExtrinsicV5; f32: f32; F32: F32; f64: f64; @@ -516,8 +548,11 @@ declare module '@polkadot/types/types/registry' { FungibilityV0: FungibilityV0; FungibilityV1: FungibilityV1; FungibilityV2: FungibilityV2; + FungibilityV3: FungibilityV3; + FungibilityV4: FungibilityV4; FungiblesAccessError: FungiblesAccessError; Gas: Gas; + GenesisBuildErr: GenesisBuildErr; GiltBid: GiltBid; GlobalValidationData: GlobalValidationData; GlobalValidationSchedule: GlobalValidationSchedule; @@ -574,6 +609,7 @@ declare module '@polkadot/types/types/registry' { ImmortalEra: ImmortalEra; ImportedAux: ImportedAux; InboundDownwardMessage: InboundDownwardMessage; + InboundHrmpLimitations: InboundHrmpLimitations; InboundHrmpMessage: InboundHrmpMessage; InboundHrmpMessages: InboundHrmpMessages; InboundLaneData: InboundLaneData; @@ -600,8 +636,12 @@ declare module '@polkadot/types/types/registry' { InstantiateReturnValueOk: InstantiateReturnValueOk; InstantiateReturnValueTo267: InstantiateReturnValueTo267; InstructionV2: InstructionV2; + InstructionV3: InstructionV3; + InstructionV4: InstructionV4; InstructionWeights: InstructionWeights; InteriorMultiLocation: InteriorMultiLocation; + InteriorMultiLocationV2: InteriorMultiLocationV2; + InteriorMultiLocationV3: InteriorMultiLocationV3; InvalidDisputeStatementKind: InvalidDisputeStatementKind; InvalidTransaction: InvalidTransaction; isize: isize; @@ -611,9 +651,13 @@ declare module '@polkadot/types/types/registry' { Junctions: Junctions; JunctionsV1: JunctionsV1; JunctionsV2: JunctionsV2; + JunctionsV3: JunctionsV3; + JunctionsV4: JunctionsV4; JunctionV0: JunctionV0; JunctionV1: JunctionV1; JunctionV2: JunctionV2; + JunctionV3: JunctionV3; + JunctionV4: JunctionV4; Justification: Justification; JustificationNotification: JustificationNotification; Justifications: Justifications; @@ -638,6 +682,9 @@ declare module '@polkadot/types/types/registry' { LookupSource: LookupSource; LookupTarget: LookupTarget; LotteryConfig: LotteryConfig; + MaxPalletNameLen: MaxPalletNameLen; + MaxPalletsInfo: MaxPalletsInfo; + MaybeErrorCodeV3: MaybeErrorCodeV3; MaybeRandomness: MaybeRandomness; MaybeVrf: MaybeVrf; MemberCount: MemberCount; @@ -662,6 +709,8 @@ declare module '@polkadot/types/types/registry' { MetadataV15: MetadataV15; MetadataV9: MetadataV9; MigrationStatusResult: MigrationStatusResult; + Mixnode: Mixnode; + MixnodesErr: MixnodesErr; MmrBatchProof: MmrBatchProof; MmrEncodableOpaqueLeaf: MmrEncodableOpaqueLeaf; MmrError: MmrError; @@ -692,22 +741,33 @@ declare module '@polkadot/types/types/registry' { MultiAssetFilter: MultiAssetFilter; MultiAssetFilterV1: MultiAssetFilterV1; MultiAssetFilterV2: MultiAssetFilterV2; + MultiAssetFilterV3: MultiAssetFilterV3; + MultiAssetFilterV4: MultiAssetFilterV4; MultiAssets: MultiAssets; MultiAssetsV1: MultiAssetsV1; MultiAssetsV2: MultiAssetsV2; + MultiAssetsV3: MultiAssetsV3; + MultiAssetsV4: MultiAssetsV4; MultiAssetV0: MultiAssetV0; MultiAssetV1: MultiAssetV1; MultiAssetV2: MultiAssetV2; + MultiAssetV3: MultiAssetV3; + MultiAssetV4: MultiAssetV4; MultiDisputeStatementSet: MultiDisputeStatementSet; MultiLocation: MultiLocation; MultiLocationV0: MultiLocationV0; MultiLocationV1: MultiLocationV1; MultiLocationV2: MultiLocationV2; + MultiLocationV3: MultiLocationV3; + MultiLocationV4: MultiLocationV4; Multiplier: Multiplier; Multisig: Multisig; MultiSignature: MultiSignature; MultiSigner: MultiSigner; NetworkId: NetworkId; + NetworkIdV2: NetworkIdV2; + NetworkIdV3: NetworkIdV3; + NetworkIdV4: NetworkIdV4; NetworkState: NetworkState; NetworkStatePeerset: NetworkStatePeerset; NetworkStatePeersetInfo: NetworkStatePeersetInfo; @@ -717,6 +777,7 @@ declare module '@polkadot/types/types/registry' { NextConfigDescriptorV1: NextConfigDescriptorV1; NftCollectionId: NftCollectionId; NftItemId: NftItemId; + NodeFeatures: NodeFeatures; NodeRole: NodeRole; Nominations: Nominations; NominatorIndex: NominatorIndex; @@ -750,12 +811,16 @@ declare module '@polkadot/types/types/registry' { OriginKindV0: OriginKindV0; OriginKindV1: OriginKindV1; OriginKindV2: OriginKindV2; + OriginKindV3: OriginKindV3; + OriginKindV4: OriginKindV4; + OutboundHrmpChannelLimitations: OutboundHrmpChannelLimitations; OutboundHrmpMessage: OutboundHrmpMessage; OutboundLaneData: OutboundLaneData; OutboundMessageFee: OutboundMessageFee; OutboundPayload: OutboundPayload; OutboundStatus: OutboundStatus; Outcome: Outcome; + OutcomeV4: OutcomeV4; OuterEnums15: OuterEnums15; OverweightIndex: OverweightIndex; Owner: Owner; @@ -770,6 +835,8 @@ declare module '@polkadot/types/types/registry' { PalletEventMetadataLatest: PalletEventMetadataLatest; PalletEventMetadataV14: PalletEventMetadataV14; PalletId: PalletId; + PalletInfoV3: PalletInfoV3; + PalletInfoV4: PalletInfoV4; PalletMetadataLatest: PalletMetadataLatest; PalletMetadataV14: PalletMetadataV14; PalletMetadataV15: PalletMetadataV15; @@ -822,6 +889,7 @@ declare module '@polkadot/types/types/registry' { Points: Points; PortableType: PortableType; PortableTypeV14: PortableTypeV14; + PostDispatchInfo: PostDispatchInfo; Precommits: Precommits; PrefabWasmModule: PrefabWasmModule; PrefixedStorageKey: PrefixedStorageKey; @@ -842,6 +910,8 @@ declare module '@polkadot/types/types/registry' { PvfExecTimeoutKind: PvfExecTimeoutKind; PvfPrepTimeoutKind: PvfPrepTimeoutKind; QueryId: QueryId; + QueryResponseInfoV3: QueryResponseInfoV3; + QueryResponseInfoV4: QueryResponseInfoV4; QueryStatus: QueryStatus; QueueConfigData: QueueConfigData; QueuedParathread: QueuedParathread; @@ -899,7 +969,10 @@ declare module '@polkadot/types/types/registry' { ResponseV1: ResponseV1; ResponseV2: ResponseV2; ResponseV2Error: ResponseV2Error; - ResponseV2Result: ResponseV2Result; + ResponseV3: ResponseV3; + ResponseV3Error: ResponseV3Error; + ResponseV3Result: ResponseV3Result; + ResponseV4: ResponseV4; Retriable: Retriable; RewardDestination: RewardDestination; RewardPoint: RewardPoint; @@ -955,6 +1028,8 @@ declare module '@polkadot/types/types/registry' { SessionKeys8B: SessionKeys8B; SessionKeys9: SessionKeys9; SessionKeys9B: SessionKeys9B; + SessionPhase: SessionPhase; + SessionStatus: SessionStatus; SetId: SetId; SetIndex: SetIndex; Si0Field: Si0Field; @@ -1039,6 +1114,9 @@ declare module '@polkadot/types/types/registry' { StakingLedgerTo240: StakingLedgerTo240; Statement: Statement; StatementKind: StatementKind; + StatementStoreInvalidStatement: StatementStoreInvalidStatement; + StatementStoreStatementSource: StatementStoreStatementSource; + StatementStoreValidStatement: StatementStoreValidStatement; StorageChangeSet: StorageChangeSet; StorageData: StorageData; StorageDeposit: StorageDeposit; @@ -1091,6 +1169,7 @@ declare module '@polkadot/types/types/registry' { Tally: Tally; TaskAddress: TaskAddress; TAssetBalance: TAssetBalance; + TAssetConversion: TAssetConversion; TAssetDepositBalance: TAssetDepositBalance; Text: Text; Timepoint: Timepoint; @@ -1130,6 +1209,7 @@ declare module '@polkadot/types/types/registry' { U8: U8; UnappliedSlash: UnappliedSlash; UnappliedSlashOther: UnappliedSlashOther; + UncheckedFungibilityV4: UncheckedFungibilityV4; UncleEntryItem: UncleEntryItem; UnknownTransaction: UnknownTransaction; UnlockChunk: UnlockChunk; @@ -1168,6 +1248,8 @@ declare module '@polkadot/types/types/registry' { VersionedResponse: VersionedResponse; VersionedXcm: VersionedXcm; VersionMigrationStage: VersionMigrationStage; + VersionV3: VersionV3; + VersionV4: VersionV4; VestingInfo: VestingInfo; VestingSchedule: VestingSchedule; Vote: Vote; @@ -1188,6 +1270,7 @@ declare module '@polkadot/types/types/registry' { VrfProof: VrfProof; Weight: Weight; WeightLimitV2: WeightLimitV2; + WeightLimitV3: WeightLimitV3; WeightMultiplier: WeightMultiplier; WeightPerClass: WeightPerClass; WeightToFeeCoefficient: WeightToFeeCoefficient; @@ -1198,9 +1281,13 @@ declare module '@polkadot/types/types/registry' { WildFungibilityV0: WildFungibilityV0; WildFungibilityV1: WildFungibilityV1; WildFungibilityV2: WildFungibilityV2; + WildFungibilityV3: WildFungibilityV3; + WildFungibilityV4: WildFungibilityV4; WildMultiAsset: WildMultiAsset; WildMultiAssetV1: WildMultiAssetV1; WildMultiAssetV2: WildMultiAssetV2; + WildMultiAssetV3: WildMultiAssetV3; + WildMultiAssetV4: WildMultiAssetV4; WinnersData: WinnersData; WinnersData10: WinnersData10; WinnersDataTuple: WinnersDataTuple; @@ -1211,20 +1298,25 @@ declare module '@polkadot/types/types/registry' { WithdrawReasons: WithdrawReasons; Xcm: Xcm; XcmAssetId: XcmAssetId; + XcmDryRunApiError: XcmDryRunApiError; + XcmDryRunEffects: XcmDryRunEffects; XcmError: XcmError; XcmErrorV0: XcmErrorV0; XcmErrorV1: XcmErrorV1; XcmErrorV2: XcmErrorV2; - XcmOrder: XcmOrder; + XcmErrorV3: XcmErrorV3; + XcmErrorV4: XcmErrorV4; XcmOrderV0: XcmOrderV0; XcmOrderV1: XcmOrderV1; - XcmOrderV2: XcmOrderV2; XcmOrigin: XcmOrigin; XcmOriginKind: XcmOriginKind; + XcmPaymentApiError: XcmPaymentApiError; XcmpMessageFormat: XcmpMessageFormat; XcmV0: XcmV0; XcmV1: XcmV1; XcmV2: XcmV2; + XcmV3: XcmV3; + XcmV4: XcmV4; XcmVersion: XcmVersion; } // InterfaceTypes } // declare module diff --git a/src/interfaces/index.ts b/src/interfaces/index.ts index 34587ac..7f1de78 100644 --- a/src/interfaces/index.ts +++ b/src/interfaces/index.ts @@ -1,4 +1,4 @@ // Auto-generated via `yarn polkadot-types-from-defs`, do not edit /* eslint-disable */ -//export * from './types.ts'; +export * from './types.js'; diff --git a/src/interfaces/lookup.ts b/src/interfaces/lookup.ts index 56449fc..bea8a20 100644 --- a/src/interfaces/lookup.ts +++ b/src/interfaces/lookup.ts @@ -1,7 +1,7 @@ // Auto-generated via `yarn polkadot-types-from-defs`, do not edit /* eslint-disable */ - +/* eslint-disable sort-keys */ export default { /** @@ -163,27 +163,7 @@ export default { _enum: ['LimitReached', 'NoLayer'] }, /** - * Lookup30: pallet_grandpa::pallet::Event - **/ - PalletGrandpaEvent: { - _enum: { - NewAuthorities: { - authoritySet: 'Vec<(SpConsensusGrandpaAppPublic,u64)>', - }, - Paused: 'Null', - Resumed: 'Null' - } - }, - /** - * Lookup33: sp_consensus_grandpa::app::Public - **/ - SpConsensusGrandpaAppPublic: 'SpCoreEd25519Public', - /** - * Lookup34: sp_core::ed25519::Public - **/ - SpCoreEd25519Public: '[u8;32]', - /** - * Lookup35: pallet_balances::pallet::Event + * Lookup30: pallet_balances::pallet::Event **/ PalletBalancesEvent: { _enum: { @@ -274,13 +254,42 @@ export default { } }, /** - * Lookup36: frame_support::traits::tokens::misc::BalanceStatus + * Lookup31: frame_support::traits::tokens::misc::BalanceStatus **/ FrameSupportTokensMiscBalanceStatus: { _enum: ['Free', 'Reserved'] }, /** - * Lookup37: pallet_transaction_payment::pallet::Event + * Lookup32: sugarfunge_validator_set::pallet::Event + **/ + SugarfungeValidatorSetEvent: { + _enum: { + ValidatorAdditionInitiated: 'AccountId32', + ValidatorRemovalInitiated: 'AccountId32' + } + }, + /** + * Lookup33: pallet_grandpa::pallet::Event + **/ + PalletGrandpaEvent: { + _enum: { + NewAuthorities: { + authoritySet: 'Vec<(SpConsensusGrandpaAppPublic,u64)>', + }, + Paused: 'Null', + Resumed: 'Null' + } + }, + /** + * Lookup36: sp_consensus_grandpa::app::Public + **/ + SpConsensusGrandpaAppPublic: 'SpCoreEd25519Public', + /** + * Lookup37: sp_core::ed25519::Public + **/ + SpCoreEd25519Public: '[u8;32]', + /** + * Lookup38: pallet_transaction_payment::pallet::Event **/ PalletTransactionPaymentEvent: { _enum: { @@ -292,7 +301,7 @@ export default { } }, /** - * Lookup38: pallet_sudo::pallet::Event + * Lookup39: pallet_sudo::pallet::Event **/ PalletSudoEvent: { _enum: { @@ -308,7 +317,7 @@ export default { } }, /** - * Lookup42: pallet_scheduler::pallet::Event + * Lookup43: pallet_scheduler::pallet::Event **/ PalletSchedulerEvent: { _enum: { @@ -340,7 +349,7 @@ export default { } }, /** - * Lookup45: pallet_collective::pallet::Event + * Lookup46: pallet_collective::pallet::Event **/ PalletCollectiveEvent: { _enum: { @@ -379,26 +388,39 @@ export default { } }, /** - * Lookup47: sugarfunge_validator_set::pallet::Event + * Lookup48: pallet_session::pallet::Event **/ - SugarfungeValidatorSetEvent: { + PalletSessionEvent: { _enum: { - ValidatorAdditionInitiated: 'AccountId32', - ValidatorRemovalInitiated: 'AccountId32' + NewSession: { + sessionIndex: 'u32' + } } }, /** - * Lookup48: pallet_session::pallet::Event + * Lookup49: pallet_im_online::pallet::Event **/ - PalletSessionEvent: { + PalletImOnlineEvent: { _enum: { - NewSession: { - sessionIndex: 'u32' + HeartbeatReceived: { + authorityId: 'PalletImOnlineSr25519AppSr25519Public', + }, + AllGood: 'Null', + SomeOffline: { + offline: 'Vec<(AccountId32,AccountId32)>' } } }, /** - * Lookup49: sugarfunge_asset::pallet::Event + * Lookup50: pallet_im_online::sr25519::app_sr25519::Public + **/ + PalletImOnlineSr25519AppSr25519Public: 'SpCoreSr25519Public', + /** + * Lookup51: sp_core::sr25519::Public + **/ + SpCoreSr25519Public: '[u8;32]', + /** + * Lookup54: sugarfunge_asset::pallet::Event **/ SugarfungeAssetEvent: { _enum: { @@ -470,7 +492,7 @@ export default { } }, /** - * Lookup52: sugarfunge_dao::pallet::Event + * Lookup57: sugarfunge_dao::pallet::Event **/ SugarfungeDaoEvent: { _enum: { @@ -478,7 +500,7 @@ export default { } }, /** - * Lookup53: sugarfunge_bundle::pallet::Event + * Lookup58: sugarfunge_bundle::pallet::Event **/ SugarfungeBundleEvent: { _enum: { @@ -505,7 +527,7 @@ export default { } }, /** - * Lookup54: sugarfunge_bag::pallet::Event + * Lookup59: sugarfunge_bag::pallet::Event **/ SugarfungeBagEvent: { _enum: { @@ -532,7 +554,7 @@ export default { } }, /** - * Lookup56: sugarfunge_exgine::pallet::Event + * Lookup61: sugarfunge_exgine::pallet::Event **/ SugarfungeExgineEvent: { _enum: { @@ -540,7 +562,7 @@ export default { } }, /** - * Lookup57: sugarfunge_market::pallet::Event + * Lookup62: sugarfunge_market::pallet::Event **/ SugarfungeMarketEvent: { _enum: { @@ -588,14 +610,14 @@ export default { } }, /** - * Lookup61: sugarfunge_market::RateBalance + * Lookup66: sugarfunge_market::RateBalance **/ SugarfungeMarketRateBalance: { rate: 'SugarfungeMarketAssetRate', balance: 'i128' }, /** - * Lookup62: sugarfunge_market::AssetRate + * Lookup67: sugarfunge_market::AssetRate **/ SugarfungeMarketAssetRate: { classId: 'u64', @@ -605,7 +627,7 @@ export default { to: 'SugarfungeMarketRateAccount' }, /** - * Lookup63: sugarfunge_market::RateAction + * Lookup68: sugarfunge_market::RateAction **/ SugarfungeMarketRateAction: { _enum: { @@ -617,19 +639,19 @@ export default { } }, /** - * Lookup65: sugarfunge_market::AMM + * Lookup70: sugarfunge_market::AMM **/ SugarfungeMarketAmm: { _enum: ['Constant'] }, /** - * Lookup66: sugarfunge_market::AmountOp + * Lookup71: sugarfunge_market::AmountOp **/ SugarfungeMarketAmountOp: { _enum: ['Equal', 'LessThan', 'LessEqualThan', 'GreaterThan', 'GreaterEqualThan'] }, /** - * Lookup67: sugarfunge_market::RateAccount + * Lookup72: sugarfunge_market::RateAccount **/ SugarfungeMarketRateAccount: { _enum: { @@ -639,7 +661,7 @@ export default { } }, /** - * Lookup68: functionland_fula::pallet::Event + * Lookup73: functionland_fula::pallet::Event **/ FunctionlandFulaEvent: { _enum: { @@ -742,7 +764,7 @@ export default { } }, /** - * Lookup74: functionland_fula::ManifestWithPoolId> + * Lookup79: functionland_fula::ManifestWithPoolId> **/ FunctionlandFulaManifestWithPoolId: { _alias: { @@ -754,7 +776,7 @@ export default { size_: 'Option' }, /** - * Lookup77: functionland_fula::UploaderData + * Lookup82: functionland_fula::UploaderData **/ FunctionlandFulaUploaderData: { uploader: 'AccountId32', @@ -762,7 +784,7 @@ export default { replicationFactor: 'u16' }, /** - * Lookup80: functionland_fula::ManifestAvailable> + * Lookup85: functionland_fula::ManifestAvailable> **/ FunctionlandFulaManifestAvailable: { poolId: 'u32', @@ -770,7 +792,7 @@ export default { manifestMetadata: 'Bytes' }, /** - * Lookup82: functionland_fula::StorerData, sp_core::crypto::AccountId32> + * Lookup87: functionland_fula::StorerData, sp_core::crypto::AccountId32> **/ FunctionlandFulaStorerData: { poolId: 'u32', @@ -779,7 +801,7 @@ export default { manifestData: 'FunctionlandFulaManifestStorageData' }, /** - * Lookup84: functionland_fula::ManifestStorageData + * Lookup89: functionland_fula::ManifestStorageData **/ FunctionlandFulaManifestStorageData: { activeCycles: 'u16', @@ -788,13 +810,13 @@ export default { challengeState: 'FunctionlandFulaChallengeState' }, /** - * Lookup85: functionland_fula::ChallengeState + * Lookup90: functionland_fula::ChallengeState **/ FunctionlandFulaChallengeState: { _enum: ['Open', 'Successful', 'Failed'] }, /** - * Lookup86: fula_pool::pallet::Event + * Lookup91: fula_pool::pallet::Event **/ FulaPoolEvent: { _enum: { @@ -825,7 +847,27 @@ export default { } }, /** - * Lookup87: frame_system::Phase + * Lookup92: pallet_utility::pallet::Event + **/ + PalletUtilityEvent: { + _enum: { + BatchInterrupted: { + index: 'u32', + error: 'SpRuntimeDispatchError', + }, + BatchCompleted: 'Null', + BatchCompletedWithErrors: 'Null', + ItemCompleted: 'Null', + ItemFailed: { + error: 'SpRuntimeDispatchError', + }, + DispatchedAs: { + result: 'Result' + } + } + }, + /** + * Lookup93: frame_system::Phase **/ FrameSystemPhase: { _enum: { @@ -835,14 +877,14 @@ export default { } }, /** - * Lookup90: frame_system::LastRuntimeUpgradeInfo + * Lookup96: frame_system::LastRuntimeUpgradeInfo **/ FrameSystemLastRuntimeUpgradeInfo: { specVersion: 'Compact', specName: 'Text' }, /** - * Lookup93: frame_system::pallet::Call + * Lookup99: frame_system::pallet::Call **/ FrameSystemCall: { _enum: { @@ -877,7 +919,7 @@ export default { } }, /** - * Lookup96: frame_system::limits::BlockWeights + * Lookup102: frame_system::limits::BlockWeights **/ FrameSystemLimitsBlockWeights: { baseBlock: 'SpWeightsWeightV2Weight', @@ -885,7 +927,7 @@ export default { perClass: 'FrameSupportDispatchPerDispatchClassWeightsPerClass' }, /** - * Lookup97: frame_support::dispatch::PerDispatchClass + * Lookup103: frame_support::dispatch::PerDispatchClass **/ FrameSupportDispatchPerDispatchClassWeightsPerClass: { normal: 'FrameSystemLimitsWeightsPerClass', @@ -893,7 +935,7 @@ export default { mandatory: 'FrameSystemLimitsWeightsPerClass' }, /** - * Lookup98: frame_system::limits::WeightsPerClass + * Lookup104: frame_system::limits::WeightsPerClass **/ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: 'SpWeightsWeightV2Weight', @@ -902,13 +944,13 @@ export default { reserved: 'Option' }, /** - * Lookup100: frame_system::limits::BlockLength + * Lookup106: frame_system::limits::BlockLength **/ FrameSystemLimitsBlockLength: { max: 'FrameSupportDispatchPerDispatchClassU32' }, /** - * Lookup101: frame_support::dispatch::PerDispatchClass + * Lookup107: frame_support::dispatch::PerDispatchClass **/ FrameSupportDispatchPerDispatchClassU32: { normal: 'u32', @@ -916,14 +958,14 @@ export default { mandatory: 'u32' }, /** - * Lookup102: sp_weights::RuntimeDbWeight + * Lookup108: sp_weights::RuntimeDbWeight **/ SpWeightsRuntimeDbWeight: { read: 'u64', write: 'u64' }, /** - * Lookup103: sp_version::RuntimeVersion + * Lookup109: sp_version::RuntimeVersion **/ SpVersionRuntimeVersion: { specName: 'Text', @@ -936,13 +978,13 @@ export default { stateVersion: 'u8' }, /** - * Lookup108: frame_system::pallet::Error + * Lookup114: frame_system::pallet::Error **/ FrameSystemError: { _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'] }, /** - * Lookup109: pallet_timestamp::pallet::Call + * Lookup115: pallet_timestamp::pallet::Call **/ PalletTimestampCall: { _enum: { @@ -952,7 +994,107 @@ export default { } }, /** - * Lookup110: pallet_grandpa::StoredState + * Lookup117: pallet_balances::types::BalanceLock + **/ + PalletBalancesBalanceLock: { + id: '[u8;8]', + amount: 'u128', + reasons: 'PalletBalancesReasons' + }, + /** + * Lookup118: pallet_balances::types::Reasons + **/ + PalletBalancesReasons: { + _enum: ['Fee', 'Misc', 'All'] + }, + /** + * Lookup121: pallet_balances::types::ReserveData + **/ + PalletBalancesReserveData: { + id: '[u8;8]', + amount: 'u128' + }, + /** + * Lookup124: pallet_balances::types::IdAmount + **/ + PalletBalancesIdAmount: { + id: 'Null', + amount: 'u128' + }, + /** + * Lookup126: pallet_balances::pallet::Call + **/ + PalletBalancesCall: { + _enum: { + transfer_allow_death: { + dest: 'MultiAddress', + value: 'Compact', + }, + set_balance_deprecated: { + who: 'MultiAddress', + newFree: 'Compact', + oldReserved: 'Compact', + }, + force_transfer: { + source: 'MultiAddress', + dest: 'MultiAddress', + value: 'Compact', + }, + transfer_keep_alive: { + dest: 'MultiAddress', + value: 'Compact', + }, + transfer_all: { + dest: 'MultiAddress', + keepAlive: 'bool', + }, + force_unreserve: { + who: 'MultiAddress', + amount: 'u128', + }, + upgrade_accounts: { + who: 'Vec', + }, + transfer: { + dest: 'MultiAddress', + value: 'Compact', + }, + force_set_balance: { + who: 'MultiAddress', + newFree: 'Compact' + } + } + }, + /** + * Lookup131: pallet_balances::pallet::Error + **/ + PalletBalancesError: { + _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'Expendability', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves', 'TooManyHolds', 'TooManyFreezes'] + }, + /** + * Lookup133: sugarfunge_validator_set::pallet::Call + **/ + SugarfungeValidatorSetCall: { + _enum: { + add_validator: { + validatorId: 'AccountId32', + }, + remove_validator: { + validatorId: 'AccountId32', + }, + add_validator_again: { + validatorId: 'AccountId32' + } + } + }, + /** + * Lookup134: sugarfunge_validator_set::pallet::Error + **/ + SugarfungeValidatorSetError: { + _enum: ['TooLowValidatorCount', 'Duplicate', 'ValidatorNotApproved', 'BadOrigin'] + }, + /** + * Lookup135: pallet_grandpa::StoredState **/ PalletGrandpaStoredState: { _enum: { @@ -969,7 +1111,7 @@ export default { } }, /** - * Lookup111: pallet_grandpa::StoredPendingChange + * Lookup136: pallet_grandpa::StoredPendingChange **/ PalletGrandpaStoredPendingChange: { scheduledAt: 'u32', @@ -978,7 +1120,7 @@ export default { forced: 'Option' }, /** - * Lookup114: pallet_grandpa::pallet::Call + * Lookup139: pallet_grandpa::pallet::Call **/ PalletGrandpaCall: { _enum: { @@ -997,14 +1139,14 @@ export default { } }, /** - * Lookup115: sp_consensus_grandpa::EquivocationProof + * Lookup140: sp_consensus_grandpa::EquivocationProof **/ SpConsensusGrandpaEquivocationProof: { setId: 'u64', equivocation: 'SpConsensusGrandpaEquivocation' }, /** - * Lookup116: sp_consensus_grandpa::Equivocation + * Lookup141: sp_consensus_grandpa::Equivocation **/ SpConsensusGrandpaEquivocation: { _enum: { @@ -1013,7 +1155,7 @@ export default { } }, /** - * Lookup117: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> + * Lookup142: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> **/ FinalityGrandpaEquivocationPrevote: { roundNumber: 'u64', @@ -1022,22 +1164,22 @@ export default { second: '(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)' }, /** - * Lookup118: finality_grandpa::Prevote + * Lookup143: finality_grandpa::Prevote **/ FinalityGrandpaPrevote: { targetHash: 'H256', targetNumber: 'u32' }, /** - * Lookup119: sp_consensus_grandpa::app::Signature + * Lookup144: sp_consensus_grandpa::app::Signature **/ SpConsensusGrandpaAppSignature: 'SpCoreEd25519Signature', /** - * Lookup120: sp_core::ed25519::Signature + * Lookup145: sp_core::ed25519::Signature **/ SpCoreEd25519Signature: '[u8;64]', /** - * Lookup123: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> + * Lookup148: finality_grandpa::Equivocation, sp_consensus_grandpa::app::Signature> **/ FinalityGrandpaEquivocationPrecommit: { roundNumber: 'u64', @@ -1046,108 +1188,30 @@ export default { second: '(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)' }, /** - * Lookup124: finality_grandpa::Precommit + * Lookup149: finality_grandpa::Precommit **/ FinalityGrandpaPrecommit: { targetHash: 'H256', targetNumber: 'u32' }, /** - * Lookup126: sp_core::Void + * Lookup151: sp_core::Void **/ SpCoreVoid: 'Null', /** - * Lookup127: pallet_grandpa::pallet::Error + * Lookup152: pallet_grandpa::pallet::Error **/ PalletGrandpaError: { _enum: ['PauseFailed', 'ResumeFailed', 'ChangePending', 'TooSoon', 'InvalidKeyOwnershipProof', 'InvalidEquivocationProof', 'DuplicateOffenceReport'] }, /** - * Lookup129: pallet_balances::types::BalanceLock - **/ - PalletBalancesBalanceLock: { - id: '[u8;8]', - amount: 'u128', - reasons: 'PalletBalancesReasons' - }, - /** - * Lookup130: pallet_balances::types::Reasons - **/ - PalletBalancesReasons: { - _enum: ['Fee', 'Misc', 'All'] - }, - /** - * Lookup133: pallet_balances::types::ReserveData - **/ - PalletBalancesReserveData: { - id: '[u8;8]', - amount: 'u128' - }, - /** - * Lookup136: pallet_balances::types::IdAmount - **/ - PalletBalancesIdAmount: { - id: 'Null', - amount: 'u128' - }, - /** - * Lookup138: pallet_balances::pallet::Call - **/ - PalletBalancesCall: { - _enum: { - transfer_allow_death: { - dest: 'MultiAddress', - value: 'Compact', - }, - set_balance_deprecated: { - who: 'MultiAddress', - newFree: 'Compact', - oldReserved: 'Compact', - }, - force_transfer: { - source: 'MultiAddress', - dest: 'MultiAddress', - value: 'Compact', - }, - transfer_keep_alive: { - dest: 'MultiAddress', - value: 'Compact', - }, - transfer_all: { - dest: 'MultiAddress', - keepAlive: 'bool', - }, - force_unreserve: { - who: 'MultiAddress', - amount: 'u128', - }, - upgrade_accounts: { - who: 'Vec', - }, - transfer: { - dest: 'MultiAddress', - value: 'Compact', - }, - force_set_balance: { - who: 'MultiAddress', - newFree: 'Compact' - } - } - }, - /** - * Lookup143: pallet_balances::pallet::Error - **/ - PalletBalancesError: { - _enum: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'Expendability', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves', 'TooManyHolds', 'TooManyFreezes'] - }, - /** - * Lookup145: pallet_transaction_payment::Releases + * Lookup154: pallet_transaction_payment::Releases **/ PalletTransactionPaymentReleases: { _enum: ['V1Ancient', 'V2'] }, /** - * Lookup146: pallet_sudo::pallet::Call + * Lookup155: pallet_sudo::pallet::Call **/ PalletSudoCall: { _enum: { @@ -1171,7 +1235,7 @@ export default { } }, /** - * Lookup148: pallet_scheduler::pallet::Call + * Lookup157: pallet_scheduler::pallet::Call **/ PalletSchedulerCall: { _enum: { @@ -1211,7 +1275,7 @@ export default { } }, /** - * Lookup150: pallet_collective::pallet::Call + * Lookup159: pallet_collective::pallet::Call **/ PalletCollectiveCall: { _enum: { @@ -1247,23 +1311,7 @@ export default { } }, /** - * Lookup151: sugarfunge_validator_set::pallet::Call - **/ - SugarfungeValidatorSetCall: { - _enum: { - add_validator: { - validatorId: 'AccountId32', - }, - remove_validator: { - validatorId: 'AccountId32', - }, - add_validator_again: { - validatorId: 'AccountId32' - } - } - }, - /** - * Lookup152: pallet_session::pallet::Call + * Lookup160: pallet_session::pallet::Call **/ PalletSessionCall: { _enum: { @@ -1278,22 +1326,55 @@ export default { } }, /** - * Lookup153: sugarfunge_runtime::opaque::SessionKeys + * Lookup161: sugarfunge_runtime::opaque::SessionKeys **/ SugarfungeRuntimeOpaqueSessionKeys: { aura: 'SpConsensusAuraSr25519AppSr25519Public', - grandpa: 'SpConsensusGrandpaAppPublic' + grandpa: 'SpConsensusGrandpaAppPublic', + imOnline: 'PalletImOnlineSr25519AppSr25519Public' }, /** - * Lookup154: sp_consensus_aura::sr25519::app_sr25519::Public + * Lookup162: sp_consensus_aura::sr25519::app_sr25519::Public **/ SpConsensusAuraSr25519AppSr25519Public: 'SpCoreSr25519Public', /** - * Lookup155: sp_core::sr25519::Public + * Lookup163: pallet_im_online::pallet::Call **/ - SpCoreSr25519Public: '[u8;32]', + PalletImOnlineCall: { + _enum: { + heartbeat: { + heartbeat: 'PalletImOnlineHeartbeat', + signature: 'PalletImOnlineSr25519AppSr25519Signature' + } + } + }, + /** + * Lookup164: pallet_im_online::Heartbeat + **/ + PalletImOnlineHeartbeat: { + blockNumber: 'u32', + networkState: 'SpCoreOffchainOpaqueNetworkState', + sessionIndex: 'u32', + authorityIndex: 'u32', + validatorsLen: 'u32' + }, + /** + * Lookup165: sp_core::offchain::OpaqueNetworkState + **/ + SpCoreOffchainOpaqueNetworkState: { + peerId: 'OpaquePeerId', + externalAddresses: 'Vec' + }, + /** + * Lookup169: pallet_im_online::sr25519::app_sr25519::Signature + **/ + PalletImOnlineSr25519AppSr25519Signature: 'SpCoreSr25519Signature', + /** + * Lookup170: sp_core::sr25519::Signature + **/ + SpCoreSr25519Signature: '[u8;64]', /** - * Lookup156: sugarfunge_asset::pallet::Call + * Lookup171: sugarfunge_asset::pallet::Call **/ SugarfungeAssetCall: { _enum: { @@ -1357,7 +1438,7 @@ export default { } }, /** - * Lookup159: sugarfunge_dao::pallet::Call + * Lookup174: sugarfunge_dao::pallet::Call **/ SugarfungeDaoCall: { _enum: { @@ -1368,7 +1449,7 @@ export default { } }, /** - * Lookup160: sugarfunge_bundle::pallet::Call + * Lookup175: sugarfunge_bundle::pallet::Call **/ SugarfungeBundleCall: { _enum: { @@ -1394,7 +1475,7 @@ export default { } }, /** - * Lookup168: sugarfunge_bag::pallet::Call + * Lookup183: sugarfunge_bag::pallet::Call **/ SugarfungeBagCall: { _enum: { @@ -1420,7 +1501,7 @@ export default { } }, /** - * Lookup169: sugarfunge_exgine::pallet::Call + * Lookup184: sugarfunge_exgine::pallet::Call **/ SugarfungeExgineCall: { _enum: { @@ -1431,7 +1512,7 @@ export default { } }, /** - * Lookup170: sugarfunge_market::pallet::Call + * Lookup185: sugarfunge_market::pallet::Call **/ SugarfungeMarketCall: { _enum: { @@ -1456,7 +1537,7 @@ export default { } }, /** - * Lookup173: functionland_fula::pallet::Call + * Lookup188: functionland_fula::pallet::Call **/ FunctionlandFulaCall: { _enum: { @@ -1544,7 +1625,7 @@ export default { } }, /** - * Lookup177: fula_pool::pallet::Call + * Lookup192: fula_pool::pallet::Call **/ FulaPoolCall: { _enum: { @@ -1555,6 +1636,7 @@ export default { }, leave_pool: { poolId: 'u32', + targetAccount: 'Option', }, join: { poolId: 'u32', @@ -1562,6 +1644,7 @@ export default { }, cancel_join: { poolId: 'u32', + targetAccount: 'Option', }, vote: { poolId: 'u32', @@ -1572,44 +1655,35 @@ export default { } }, /** - * Lookup179: pallet_sudo::pallet::Error - **/ - PalletSudoError: { - _enum: ['RequireSudo'] - }, - /** - * Lookup182: pallet_scheduler::Scheduled, BlockNumber, sugarfunge_runtime::OriginCaller, sp_core::crypto::AccountId32> - **/ - PalletSchedulerScheduled: { - maybeId: 'Option<[u8;32]>', - priority: 'u8', - call: 'FrameSupportPreimagesBounded', - maybePeriodic: 'Option<(u32,u32)>', - origin: 'SugarfungeRuntimeOriginCaller' - }, - /** - * Lookup183: frame_support::traits::preimages::Bounded + * Lookup194: pallet_utility::pallet::Call **/ - FrameSupportPreimagesBounded: { + PalletUtilityCall: { _enum: { - Legacy: { - _alias: { - hash_: 'hash', - }, - hash_: 'H256', + batch: { + calls: 'Vec', }, - Inline: 'Bytes', - Lookup: { - _alias: { - hash_: 'hash', - }, - hash_: 'H256', - len: 'u32' + as_derivative: { + index: 'u16', + call: 'Call', + }, + batch_all: { + calls: 'Vec', + }, + dispatch_as: { + asOrigin: 'SugarfungeRuntimeOriginCaller', + call: 'Call', + }, + force_batch: { + calls: 'Vec', + }, + with_weight: { + call: 'Call', + weight: 'SpWeightsWeightV2Weight' } } }, /** - * Lookup185: sugarfunge_runtime::OriginCaller + * Lookup196: sugarfunge_runtime::OriginCaller **/ SugarfungeRuntimeOriginCaller: { _enum: { @@ -1621,11 +1695,13 @@ export default { __Unused5: 'Null', __Unused6: 'Null', __Unused7: 'Null', + __Unused8: 'Null', + __Unused9: 'Null', Council: 'PalletCollectiveRawOrigin' } }, /** - * Lookup186: frame_support::dispatch::RawOrigin + * Lookup197: frame_support::dispatch::RawOrigin **/ FrameSupportDispatchRawOrigin: { _enum: { @@ -1635,7 +1711,7 @@ export default { } }, /** - * Lookup187: pallet_collective::RawOrigin + * Lookup198: pallet_collective::RawOrigin **/ PalletCollectiveRawOrigin: { _enum: { @@ -1645,13 +1721,50 @@ export default { } }, /** - * Lookup189: pallet_scheduler::pallet::Error + * Lookup199: pallet_sudo::pallet::Error + **/ + PalletSudoError: { + _enum: ['RequireSudo'] + }, + /** + * Lookup202: pallet_scheduler::Scheduled, BlockNumber, sugarfunge_runtime::OriginCaller, sp_core::crypto::AccountId32> + **/ + PalletSchedulerScheduled: { + maybeId: 'Option<[u8;32]>', + priority: 'u8', + call: 'FrameSupportPreimagesBounded', + maybePeriodic: 'Option<(u32,u32)>', + origin: 'SugarfungeRuntimeOriginCaller' + }, + /** + * Lookup203: frame_support::traits::preimages::Bounded + **/ + FrameSupportPreimagesBounded: { + _enum: { + Legacy: { + _alias: { + hash_: 'hash', + }, + hash_: 'H256', + }, + Inline: 'Bytes', + Lookup: { + _alias: { + hash_: 'hash', + }, + hash_: 'H256', + len: 'u32' + } + } + }, + /** + * Lookup206: pallet_scheduler::pallet::Error **/ PalletSchedulerError: { _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange', 'Named'] }, /** - * Lookup191: pallet_collective::Votes + * Lookup208: pallet_collective::Votes **/ PalletCollectiveVotes: { index: 'u32', @@ -1661,36 +1774,43 @@ export default { end: 'u32' }, /** - * Lookup192: pallet_collective::pallet::Error + * Lookup209: pallet_collective::pallet::Error **/ PalletCollectiveError: { _enum: ['NotMember', 'DuplicateProposal', 'ProposalMissing', 'WrongIndex', 'DuplicateVote', 'AlreadyInitialized', 'TooEarly', 'TooManyProposals', 'WrongProposalWeight', 'WrongProposalLength'] }, /** - * Lookup194: sugarfunge_validator_set::pallet::Error - **/ - SugarfungeValidatorSetError: { - _enum: ['TooLowValidatorCount', 'Duplicate', 'ValidatorNotApproved', 'BadOrigin'] - }, - /** - * Lookup198: sp_core::crypto::KeyTypeId + * Lookup213: sp_core::crypto::KeyTypeId **/ SpCoreCryptoKeyTypeId: '[u8;4]', /** - * Lookup199: pallet_session::pallet::Error + * Lookup214: pallet_session::pallet::Error **/ PalletSessionError: { _enum: ['InvalidProof', 'NoAssociatedValidatorId', 'DuplicatedKey', 'NoKeys', 'NoAccount'] }, /** - * Lookup200: sugarfunge_asset::Class> + * Lookup218: pallet_im_online::BoundedOpaqueNetworkState + **/ + PalletImOnlineBoundedOpaqueNetworkState: { + peerId: 'Bytes', + externalAddresses: 'Vec' + }, + /** + * Lookup223: pallet_im_online::pallet::Error + **/ + PalletImOnlineError: { + _enum: ['InvalidKey', 'DuplicatedHeartbeat'] + }, + /** + * Lookup224: sugarfunge_asset::Class> **/ SugarfungeAssetClass: { owner: 'AccountId32', metadata: 'Bytes' }, /** - * Lookup202: sugarfunge_asset::Asset> + * Lookup226: sugarfunge_asset::Asset> **/ SugarfungeAssetAsset: { classId: 'u64', @@ -1698,19 +1818,19 @@ export default { metadata: 'Bytes' }, /** - * Lookup204: sugarfunge_asset::pallet::Error + * Lookup228: sugarfunge_asset::pallet::Error **/ SugarfungeAssetError: { _enum: ['Unknown', 'InUse', 'InvalidAssetId', 'InsufficientBalance', 'NumOverflow', 'InvalidArrayLength', 'Overflow', 'InvalidClassId', 'NoPermission', 'ClassNotFound', 'AssetNotFound'] }, /** - * Lookup205: sugarfunge_dao::pallet::Error + * Lookup229: sugarfunge_dao::pallet::Error **/ SugarfungeDaoError: { _enum: ['NoneValue', 'StorageOverflow'] }, /** - * Lookup206: sugarfunge_bundle::Bundle> + * Lookup230: sugarfunge_bundle::Bundle> **/ SugarfungeBundleBundle: { creator: 'AccountId32', @@ -1721,24 +1841,24 @@ export default { vault: 'AccountId32' }, /** - * Lookup207: frame_support::PalletId + * Lookup231: frame_support::PalletId **/ FrameSupportPalletId: '[u8;8]', /** - * Lookup208: sugarfunge_bundle::pallet::Error + * Lookup232: sugarfunge_bundle::pallet::Error **/ SugarfungeBundleError: { _enum: ['InvalidBundleIdForBundle', 'BundleExists', 'BundleNotFound', 'NumOverflow', 'InvalidArrayLength', 'InsufficientBalance', 'AssetExists', 'AccountNotOwner'] }, /** - * Lookup209: sugarfunge_bag::BagClass + * Lookup233: sugarfunge_bag::BagClass **/ SugarfungeBagBagClass: { operator: 'AccountId32', classId: 'u64' }, /** - * Lookup210: sugarfunge_bag::Bag + * Lookup234: sugarfunge_bag::Bag **/ SugarfungeBagBag: { operator: 'AccountId32', @@ -1747,32 +1867,32 @@ export default { totalShares: 'u128' }, /** - * Lookup211: sugarfunge_bag::pallet::Error + * Lookup235: sugarfunge_bag::pallet::Error **/ SugarfungeBagError: { _enum: ['BagClassExists', 'BagExists', 'InvalidBagClass', 'InvalidBag', 'InvalidBagOperator', 'InvalidBagOwner', 'InvalidArrayLength', 'InsufficientShares'] }, /** - * Lookup212: sugarfunge_exgine::pallet::Error + * Lookup236: sugarfunge_exgine::pallet::Error **/ SugarfungeExgineError: { _enum: ['NoneValue', 'StorageOverflow'] }, /** - * Lookup213: sugarfunge_market::Market + * Lookup237: sugarfunge_market::Market **/ SugarfungeMarketMarket: { owner: 'AccountId32', vault: 'AccountId32' }, /** - * Lookup215: sugarfunge_market::pallet::Error + * Lookup239: sugarfunge_market::pallet::Error **/ SugarfungeMarketError: { _enum: ['Overflow', 'InsufficientAmount', 'InsufficientLiquidity', 'InvalidMarket', 'InvalidMarketRate', 'InvalidMarketOwner', 'NotAuthorizedToMintAsset', 'MarketExists', 'MarketRateExists', 'InvalidAsset', 'InvalidAssetRate', 'InvalidRateAccount', 'InvalidRateAmount', 'InvalidBurnPrice', 'InvalidBurnBalance', 'InvalidTransferPrice', 'InvalidTransferBalance', 'InvalidBuyer', 'InvalidArrayLength'] }, /** - * Lookup217: functionland_fula::Manifest> + * Lookup241: functionland_fula::Manifest> **/ FunctionlandFulaManifest: { _alias: { @@ -1783,14 +1903,14 @@ export default { size_: 'Option' }, /** - * Lookup220: functionland_fula::Challenge + * Lookup244: functionland_fula::Challenge **/ FunctionlandFulaChallenge: { challenger: 'AccountId32', challengeState: 'FunctionlandFulaChallengeState' }, /** - * Lookup221: functionland_fula::ClaimData + * Lookup245: functionland_fula::ClaimData **/ FunctionlandFulaClaimData: { mintedLaborTokens: 'u128', @@ -1798,13 +1918,13 @@ export default { challengeTokens: 'u128' }, /** - * Lookup222: functionland_fula::pallet::Error + * Lookup246: functionland_fula::pallet::Error **/ FunctionlandFulaError: { - _enum: ['NoneValue', 'StorageOverflow', 'ReplicationFactorLimitReached', 'ReplicationFactorInvalid', 'AccountAlreadyStorer', 'AccountNotStorer', 'AccountNotInPool', 'AccountNotUploader', 'AccountNotFound', 'ManifestAlreadyExist', 'ManifestNotFound', 'ManifestNotStored', 'InvalidArrayLength', 'ErrorPickingCIDToChallenge', 'ErrorPickingAccountToChallenge', 'ManifestStorerDataNotFound', 'NoFileSizeProvided', 'NoAccountsToChallenge'] + _enum: ['NoneValue', 'StorageOverflow', 'ReplicationFactorLimitReached', 'ReplicationFactorInvalid', 'AccountAlreadyStorer', 'AccountNotStorer', 'AccountNotInPool', 'AccountNotUploader', 'AccountNotFound', 'ManifestAlreadyExist', 'ManifestNotFound', 'ManifestNotStored', 'InvalidArrayLength', 'ErrorPickingCIDToChallenge', 'ErrorPickingAccountToChallenge', 'ManifestStorerDataNotFound', 'NoFileSizeProvided', 'NoAccountsToChallenge', 'FileAlreadyUploadedbyUser'] }, /** - * Lookup223: fula_pool::Pool + * Lookup247: fula_pool::Pool **/ FulaPoolPool: { name: 'Bytes', @@ -1815,7 +1935,7 @@ export default { region: 'Bytes' }, /** - * Lookup226: fula_pool::PoolRequest + * Lookup249: fula_pool::PoolRequest **/ FulaPoolPoolRequest: { voted: 'Vec', @@ -1823,7 +1943,7 @@ export default { peerId: 'Bytes' }, /** - * Lookup227: fula_pool::User> + * Lookup250: fula_pool::User> **/ FulaPoolUser: { poolId: 'Option', @@ -1831,13 +1951,19 @@ export default { peerId: 'Bytes' }, /** - * Lookup228: fula_pool::pallet::Error + * Lookup251: fula_pool::pallet::Error **/ FulaPoolError: { _enum: ['UserBusy', 'MaxPools', 'NameTooLong', 'PoolDoesNotExist', 'RequestDoesNotExist', 'CapacityReached', 'UserDoesNotExist', 'AccessDenied', 'InternalError', 'AlreadyVoted'] }, /** - * Lookup230: sp_runtime::MultiSignature + * Lookup252: pallet_utility::pallet::Error + **/ + PalletUtilityError: { + _enum: ['TooManyCalls'] + }, + /** + * Lookup254: sp_runtime::MultiSignature **/ SpRuntimeMultiSignature: { _enum: { @@ -1847,43 +1973,39 @@ export default { } }, /** - * Lookup231: sp_core::sr25519::Signature - **/ - SpCoreSr25519Signature: '[u8;64]', - /** - * Lookup232: sp_core::ecdsa::Signature + * Lookup255: sp_core::ecdsa::Signature **/ SpCoreEcdsaSignature: '[u8;65]', /** - * Lookup235: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender + * Lookup258: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender **/ FrameSystemExtensionsCheckNonZeroSender: 'Null', /** - * Lookup236: frame_system::extensions::check_spec_version::CheckSpecVersion + * Lookup259: frame_system::extensions::check_spec_version::CheckSpecVersion **/ FrameSystemExtensionsCheckSpecVersion: 'Null', /** - * Lookup237: frame_system::extensions::check_tx_version::CheckTxVersion + * Lookup260: frame_system::extensions::check_tx_version::CheckTxVersion **/ FrameSystemExtensionsCheckTxVersion: 'Null', /** - * Lookup238: frame_system::extensions::check_genesis::CheckGenesis + * Lookup261: frame_system::extensions::check_genesis::CheckGenesis **/ FrameSystemExtensionsCheckGenesis: 'Null', /** - * Lookup241: frame_system::extensions::check_nonce::CheckNonce + * Lookup264: frame_system::extensions::check_nonce::CheckNonce **/ FrameSystemExtensionsCheckNonce: 'Compact', /** - * Lookup242: frame_system::extensions::check_weight::CheckWeight + * Lookup265: frame_system::extensions::check_weight::CheckWeight **/ FrameSystemExtensionsCheckWeight: 'Null', /** - * Lookup243: pallet_transaction_payment::ChargeTransactionPayment + * Lookup266: pallet_transaction_payment::ChargeTransactionPayment **/ PalletTransactionPaymentChargeTransactionPayment: 'Compact', /** - * Lookup244: sugarfunge_runtime::Runtime + * Lookup267: sugarfunge_runtime::Runtime **/ SugarfungeRuntimeRuntime: 'Null' }; diff --git a/src/interfaces/registry.ts b/src/interfaces/registry.ts index 9855673..d6fa01f 100644 --- a/src/interfaces/registry.ts +++ b/src/interfaces/registry.ts @@ -5,7 +5,7 @@ // this is required to allow for ambient/previous definitions import '@polkadot/types/types/registry'; -import type { FinalityGrandpaEquivocationPrecommit, FinalityGrandpaEquivocationPrevote, FinalityGrandpaPrecommit, FinalityGrandpaPrevote, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportPreimagesBounded, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonZeroSender, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, FulaPoolCall, FulaPoolError, FulaPoolEvent, FulaPoolPool, FulaPoolPoolRequest, FulaPoolUser, FunctionlandFulaCall, FunctionlandFulaChallenge, FunctionlandFulaChallengeState, FunctionlandFulaClaimData, FunctionlandFulaError, FunctionlandFulaEvent, FunctionlandFulaManifest, FunctionlandFulaManifestAvailable, FunctionlandFulaManifestStorageData, FunctionlandFulaManifestWithPoolId, FunctionlandFulaStorerData, FunctionlandFulaUploaderData, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesIdAmount, PalletBalancesReasons, PalletBalancesReserveData, PalletCollectiveCall, PalletCollectiveError, PalletCollectiveEvent, PalletCollectiveRawOrigin, PalletCollectiveVotes, PalletGrandpaCall, PalletGrandpaError, PalletGrandpaEvent, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletSchedulerCall, PalletSchedulerError, PalletSchedulerEvent, PalletSchedulerScheduled, PalletSessionCall, PalletSessionError, PalletSessionEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTimestampCall, PalletTransactionPaymentChargeTransactionPayment, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, SpArithmeticArithmeticError, SpConsensusAuraSr25519AppSr25519Public, SpConsensusGrandpaAppPublic, SpConsensusGrandpaAppSignature, SpConsensusGrandpaEquivocation, SpConsensusGrandpaEquivocationProof, SpCoreCryptoKeyTypeId, SpCoreEcdsaSignature, SpCoreEd25519Public, SpCoreEd25519Signature, SpCoreSr25519Public, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight, SugarfungeAssetAsset, SugarfungeAssetCall, SugarfungeAssetClass, SugarfungeAssetError, SugarfungeAssetEvent, SugarfungeBagBag, SugarfungeBagBagClass, SugarfungeBagCall, SugarfungeBagError, SugarfungeBagEvent, SugarfungeBundleBundle, SugarfungeBundleCall, SugarfungeBundleError, SugarfungeBundleEvent, SugarfungeDaoCall, SugarfungeDaoError, SugarfungeDaoEvent, SugarfungeExgineCall, SugarfungeExgineError, SugarfungeExgineEvent, SugarfungeMarketAmm, SugarfungeMarketAmountOp, SugarfungeMarketAssetRate, SugarfungeMarketCall, SugarfungeMarketError, SugarfungeMarketEvent, SugarfungeMarketMarket, SugarfungeMarketRateAccount, SugarfungeMarketRateAction, SugarfungeMarketRateBalance, SugarfungeRuntimeOpaqueSessionKeys, SugarfungeRuntimeOriginCaller, SugarfungeRuntimeRuntime, SugarfungeValidatorSetCall, SugarfungeValidatorSetError, SugarfungeValidatorSetEvent } from '@polkadot/types/lookup'; +import type { FinalityGrandpaEquivocationPrecommit, FinalityGrandpaEquivocationPrevote, FinalityGrandpaPrecommit, FinalityGrandpaPrevote, FrameSupportDispatchDispatchClass, FrameSupportDispatchDispatchInfo, FrameSupportDispatchPays, FrameSupportDispatchPerDispatchClassU32, FrameSupportDispatchPerDispatchClassWeight, FrameSupportDispatchPerDispatchClassWeightsPerClass, FrameSupportDispatchRawOrigin, FrameSupportPalletId, FrameSupportPreimagesBounded, FrameSupportTokensMiscBalanceStatus, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonZeroSender, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, FulaPoolCall, FulaPoolError, FulaPoolEvent, FulaPoolPool, FulaPoolPoolRequest, FulaPoolUser, FunctionlandFulaCall, FunctionlandFulaChallenge, FunctionlandFulaChallengeState, FunctionlandFulaClaimData, FunctionlandFulaError, FunctionlandFulaEvent, FunctionlandFulaManifest, FunctionlandFulaManifestAvailable, FunctionlandFulaManifestStorageData, FunctionlandFulaManifestWithPoolId, FunctionlandFulaStorerData, FunctionlandFulaUploaderData, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesIdAmount, PalletBalancesReasons, PalletBalancesReserveData, PalletCollectiveCall, PalletCollectiveError, PalletCollectiveEvent, PalletCollectiveRawOrigin, PalletCollectiveVotes, PalletGrandpaCall, PalletGrandpaError, PalletGrandpaEvent, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletImOnlineBoundedOpaqueNetworkState, PalletImOnlineCall, PalletImOnlineError, PalletImOnlineEvent, PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Public, PalletImOnlineSr25519AppSr25519Signature, PalletSchedulerCall, PalletSchedulerError, PalletSchedulerEvent, PalletSchedulerScheduled, PalletSessionCall, PalletSessionError, PalletSessionEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTimestampCall, PalletTransactionPaymentChargeTransactionPayment, PalletTransactionPaymentEvent, PalletTransactionPaymentReleases, PalletUtilityCall, PalletUtilityError, PalletUtilityEvent, SpArithmeticArithmeticError, SpConsensusAuraSr25519AppSr25519Public, SpConsensusGrandpaAppPublic, SpConsensusGrandpaAppSignature, SpConsensusGrandpaEquivocation, SpConsensusGrandpaEquivocationProof, SpCoreCryptoKeyTypeId, SpCoreEcdsaSignature, SpCoreEd25519Public, SpCoreEd25519Signature, SpCoreOffchainOpaqueNetworkState, SpCoreSr25519Public, SpCoreSr25519Signature, SpCoreVoid, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight, SugarfungeAssetAsset, SugarfungeAssetCall, SugarfungeAssetClass, SugarfungeAssetError, SugarfungeAssetEvent, SugarfungeBagBag, SugarfungeBagBagClass, SugarfungeBagCall, SugarfungeBagError, SugarfungeBagEvent, SugarfungeBundleBundle, SugarfungeBundleCall, SugarfungeBundleError, SugarfungeBundleEvent, SugarfungeDaoCall, SugarfungeDaoError, SugarfungeDaoEvent, SugarfungeExgineCall, SugarfungeExgineError, SugarfungeExgineEvent, SugarfungeMarketAmm, SugarfungeMarketAmountOp, SugarfungeMarketAssetRate, SugarfungeMarketCall, SugarfungeMarketError, SugarfungeMarketEvent, SugarfungeMarketMarket, SugarfungeMarketRateAccount, SugarfungeMarketRateAction, SugarfungeMarketRateBalance, SugarfungeRuntimeOpaqueSessionKeys, SugarfungeRuntimeOriginCaller, SugarfungeRuntimeRuntime, SugarfungeValidatorSetCall, SugarfungeValidatorSetError, SugarfungeValidatorSetEvent } from '@polkadot/types/lookup'; declare module '@polkadot/types/types/registry' { interface InterfaceTypes { @@ -75,6 +75,13 @@ declare module '@polkadot/types/types/registry' { PalletGrandpaEvent: PalletGrandpaEvent; PalletGrandpaStoredPendingChange: PalletGrandpaStoredPendingChange; PalletGrandpaStoredState: PalletGrandpaStoredState; + PalletImOnlineBoundedOpaqueNetworkState: PalletImOnlineBoundedOpaqueNetworkState; + PalletImOnlineCall: PalletImOnlineCall; + PalletImOnlineError: PalletImOnlineError; + PalletImOnlineEvent: PalletImOnlineEvent; + PalletImOnlineHeartbeat: PalletImOnlineHeartbeat; + PalletImOnlineSr25519AppSr25519Public: PalletImOnlineSr25519AppSr25519Public; + PalletImOnlineSr25519AppSr25519Signature: PalletImOnlineSr25519AppSr25519Signature; PalletSchedulerCall: PalletSchedulerCall; PalletSchedulerError: PalletSchedulerError; PalletSchedulerEvent: PalletSchedulerEvent; @@ -89,6 +96,9 @@ declare module '@polkadot/types/types/registry' { PalletTransactionPaymentChargeTransactionPayment: PalletTransactionPaymentChargeTransactionPayment; PalletTransactionPaymentEvent: PalletTransactionPaymentEvent; PalletTransactionPaymentReleases: PalletTransactionPaymentReleases; + PalletUtilityCall: PalletUtilityCall; + PalletUtilityError: PalletUtilityError; + PalletUtilityEvent: PalletUtilityEvent; SpArithmeticArithmeticError: SpArithmeticArithmeticError; SpConsensusAuraSr25519AppSr25519Public: SpConsensusAuraSr25519AppSr25519Public; SpConsensusGrandpaAppPublic: SpConsensusGrandpaAppPublic; @@ -99,6 +109,7 @@ declare module '@polkadot/types/types/registry' { SpCoreEcdsaSignature: SpCoreEcdsaSignature; SpCoreEd25519Public: SpCoreEd25519Public; SpCoreEd25519Signature: SpCoreEd25519Signature; + SpCoreOffchainOpaqueNetworkState: SpCoreOffchainOpaqueNetworkState; SpCoreSr25519Public: SpCoreSr25519Public; SpCoreSr25519Signature: SpCoreSr25519Signature; SpCoreVoid: SpCoreVoid; diff --git a/src/interfaces/types-lookup.ts b/src/interfaces/types-lookup.ts index 300720e..2da0127 100644 --- a/src/interfaces/types-lookup.ts +++ b/src/interfaces/types-lookup.ts @@ -7,6 +7,7 @@ import '@polkadot/types/lookup'; import type { Bytes, Compact, Enum, Null, Option, Result, Struct, Text, U8aFixed, Vec, bool, i128, i32, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { ITuple } from '@polkadot/types-codec/types'; +import type { OpaqueMultiaddr, OpaquePeerId } from '@polkadot/types/interfaces/imOnline'; import type { AccountId32, Call, H256, MultiAddress } from '@polkadot/types/interfaces/runtime'; import type { Event } from '@polkadot/types/interfaces/system'; @@ -176,24 +177,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'LimitReached' | 'NoLayer'; } - /** @name PalletGrandpaEvent (30) */ - interface PalletGrandpaEvent extends Enum { - readonly isNewAuthorities: boolean; - readonly asNewAuthorities: { - readonly authoritySet: Vec>; - } & Struct; - readonly isPaused: boolean; - readonly isResumed: boolean; - readonly type: 'NewAuthorities' | 'Paused' | 'Resumed'; - } - - /** @name SpConsensusGrandpaAppPublic (33) */ - interface SpConsensusGrandpaAppPublic extends SpCoreEd25519Public {} - - /** @name SpCoreEd25519Public (34) */ - interface SpCoreEd25519Public extends U8aFixed {} - - /** @name PalletBalancesEvent (35) */ + /** @name PalletBalancesEvent (30) */ interface PalletBalancesEvent extends Enum { readonly isEndowed: boolean; readonly asEndowed: { @@ -303,14 +287,40 @@ declare module '@polkadot/types/lookup' { readonly type: 'Endowed' | 'DustLost' | 'Transfer' | 'BalanceSet' | 'Reserved' | 'Unreserved' | 'ReserveRepatriated' | 'Deposit' | 'Withdraw' | 'Slashed' | 'Minted' | 'Burned' | 'Suspended' | 'Restored' | 'Upgraded' | 'Issued' | 'Rescinded' | 'Locked' | 'Unlocked' | 'Frozen' | 'Thawed'; } - /** @name FrameSupportTokensMiscBalanceStatus (36) */ + /** @name FrameSupportTokensMiscBalanceStatus (31) */ interface FrameSupportTokensMiscBalanceStatus extends Enum { readonly isFree: boolean; readonly isReserved: boolean; readonly type: 'Free' | 'Reserved'; } - /** @name PalletTransactionPaymentEvent (37) */ + /** @name SugarfungeValidatorSetEvent (32) */ + interface SugarfungeValidatorSetEvent extends Enum { + readonly isValidatorAdditionInitiated: boolean; + readonly asValidatorAdditionInitiated: AccountId32; + readonly isValidatorRemovalInitiated: boolean; + readonly asValidatorRemovalInitiated: AccountId32; + readonly type: 'ValidatorAdditionInitiated' | 'ValidatorRemovalInitiated'; + } + + /** @name PalletGrandpaEvent (33) */ + interface PalletGrandpaEvent extends Enum { + readonly isNewAuthorities: boolean; + readonly asNewAuthorities: { + readonly authoritySet: Vec>; + } & Struct; + readonly isPaused: boolean; + readonly isResumed: boolean; + readonly type: 'NewAuthorities' | 'Paused' | 'Resumed'; + } + + /** @name SpConsensusGrandpaAppPublic (36) */ + interface SpConsensusGrandpaAppPublic extends SpCoreEd25519Public {} + + /** @name SpCoreEd25519Public (37) */ + interface SpCoreEd25519Public extends U8aFixed {} + + /** @name PalletTransactionPaymentEvent (38) */ interface PalletTransactionPaymentEvent extends Enum { readonly isTransactionFeePaid: boolean; readonly asTransactionFeePaid: { @@ -321,7 +331,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'TransactionFeePaid'; } - /** @name PalletSudoEvent (38) */ + /** @name PalletSudoEvent (39) */ interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -338,7 +348,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Sudid' | 'KeyChanged' | 'SudoAsDone'; } - /** @name PalletSchedulerEvent (42) */ + /** @name PalletSchedulerEvent (43) */ interface PalletSchedulerEvent extends Enum { readonly isScheduled: boolean; readonly asScheduled: { @@ -374,7 +384,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Scheduled' | 'Canceled' | 'Dispatched' | 'CallUnavailable' | 'PeriodicFailed' | 'PermanentlyOverweight'; } - /** @name PalletCollectiveEvent (45) */ + /** @name PalletCollectiveEvent (46) */ interface PalletCollectiveEvent extends Enum { readonly isProposed: boolean; readonly asProposed: { @@ -418,15 +428,6 @@ declare module '@polkadot/types/lookup' { readonly type: 'Proposed' | 'Voted' | 'Approved' | 'Disapproved' | 'Executed' | 'MemberExecuted' | 'Closed'; } - /** @name SugarfungeValidatorSetEvent (47) */ - interface SugarfungeValidatorSetEvent extends Enum { - readonly isValidatorAdditionInitiated: boolean; - readonly asValidatorAdditionInitiated: AccountId32; - readonly isValidatorRemovalInitiated: boolean; - readonly asValidatorRemovalInitiated: AccountId32; - readonly type: 'ValidatorAdditionInitiated' | 'ValidatorRemovalInitiated'; - } - /** @name PalletSessionEvent (48) */ interface PalletSessionEvent extends Enum { readonly isNewSession: boolean; @@ -436,7 +437,27 @@ declare module '@polkadot/types/lookup' { readonly type: 'NewSession'; } - /** @name SugarfungeAssetEvent (49) */ + /** @name PalletImOnlineEvent (49) */ + interface PalletImOnlineEvent extends Enum { + readonly isHeartbeatReceived: boolean; + readonly asHeartbeatReceived: { + readonly authorityId: PalletImOnlineSr25519AppSr25519Public; + } & Struct; + readonly isAllGood: boolean; + readonly isSomeOffline: boolean; + readonly asSomeOffline: { + readonly offline: Vec>; + } & Struct; + readonly type: 'HeartbeatReceived' | 'AllGood' | 'SomeOffline'; + } + + /** @name PalletImOnlineSr25519AppSr25519Public (50) */ + interface PalletImOnlineSr25519AppSr25519Public extends SpCoreSr25519Public {} + + /** @name SpCoreSr25519Public (51) */ + interface SpCoreSr25519Public extends U8aFixed {} + + /** @name SugarfungeAssetEvent (54) */ interface SugarfungeAssetEvent extends Enum { readonly isClassCreated: boolean; readonly asClassCreated: { @@ -516,14 +537,14 @@ declare module '@polkadot/types/lookup' { readonly type: 'ClassCreated' | 'AssetCreated' | 'AssetMetadataUpdated' | 'Mint' | 'BatchMint' | 'Burn' | 'BatchBurn' | 'Transferred' | 'BatchTransferred' | 'OperatorApprovalForAll'; } - /** @name SugarfungeDaoEvent (52) */ + /** @name SugarfungeDaoEvent (57) */ interface SugarfungeDaoEvent extends Enum { readonly isSomethingStored: boolean; readonly asSomethingStored: ITuple<[u32, AccountId32]>; readonly type: 'SomethingStored'; } - /** @name SugarfungeBundleEvent (53) */ + /** @name SugarfungeBundleEvent (58) */ interface SugarfungeBundleEvent extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -551,7 +572,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Register' | 'Mint' | 'Burn'; } - /** @name SugarfungeBagEvent (54) */ + /** @name SugarfungeBagEvent (59) */ interface SugarfungeBagEvent extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -580,14 +601,14 @@ declare module '@polkadot/types/lookup' { readonly type: 'Register' | 'Created' | 'Deposit' | 'Sweep'; } - /** @name SugarfungeExgineEvent (56) */ + /** @name SugarfungeExgineEvent (61) */ interface SugarfungeExgineEvent extends Enum { readonly isSomethingStored: boolean; readonly asSomethingStored: ITuple<[u32, AccountId32]>; readonly type: 'SomethingStored'; } - /** @name SugarfungeMarketEvent (57) */ + /** @name SugarfungeMarketEvent (62) */ interface SugarfungeMarketEvent extends Enum { readonly isCreated: boolean; readonly asCreated: { @@ -639,13 +660,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'Created' | 'RateCreated' | 'LiquidityAdded' | 'LiquidityRemoved' | 'Deposit' | 'Exchanged'; } - /** @name SugarfungeMarketRateBalance (61) */ + /** @name SugarfungeMarketRateBalance (66) */ interface SugarfungeMarketRateBalance extends Struct { readonly rate: SugarfungeMarketAssetRate; readonly balance: i128; } - /** @name SugarfungeMarketAssetRate (62) */ + /** @name SugarfungeMarketAssetRate (67) */ interface SugarfungeMarketAssetRate extends Struct { readonly classId: u64; readonly assetId: u64; @@ -654,7 +675,7 @@ declare module '@polkadot/types/lookup' { readonly to: SugarfungeMarketRateAccount; } - /** @name SugarfungeMarketRateAction (63) */ + /** @name SugarfungeMarketRateAction (68) */ interface SugarfungeMarketRateAction extends Enum { readonly isTransfer: boolean; readonly asTransfer: i128; @@ -669,13 +690,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'Transfer' | 'MarketTransfer' | 'Mint' | 'Burn' | 'Has'; } - /** @name SugarfungeMarketAmm (65) */ + /** @name SugarfungeMarketAmm (70) */ interface SugarfungeMarketAmm extends Enum { readonly isConstant: boolean; readonly type: 'Constant'; } - /** @name SugarfungeMarketAmountOp (66) */ + /** @name SugarfungeMarketAmountOp (71) */ interface SugarfungeMarketAmountOp extends Enum { readonly isEqual: boolean; readonly isLessThan: boolean; @@ -685,7 +706,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Equal' | 'LessThan' | 'LessEqualThan' | 'GreaterThan' | 'GreaterEqualThan'; } - /** @name SugarfungeMarketRateAccount (67) */ + /** @name SugarfungeMarketRateAccount (72) */ interface SugarfungeMarketRateAccount extends Enum { readonly isMarket: boolean; readonly isAccount: boolean; @@ -694,7 +715,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Market' | 'Account' | 'Buyer'; } - /** @name FunctionlandFulaEvent (68) */ + /** @name FunctionlandFulaEvent (73) */ interface FunctionlandFulaEvent extends Enum { readonly isManifestOutput: boolean; readonly asManifestOutput: { @@ -810,7 +831,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'ManifestOutput' | 'StorageManifestOutput' | 'RemoveStorerOutput' | 'ManifestRemoved' | 'ManifestStorageUpdated' | 'BatchManifestOutput' | 'BatchStorageManifestOutput' | 'BatchRemoveStorerOutput' | 'BatchManifestRemoved' | 'VerifiedStorerManifests' | 'UpdateFileSizeOutput' | 'UpdateFileSizesOutput' | 'GetManifests' | 'GetAvailableManifests' | 'GetManifestsStorerData' | 'Challenge' | 'VerifiedChallenges' | 'MintedLaborTokens'; } - /** @name FunctionlandFulaManifestWithPoolId (74) */ + /** @name FunctionlandFulaManifestWithPoolId (79) */ interface FunctionlandFulaManifestWithPoolId extends Struct { readonly poolId: u32; readonly usersData: Vec; @@ -818,21 +839,21 @@ declare module '@polkadot/types/lookup' { readonly size_: Option; } - /** @name FunctionlandFulaUploaderData (77) */ + /** @name FunctionlandFulaUploaderData (82) */ interface FunctionlandFulaUploaderData extends Struct { readonly uploader: AccountId32; readonly storers: Vec; readonly replicationFactor: u16; } - /** @name FunctionlandFulaManifestAvailable (80) */ + /** @name FunctionlandFulaManifestAvailable (85) */ interface FunctionlandFulaManifestAvailable extends Struct { readonly poolId: u32; readonly replicationFactor: u16; readonly manifestMetadata: Bytes; } - /** @name FunctionlandFulaStorerData (82) */ + /** @name FunctionlandFulaStorerData (87) */ interface FunctionlandFulaStorerData extends Struct { readonly poolId: u32; readonly cid: Bytes; @@ -840,7 +861,7 @@ declare module '@polkadot/types/lookup' { readonly manifestData: FunctionlandFulaManifestStorageData; } - /** @name FunctionlandFulaManifestStorageData (84) */ + /** @name FunctionlandFulaManifestStorageData (89) */ interface FunctionlandFulaManifestStorageData extends Struct { readonly activeCycles: u16; readonly missedCycles: u16; @@ -848,7 +869,7 @@ declare module '@polkadot/types/lookup' { readonly challengeState: FunctionlandFulaChallengeState; } - /** @name FunctionlandFulaChallengeState (85) */ + /** @name FunctionlandFulaChallengeState (90) */ interface FunctionlandFulaChallengeState extends Enum { readonly isOpen: boolean; readonly isSuccessful: boolean; @@ -856,7 +877,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Open' | 'Successful' | 'Failed'; } - /** @name FulaPoolEvent (86) */ + /** @name FulaPoolEvent (91) */ interface FulaPoolEvent extends Enum { readonly isPoolCreated: boolean; readonly asPoolCreated: { @@ -891,7 +912,28 @@ declare module '@polkadot/types/lookup' { readonly type: 'PoolCreated' | 'JoinRequested' | 'RequestWithdrawn' | 'VotingResult' | 'CapacityReached' | 'ParticipantLeft'; } - /** @name FrameSystemPhase (87) */ + /** @name PalletUtilityEvent (92) */ + interface PalletUtilityEvent extends Enum { + readonly isBatchInterrupted: boolean; + readonly asBatchInterrupted: { + readonly index: u32; + readonly error: SpRuntimeDispatchError; + } & Struct; + readonly isBatchCompleted: boolean; + readonly isBatchCompletedWithErrors: boolean; + readonly isItemCompleted: boolean; + readonly isItemFailed: boolean; + readonly asItemFailed: { + readonly error: SpRuntimeDispatchError; + } & Struct; + readonly isDispatchedAs: boolean; + readonly asDispatchedAs: { + readonly result: Result; + } & Struct; + readonly type: 'BatchInterrupted' | 'BatchCompleted' | 'BatchCompletedWithErrors' | 'ItemCompleted' | 'ItemFailed' | 'DispatchedAs'; + } + + /** @name FrameSystemPhase (93) */ interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -900,13 +942,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } - /** @name FrameSystemLastRuntimeUpgradeInfo (90) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (96) */ interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemCall (93) */ + /** @name FrameSystemCall (99) */ interface FrameSystemCall extends Enum { readonly isRemark: boolean; readonly asRemark: { @@ -944,21 +986,21 @@ declare module '@polkadot/types/lookup' { readonly type: 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent'; } - /** @name FrameSystemLimitsBlockWeights (96) */ + /** @name FrameSystemLimitsBlockWeights (102) */ interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: SpWeightsWeightV2Weight; readonly maxBlock: SpWeightsWeightV2Weight; readonly perClass: FrameSupportDispatchPerDispatchClassWeightsPerClass; } - /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (97) */ + /** @name FrameSupportDispatchPerDispatchClassWeightsPerClass (103) */ interface FrameSupportDispatchPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (98) */ + /** @name FrameSystemLimitsWeightsPerClass (104) */ interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: SpWeightsWeightV2Weight; readonly maxExtrinsic: Option; @@ -966,25 +1008,25 @@ declare module '@polkadot/types/lookup' { readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (100) */ + /** @name FrameSystemLimitsBlockLength (106) */ interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportDispatchPerDispatchClassU32; } - /** @name FrameSupportDispatchPerDispatchClassU32 (101) */ + /** @name FrameSupportDispatchPerDispatchClassU32 (107) */ interface FrameSupportDispatchPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name SpWeightsRuntimeDbWeight (102) */ + /** @name SpWeightsRuntimeDbWeight (108) */ interface SpWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (103) */ + /** @name SpVersionRuntimeVersion (109) */ interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -996,7 +1038,7 @@ declare module '@polkadot/types/lookup' { readonly stateVersion: u8; } - /** @name FrameSystemError (108) */ + /** @name FrameSystemError (114) */ interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -1007,7 +1049,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered'; } - /** @name PalletTimestampCall (109) */ + /** @name PalletTimestampCall (115) */ interface PalletTimestampCall extends Enum { readonly isSet: boolean; readonly asSet: { @@ -1016,7 +1058,126 @@ declare module '@polkadot/types/lookup' { readonly type: 'Set'; } - /** @name PalletGrandpaStoredState (110) */ + /** @name PalletBalancesBalanceLock (117) */ + interface PalletBalancesBalanceLock extends Struct { + readonly id: U8aFixed; + readonly amount: u128; + readonly reasons: PalletBalancesReasons; + } + + /** @name PalletBalancesReasons (118) */ + interface PalletBalancesReasons extends Enum { + readonly isFee: boolean; + readonly isMisc: boolean; + readonly isAll: boolean; + readonly type: 'Fee' | 'Misc' | 'All'; + } + + /** @name PalletBalancesReserveData (121) */ + interface PalletBalancesReserveData extends Struct { + readonly id: U8aFixed; + readonly amount: u128; + } + + /** @name PalletBalancesIdAmount (124) */ + interface PalletBalancesIdAmount extends Struct { + readonly id: Null; + readonly amount: u128; + } + + /** @name PalletBalancesCall (126) */ + interface PalletBalancesCall extends Enum { + readonly isTransferAllowDeath: boolean; + readonly asTransferAllowDeath: { + readonly dest: MultiAddress; + readonly value: Compact; + } & Struct; + readonly isSetBalanceDeprecated: boolean; + readonly asSetBalanceDeprecated: { + readonly who: MultiAddress; + readonly newFree: Compact; + readonly oldReserved: Compact; + } & Struct; + readonly isForceTransfer: boolean; + readonly asForceTransfer: { + readonly source: MultiAddress; + readonly dest: MultiAddress; + readonly value: Compact; + } & Struct; + readonly isTransferKeepAlive: boolean; + readonly asTransferKeepAlive: { + readonly dest: MultiAddress; + readonly value: Compact; + } & Struct; + readonly isTransferAll: boolean; + readonly asTransferAll: { + readonly dest: MultiAddress; + readonly keepAlive: bool; + } & Struct; + readonly isForceUnreserve: boolean; + readonly asForceUnreserve: { + readonly who: MultiAddress; + readonly amount: u128; + } & Struct; + readonly isUpgradeAccounts: boolean; + readonly asUpgradeAccounts: { + readonly who: Vec; + } & Struct; + readonly isTransfer: boolean; + readonly asTransfer: { + readonly dest: MultiAddress; + readonly value: Compact; + } & Struct; + readonly isForceSetBalance: boolean; + readonly asForceSetBalance: { + readonly who: MultiAddress; + readonly newFree: Compact; + } & Struct; + readonly type: 'TransferAllowDeath' | 'SetBalanceDeprecated' | 'ForceTransfer' | 'TransferKeepAlive' | 'TransferAll' | 'ForceUnreserve' | 'UpgradeAccounts' | 'Transfer' | 'ForceSetBalance'; + } + + /** @name PalletBalancesError (131) */ + interface PalletBalancesError extends Enum { + readonly isVestingBalance: boolean; + readonly isLiquidityRestrictions: boolean; + readonly isInsufficientBalance: boolean; + readonly isExistentialDeposit: boolean; + readonly isExpendability: boolean; + readonly isExistingVestingSchedule: boolean; + readonly isDeadAccount: boolean; + readonly isTooManyReserves: boolean; + readonly isTooManyHolds: boolean; + readonly isTooManyFreezes: boolean; + readonly type: 'VestingBalance' | 'LiquidityRestrictions' | 'InsufficientBalance' | 'ExistentialDeposit' | 'Expendability' | 'ExistingVestingSchedule' | 'DeadAccount' | 'TooManyReserves' | 'TooManyHolds' | 'TooManyFreezes'; + } + + /** @name SugarfungeValidatorSetCall (133) */ + interface SugarfungeValidatorSetCall extends Enum { + readonly isAddValidator: boolean; + readonly asAddValidator: { + readonly validatorId: AccountId32; + } & Struct; + readonly isRemoveValidator: boolean; + readonly asRemoveValidator: { + readonly validatorId: AccountId32; + } & Struct; + readonly isAddValidatorAgain: boolean; + readonly asAddValidatorAgain: { + readonly validatorId: AccountId32; + } & Struct; + readonly type: 'AddValidator' | 'RemoveValidator' | 'AddValidatorAgain'; + } + + /** @name SugarfungeValidatorSetError (134) */ + interface SugarfungeValidatorSetError extends Enum { + readonly isTooLowValidatorCount: boolean; + readonly isDuplicate: boolean; + readonly isValidatorNotApproved: boolean; + readonly isBadOrigin: boolean; + readonly type: 'TooLowValidatorCount' | 'Duplicate' | 'ValidatorNotApproved' | 'BadOrigin'; + } + + /** @name PalletGrandpaStoredState (135) */ interface PalletGrandpaStoredState extends Enum { readonly isLive: boolean; readonly isPendingPause: boolean; @@ -1033,7 +1194,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Live' | 'PendingPause' | 'Paused' | 'PendingResume'; } - /** @name PalletGrandpaStoredPendingChange (111) */ + /** @name PalletGrandpaStoredPendingChange (136) */ interface PalletGrandpaStoredPendingChange extends Struct { readonly scheduledAt: u32; readonly delay: u32; @@ -1041,7 +1202,7 @@ declare module '@polkadot/types/lookup' { readonly forced: Option; } - /** @name PalletGrandpaCall (114) */ + /** @name PalletGrandpaCall (139) */ interface PalletGrandpaCall extends Enum { readonly isReportEquivocation: boolean; readonly asReportEquivocation: { @@ -1061,13 +1222,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'ReportEquivocation' | 'ReportEquivocationUnsigned' | 'NoteStalled'; } - /** @name SpConsensusGrandpaEquivocationProof (115) */ + /** @name SpConsensusGrandpaEquivocationProof (140) */ interface SpConsensusGrandpaEquivocationProof extends Struct { readonly setId: u64; readonly equivocation: SpConsensusGrandpaEquivocation; } - /** @name SpConsensusGrandpaEquivocation (116) */ + /** @name SpConsensusGrandpaEquivocation (141) */ interface SpConsensusGrandpaEquivocation extends Enum { readonly isPrevote: boolean; readonly asPrevote: FinalityGrandpaEquivocationPrevote; @@ -1076,7 +1237,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Prevote' | 'Precommit'; } - /** @name FinalityGrandpaEquivocationPrevote (117) */ + /** @name FinalityGrandpaEquivocationPrevote (142) */ interface FinalityGrandpaEquivocationPrevote extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1084,19 +1245,19 @@ declare module '@polkadot/types/lookup' { readonly second: ITuple<[FinalityGrandpaPrevote, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrevote (118) */ + /** @name FinalityGrandpaPrevote (143) */ interface FinalityGrandpaPrevote extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name SpConsensusGrandpaAppSignature (119) */ + /** @name SpConsensusGrandpaAppSignature (144) */ interface SpConsensusGrandpaAppSignature extends SpCoreEd25519Signature {} - /** @name SpCoreEd25519Signature (120) */ + /** @name SpCoreEd25519Signature (145) */ interface SpCoreEd25519Signature extends U8aFixed {} - /** @name FinalityGrandpaEquivocationPrecommit (123) */ + /** @name FinalityGrandpaEquivocationPrecommit (148) */ interface FinalityGrandpaEquivocationPrecommit extends Struct { readonly roundNumber: u64; readonly identity: SpConsensusGrandpaAppPublic; @@ -1104,16 +1265,16 @@ declare module '@polkadot/types/lookup' { readonly second: ITuple<[FinalityGrandpaPrecommit, SpConsensusGrandpaAppSignature]>; } - /** @name FinalityGrandpaPrecommit (124) */ + /** @name FinalityGrandpaPrecommit (149) */ interface FinalityGrandpaPrecommit extends Struct { readonly targetHash: H256; readonly targetNumber: u32; } - /** @name SpCoreVoid (126) */ + /** @name SpCoreVoid (151) */ type SpCoreVoid = Null; - /** @name PalletGrandpaError (127) */ + /** @name PalletGrandpaError (152) */ interface PalletGrandpaError extends Enum { readonly isPauseFailed: boolean; readonly isResumeFailed: boolean; @@ -1125,107 +1286,14 @@ declare module '@polkadot/types/lookup' { readonly type: 'PauseFailed' | 'ResumeFailed' | 'ChangePending' | 'TooSoon' | 'InvalidKeyOwnershipProof' | 'InvalidEquivocationProof' | 'DuplicateOffenceReport'; } - /** @name PalletBalancesBalanceLock (129) */ - interface PalletBalancesBalanceLock extends Struct { - readonly id: U8aFixed; - readonly amount: u128; - readonly reasons: PalletBalancesReasons; - } - - /** @name PalletBalancesReasons (130) */ - interface PalletBalancesReasons extends Enum { - readonly isFee: boolean; - readonly isMisc: boolean; - readonly isAll: boolean; - readonly type: 'Fee' | 'Misc' | 'All'; - } - - /** @name PalletBalancesReserveData (133) */ - interface PalletBalancesReserveData extends Struct { - readonly id: U8aFixed; - readonly amount: u128; - } - - /** @name PalletBalancesIdAmount (136) */ - interface PalletBalancesIdAmount extends Struct { - readonly id: Null; - readonly amount: u128; - } - - /** @name PalletBalancesCall (138) */ - interface PalletBalancesCall extends Enum { - readonly isTransferAllowDeath: boolean; - readonly asTransferAllowDeath: { - readonly dest: MultiAddress; - readonly value: Compact; - } & Struct; - readonly isSetBalanceDeprecated: boolean; - readonly asSetBalanceDeprecated: { - readonly who: MultiAddress; - readonly newFree: Compact; - readonly oldReserved: Compact; - } & Struct; - readonly isForceTransfer: boolean; - readonly asForceTransfer: { - readonly source: MultiAddress; - readonly dest: MultiAddress; - readonly value: Compact; - } & Struct; - readonly isTransferKeepAlive: boolean; - readonly asTransferKeepAlive: { - readonly dest: MultiAddress; - readonly value: Compact; - } & Struct; - readonly isTransferAll: boolean; - readonly asTransferAll: { - readonly dest: MultiAddress; - readonly keepAlive: bool; - } & Struct; - readonly isForceUnreserve: boolean; - readonly asForceUnreserve: { - readonly who: MultiAddress; - readonly amount: u128; - } & Struct; - readonly isUpgradeAccounts: boolean; - readonly asUpgradeAccounts: { - readonly who: Vec; - } & Struct; - readonly isTransfer: boolean; - readonly asTransfer: { - readonly dest: MultiAddress; - readonly value: Compact; - } & Struct; - readonly isForceSetBalance: boolean; - readonly asForceSetBalance: { - readonly who: MultiAddress; - readonly newFree: Compact; - } & Struct; - readonly type: 'TransferAllowDeath' | 'SetBalanceDeprecated' | 'ForceTransfer' | 'TransferKeepAlive' | 'TransferAll' | 'ForceUnreserve' | 'UpgradeAccounts' | 'Transfer' | 'ForceSetBalance'; - } - - /** @name PalletBalancesError (143) */ - interface PalletBalancesError extends Enum { - readonly isVestingBalance: boolean; - readonly isLiquidityRestrictions: boolean; - readonly isInsufficientBalance: boolean; - readonly isExistentialDeposit: boolean; - readonly isExpendability: boolean; - readonly isExistingVestingSchedule: boolean; - readonly isDeadAccount: boolean; - readonly isTooManyReserves: boolean; - readonly isTooManyHolds: boolean; - readonly isTooManyFreezes: boolean; - readonly type: 'VestingBalance' | 'LiquidityRestrictions' | 'InsufficientBalance' | 'ExistentialDeposit' | 'Expendability' | 'ExistingVestingSchedule' | 'DeadAccount' | 'TooManyReserves' | 'TooManyHolds' | 'TooManyFreezes'; - } - - /** @name PalletTransactionPaymentReleases (145) */ + /** @name PalletTransactionPaymentReleases (154) */ interface PalletTransactionPaymentReleases extends Enum { readonly isV1Ancient: boolean; readonly isV2: boolean; readonly type: 'V1Ancient' | 'V2'; } - /** @name PalletSudoCall (146) */ + /** @name PalletSudoCall (155) */ interface PalletSudoCall extends Enum { readonly isSudo: boolean; readonly asSudo: { @@ -1248,7 +1316,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Sudo' | 'SudoUncheckedWeight' | 'SetKey' | 'SudoAs'; } - /** @name PalletSchedulerCall (148) */ + /** @name PalletSchedulerCall (157) */ interface PalletSchedulerCall extends Enum { readonly isSchedule: boolean; readonly asSchedule: { @@ -1292,7 +1360,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Schedule' | 'Cancel' | 'ScheduleNamed' | 'CancelNamed' | 'ScheduleAfter' | 'ScheduleNamedAfter'; } - /** @name PalletCollectiveCall (150) */ + /** @name PalletCollectiveCall (159) */ interface PalletCollectiveCall extends Enum { readonly isSetMembers: boolean; readonly asSetMembers: { @@ -1331,24 +1399,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'SetMembers' | 'Execute' | 'Propose' | 'Vote' | 'DisapproveProposal' | 'Close'; } - /** @name SugarfungeValidatorSetCall (151) */ - interface SugarfungeValidatorSetCall extends Enum { - readonly isAddValidator: boolean; - readonly asAddValidator: { - readonly validatorId: AccountId32; - } & Struct; - readonly isRemoveValidator: boolean; - readonly asRemoveValidator: { - readonly validatorId: AccountId32; - } & Struct; - readonly isAddValidatorAgain: boolean; - readonly asAddValidatorAgain: { - readonly validatorId: AccountId32; - } & Struct; - readonly type: 'AddValidator' | 'RemoveValidator' | 'AddValidatorAgain'; - } - - /** @name PalletSessionCall (152) */ + /** @name PalletSessionCall (160) */ interface PalletSessionCall extends Enum { readonly isSetKeys: boolean; readonly asSetKeys: { @@ -1359,19 +1410,48 @@ declare module '@polkadot/types/lookup' { readonly type: 'SetKeys' | 'PurgeKeys'; } - /** @name SugarfungeRuntimeOpaqueSessionKeys (153) */ + /** @name SugarfungeRuntimeOpaqueSessionKeys (161) */ interface SugarfungeRuntimeOpaqueSessionKeys extends Struct { readonly aura: SpConsensusAuraSr25519AppSr25519Public; readonly grandpa: SpConsensusGrandpaAppPublic; + readonly imOnline: PalletImOnlineSr25519AppSr25519Public; } - /** @name SpConsensusAuraSr25519AppSr25519Public (154) */ + /** @name SpConsensusAuraSr25519AppSr25519Public (162) */ interface SpConsensusAuraSr25519AppSr25519Public extends SpCoreSr25519Public {} - /** @name SpCoreSr25519Public (155) */ - interface SpCoreSr25519Public extends U8aFixed {} + /** @name PalletImOnlineCall (163) */ + interface PalletImOnlineCall extends Enum { + readonly isHeartbeat: boolean; + readonly asHeartbeat: { + readonly heartbeat: PalletImOnlineHeartbeat; + readonly signature: PalletImOnlineSr25519AppSr25519Signature; + } & Struct; + readonly type: 'Heartbeat'; + } + + /** @name PalletImOnlineHeartbeat (164) */ + interface PalletImOnlineHeartbeat extends Struct { + readonly blockNumber: u32; + readonly networkState: SpCoreOffchainOpaqueNetworkState; + readonly sessionIndex: u32; + readonly authorityIndex: u32; + readonly validatorsLen: u32; + } + + /** @name SpCoreOffchainOpaqueNetworkState (165) */ + interface SpCoreOffchainOpaqueNetworkState extends Struct { + readonly peerId: OpaquePeerId; + readonly externalAddresses: Vec; + } + + /** @name PalletImOnlineSr25519AppSr25519Signature (169) */ + interface PalletImOnlineSr25519AppSr25519Signature extends SpCoreSr25519Signature {} + + /** @name SpCoreSr25519Signature (170) */ + interface SpCoreSr25519Signature extends U8aFixed {} - /** @name SugarfungeAssetCall (156) */ + /** @name SugarfungeAssetCall (171) */ interface SugarfungeAssetCall extends Enum { readonly isCreateClass: boolean; readonly asCreateClass: { @@ -1443,7 +1523,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'CreateClass' | 'CreateAsset' | 'TransferFrom' | 'BatchTransferFrom' | 'Mint' | 'BatchMint' | 'Burn' | 'BatchBurn' | 'UpdateClassMetadata' | 'UpdateAssetMetadata'; } - /** @name SugarfungeDaoCall (159) */ + /** @name SugarfungeDaoCall (174) */ interface SugarfungeDaoCall extends Enum { readonly isDoSomething: boolean; readonly asDoSomething: { @@ -1453,7 +1533,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'DoSomething' | 'CauseError'; } - /** @name SugarfungeBundleCall (160) */ + /** @name SugarfungeBundleCall (175) */ interface SugarfungeBundleCall extends Enum { readonly isRegisterBundle: boolean; readonly asRegisterBundle: { @@ -1480,7 +1560,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'RegisterBundle' | 'MintBundle' | 'BurnBundle'; } - /** @name SugarfungeBagCall (168) */ + /** @name SugarfungeBagCall (183) */ interface SugarfungeBagCall extends Enum { readonly isRegister: boolean; readonly asRegister: { @@ -1508,7 +1588,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Register' | 'Create' | 'Deposit' | 'Sweep'; } - /** @name SugarfungeExgineCall (169) */ + /** @name SugarfungeExgineCall (184) */ interface SugarfungeExgineCall extends Enum { readonly isDoSomething: boolean; readonly asDoSomething: { @@ -1518,7 +1598,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'DoSomething' | 'CauseError'; } - /** @name SugarfungeMarketCall (170) */ + /** @name SugarfungeMarketCall (185) */ interface SugarfungeMarketCall extends Enum { readonly isCreateMarket: boolean; readonly asCreateMarket: { @@ -1545,7 +1625,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'CreateMarket' | 'CreateMarketRate' | 'Deposit' | 'ExchangeAssets'; } - /** @name FunctionlandFulaCall (173) */ + /** @name FunctionlandFulaCall (188) */ interface FunctionlandFulaCall extends Enum { readonly isUpdateManifest: boolean; readonly asUpdateManifest: { @@ -1644,7 +1724,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'UpdateManifest' | 'UploadManifest' | 'BatchUploadManifest' | 'StorageManifest' | 'BatchStorageManifest' | 'RemoveStoredManifest' | 'BatchRemoveStoredManifest' | 'RemoveManifest' | 'BatchRemoveManifest' | 'VerifyManifests' | 'GetManifests' | 'GetAvailableManifests' | 'GetManifestsStorerData' | 'GenerateChallenge' | 'VerifyChallenge' | 'MintLaborTokens' | 'UpdateFileSize' | 'UpdateFileSizes'; } - /** @name FulaPoolCall (177) */ + /** @name FulaPoolCall (192) */ interface FulaPoolCall extends Enum { readonly isCreate: boolean; readonly asCreate: { @@ -1655,6 +1735,7 @@ declare module '@polkadot/types/lookup' { readonly isLeavePool: boolean; readonly asLeavePool: { readonly poolId: u32; + readonly targetAccount: Option; } & Struct; readonly isJoin: boolean; readonly asJoin: { @@ -1664,6 +1745,7 @@ declare module '@polkadot/types/lookup' { readonly isCancelJoin: boolean; readonly asCancelJoin: { readonly poolId: u32; + readonly targetAccount: Option; } & Struct; readonly isVote: boolean; readonly asVote: { @@ -1675,38 +1757,39 @@ declare module '@polkadot/types/lookup' { readonly type: 'Create' | 'LeavePool' | 'Join' | 'CancelJoin' | 'Vote'; } - /** @name PalletSudoError (179) */ - interface PalletSudoError extends Enum { - readonly isRequireSudo: boolean; - readonly type: 'RequireSudo'; - } - - /** @name PalletSchedulerScheduled (182) */ - interface PalletSchedulerScheduled extends Struct { - readonly maybeId: Option; - readonly priority: u8; - readonly call: FrameSupportPreimagesBounded; - readonly maybePeriodic: Option>; - readonly origin: SugarfungeRuntimeOriginCaller; - } - - /** @name FrameSupportPreimagesBounded (183) */ - interface FrameSupportPreimagesBounded extends Enum { - readonly isLegacy: boolean; - readonly asLegacy: { - readonly hash_: H256; + /** @name PalletUtilityCall (194) */ + interface PalletUtilityCall extends Enum { + readonly isBatch: boolean; + readonly asBatch: { + readonly calls: Vec; } & Struct; - readonly isInline: boolean; - readonly asInline: Bytes; - readonly isLookup: boolean; - readonly asLookup: { - readonly hash_: H256; - readonly len: u32; + readonly isAsDerivative: boolean; + readonly asAsDerivative: { + readonly index: u16; + readonly call: Call; } & Struct; - readonly type: 'Legacy' | 'Inline' | 'Lookup'; + readonly isBatchAll: boolean; + readonly asBatchAll: { + readonly calls: Vec; + } & Struct; + readonly isDispatchAs: boolean; + readonly asDispatchAs: { + readonly asOrigin: SugarfungeRuntimeOriginCaller; + readonly call: Call; + } & Struct; + readonly isForceBatch: boolean; + readonly asForceBatch: { + readonly calls: Vec; + } & Struct; + readonly isWithWeight: boolean; + readonly asWithWeight: { + readonly call: Call; + readonly weight: SpWeightsWeightV2Weight; + } & Struct; + readonly type: 'Batch' | 'AsDerivative' | 'BatchAll' | 'DispatchAs' | 'ForceBatch' | 'WithWeight'; } - /** @name SugarfungeRuntimeOriginCaller (185) */ + /** @name SugarfungeRuntimeOriginCaller (196) */ interface SugarfungeRuntimeOriginCaller extends Enum { readonly isSystem: boolean; readonly asSystem: FrameSupportDispatchRawOrigin; @@ -1716,7 +1799,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'System' | 'Void' | 'Council'; } - /** @name FrameSupportDispatchRawOrigin (186) */ + /** @name FrameSupportDispatchRawOrigin (197) */ interface FrameSupportDispatchRawOrigin extends Enum { readonly isRoot: boolean; readonly isSigned: boolean; @@ -1725,7 +1808,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'Root' | 'Signed' | 'None'; } - /** @name PalletCollectiveRawOrigin (187) */ + /** @name PalletCollectiveRawOrigin (198) */ interface PalletCollectiveRawOrigin extends Enum { readonly isMembers: boolean; readonly asMembers: ITuple<[u32, u32]>; @@ -1735,7 +1818,38 @@ declare module '@polkadot/types/lookup' { readonly type: 'Members' | 'Member' | 'Phantom'; } - /** @name PalletSchedulerError (189) */ + /** @name PalletSudoError (199) */ + interface PalletSudoError extends Enum { + readonly isRequireSudo: boolean; + readonly type: 'RequireSudo'; + } + + /** @name PalletSchedulerScheduled (202) */ + interface PalletSchedulerScheduled extends Struct { + readonly maybeId: Option; + readonly priority: u8; + readonly call: FrameSupportPreimagesBounded; + readonly maybePeriodic: Option>; + readonly origin: SugarfungeRuntimeOriginCaller; + } + + /** @name FrameSupportPreimagesBounded (203) */ + interface FrameSupportPreimagesBounded extends Enum { + readonly isLegacy: boolean; + readonly asLegacy: { + readonly hash_: H256; + } & Struct; + readonly isInline: boolean; + readonly asInline: Bytes; + readonly isLookup: boolean; + readonly asLookup: { + readonly hash_: H256; + readonly len: u32; + } & Struct; + readonly type: 'Legacy' | 'Inline' | 'Lookup'; + } + + /** @name PalletSchedulerError (206) */ interface PalletSchedulerError extends Enum { readonly isFailedToSchedule: boolean; readonly isNotFound: boolean; @@ -1745,7 +1859,7 @@ declare module '@polkadot/types/lookup' { readonly type: 'FailedToSchedule' | 'NotFound' | 'TargetBlockNumberInPast' | 'RescheduleNoChange' | 'Named'; } - /** @name PalletCollectiveVotes (191) */ + /** @name PalletCollectiveVotes (208) */ interface PalletCollectiveVotes extends Struct { readonly index: u32; readonly threshold: u32; @@ -1754,7 +1868,7 @@ declare module '@polkadot/types/lookup' { readonly end: u32; } - /** @name PalletCollectiveError (192) */ + /** @name PalletCollectiveError (209) */ interface PalletCollectiveError extends Enum { readonly isNotMember: boolean; readonly isDuplicateProposal: boolean; @@ -1769,19 +1883,10 @@ declare module '@polkadot/types/lookup' { readonly type: 'NotMember' | 'DuplicateProposal' | 'ProposalMissing' | 'WrongIndex' | 'DuplicateVote' | 'AlreadyInitialized' | 'TooEarly' | 'TooManyProposals' | 'WrongProposalWeight' | 'WrongProposalLength'; } - /** @name SugarfungeValidatorSetError (194) */ - interface SugarfungeValidatorSetError extends Enum { - readonly isTooLowValidatorCount: boolean; - readonly isDuplicate: boolean; - readonly isValidatorNotApproved: boolean; - readonly isBadOrigin: boolean; - readonly type: 'TooLowValidatorCount' | 'Duplicate' | 'ValidatorNotApproved' | 'BadOrigin'; - } - - /** @name SpCoreCryptoKeyTypeId (198) */ + /** @name SpCoreCryptoKeyTypeId (213) */ interface SpCoreCryptoKeyTypeId extends U8aFixed {} - /** @name PalletSessionError (199) */ + /** @name PalletSessionError (214) */ interface PalletSessionError extends Enum { readonly isInvalidProof: boolean; readonly isNoAssociatedValidatorId: boolean; @@ -1791,20 +1896,33 @@ declare module '@polkadot/types/lookup' { readonly type: 'InvalidProof' | 'NoAssociatedValidatorId' | 'DuplicatedKey' | 'NoKeys' | 'NoAccount'; } - /** @name SugarfungeAssetClass (200) */ + /** @name PalletImOnlineBoundedOpaqueNetworkState (218) */ + interface PalletImOnlineBoundedOpaqueNetworkState extends Struct { + readonly peerId: Bytes; + readonly externalAddresses: Vec; + } + + /** @name PalletImOnlineError (223) */ + interface PalletImOnlineError extends Enum { + readonly isInvalidKey: boolean; + readonly isDuplicatedHeartbeat: boolean; + readonly type: 'InvalidKey' | 'DuplicatedHeartbeat'; + } + + /** @name SugarfungeAssetClass (224) */ interface SugarfungeAssetClass extends Struct { readonly owner: AccountId32; readonly metadata: Bytes; } - /** @name SugarfungeAssetAsset (202) */ + /** @name SugarfungeAssetAsset (226) */ interface SugarfungeAssetAsset extends Struct { readonly classId: u64; readonly creator: AccountId32; readonly metadata: Bytes; } - /** @name SugarfungeAssetError (204) */ + /** @name SugarfungeAssetError (228) */ interface SugarfungeAssetError extends Enum { readonly isUnknown: boolean; readonly isInUse: boolean; @@ -1820,14 +1938,14 @@ declare module '@polkadot/types/lookup' { readonly type: 'Unknown' | 'InUse' | 'InvalidAssetId' | 'InsufficientBalance' | 'NumOverflow' | 'InvalidArrayLength' | 'Overflow' | 'InvalidClassId' | 'NoPermission' | 'ClassNotFound' | 'AssetNotFound'; } - /** @name SugarfungeDaoError (205) */ + /** @name SugarfungeDaoError (229) */ interface SugarfungeDaoError extends Enum { readonly isNoneValue: boolean; readonly isStorageOverflow: boolean; readonly type: 'NoneValue' | 'StorageOverflow'; } - /** @name SugarfungeBundleBundle (206) */ + /** @name SugarfungeBundleBundle (230) */ interface SugarfungeBundleBundle extends Struct { readonly creator: AccountId32; readonly classId: u64; @@ -1837,10 +1955,10 @@ declare module '@polkadot/types/lookup' { readonly vault: AccountId32; } - /** @name FrameSupportPalletId (207) */ + /** @name FrameSupportPalletId (231) */ interface FrameSupportPalletId extends U8aFixed {} - /** @name SugarfungeBundleError (208) */ + /** @name SugarfungeBundleError (232) */ interface SugarfungeBundleError extends Enum { readonly isInvalidBundleIdForBundle: boolean; readonly isBundleExists: boolean; @@ -1853,13 +1971,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'InvalidBundleIdForBundle' | 'BundleExists' | 'BundleNotFound' | 'NumOverflow' | 'InvalidArrayLength' | 'InsufficientBalance' | 'AssetExists' | 'AccountNotOwner'; } - /** @name SugarfungeBagBagClass (209) */ + /** @name SugarfungeBagBagClass (233) */ interface SugarfungeBagBagClass extends Struct { readonly operator: AccountId32; readonly classId: u64; } - /** @name SugarfungeBagBag (210) */ + /** @name SugarfungeBagBag (234) */ interface SugarfungeBagBag extends Struct { readonly operator: AccountId32; readonly classId: u64; @@ -1867,7 +1985,7 @@ declare module '@polkadot/types/lookup' { readonly totalShares: u128; } - /** @name SugarfungeBagError (211) */ + /** @name SugarfungeBagError (235) */ interface SugarfungeBagError extends Enum { readonly isBagClassExists: boolean; readonly isBagExists: boolean; @@ -1880,20 +1998,20 @@ declare module '@polkadot/types/lookup' { readonly type: 'BagClassExists' | 'BagExists' | 'InvalidBagClass' | 'InvalidBag' | 'InvalidBagOperator' | 'InvalidBagOwner' | 'InvalidArrayLength' | 'InsufficientShares'; } - /** @name SugarfungeExgineError (212) */ + /** @name SugarfungeExgineError (236) */ interface SugarfungeExgineError extends Enum { readonly isNoneValue: boolean; readonly isStorageOverflow: boolean; readonly type: 'NoneValue' | 'StorageOverflow'; } - /** @name SugarfungeMarketMarket (213) */ + /** @name SugarfungeMarketMarket (237) */ interface SugarfungeMarketMarket extends Struct { readonly owner: AccountId32; readonly vault: AccountId32; } - /** @name SugarfungeMarketError (215) */ + /** @name SugarfungeMarketError (239) */ interface SugarfungeMarketError extends Enum { readonly isOverflow: boolean; readonly isInsufficientAmount: boolean; @@ -1917,27 +2035,27 @@ declare module '@polkadot/types/lookup' { readonly type: 'Overflow' | 'InsufficientAmount' | 'InsufficientLiquidity' | 'InvalidMarket' | 'InvalidMarketRate' | 'InvalidMarketOwner' | 'NotAuthorizedToMintAsset' | 'MarketExists' | 'MarketRateExists' | 'InvalidAsset' | 'InvalidAssetRate' | 'InvalidRateAccount' | 'InvalidRateAmount' | 'InvalidBurnPrice' | 'InvalidBurnBalance' | 'InvalidTransferPrice' | 'InvalidTransferBalance' | 'InvalidBuyer' | 'InvalidArrayLength'; } - /** @name FunctionlandFulaManifest (217) */ + /** @name FunctionlandFulaManifest (241) */ interface FunctionlandFulaManifest extends Struct { readonly usersData: Vec; readonly manifestMetadata: Bytes; readonly size_: Option; } - /** @name FunctionlandFulaChallenge (220) */ + /** @name FunctionlandFulaChallenge (244) */ interface FunctionlandFulaChallenge extends Struct { readonly challenger: AccountId32; readonly challengeState: FunctionlandFulaChallengeState; } - /** @name FunctionlandFulaClaimData (221) */ + /** @name FunctionlandFulaClaimData (245) */ interface FunctionlandFulaClaimData extends Struct { readonly mintedLaborTokens: u128; readonly expectedLaborTokens: u128; readonly challengeTokens: u128; } - /** @name FunctionlandFulaError (222) */ + /** @name FunctionlandFulaError (246) */ interface FunctionlandFulaError extends Enum { readonly isNoneValue: boolean; readonly isStorageOverflow: boolean; @@ -1957,10 +2075,11 @@ declare module '@polkadot/types/lookup' { readonly isManifestStorerDataNotFound: boolean; readonly isNoFileSizeProvided: boolean; readonly isNoAccountsToChallenge: boolean; - readonly type: 'NoneValue' | 'StorageOverflow' | 'ReplicationFactorLimitReached' | 'ReplicationFactorInvalid' | 'AccountAlreadyStorer' | 'AccountNotStorer' | 'AccountNotInPool' | 'AccountNotUploader' | 'AccountNotFound' | 'ManifestAlreadyExist' | 'ManifestNotFound' | 'ManifestNotStored' | 'InvalidArrayLength' | 'ErrorPickingCIDToChallenge' | 'ErrorPickingAccountToChallenge' | 'ManifestStorerDataNotFound' | 'NoFileSizeProvided' | 'NoAccountsToChallenge'; + readonly isFileAlreadyUploadedbyUser: boolean; + readonly type: 'NoneValue' | 'StorageOverflow' | 'ReplicationFactorLimitReached' | 'ReplicationFactorInvalid' | 'AccountAlreadyStorer' | 'AccountNotStorer' | 'AccountNotInPool' | 'AccountNotUploader' | 'AccountNotFound' | 'ManifestAlreadyExist' | 'ManifestNotFound' | 'ManifestNotStored' | 'InvalidArrayLength' | 'ErrorPickingCIDToChallenge' | 'ErrorPickingAccountToChallenge' | 'ManifestStorerDataNotFound' | 'NoFileSizeProvided' | 'NoAccountsToChallenge' | 'FileAlreadyUploadedbyUser'; } - /** @name FulaPoolPool (223) */ + /** @name FulaPoolPool (247) */ interface FulaPoolPool extends Struct { readonly name: Bytes; readonly owner: Option; @@ -1970,21 +2089,21 @@ declare module '@polkadot/types/lookup' { readonly region: Bytes; } - /** @name FulaPoolPoolRequest (226) */ + /** @name FulaPoolPoolRequest (249) */ interface FulaPoolPoolRequest extends Struct { readonly voted: Vec; readonly positiveVotes: u16; readonly peerId: Bytes; } - /** @name FulaPoolUser (227) */ + /** @name FulaPoolUser (250) */ interface FulaPoolUser extends Struct { readonly poolId: Option; readonly requestPoolId: Option; readonly peerId: Bytes; } - /** @name FulaPoolError (228) */ + /** @name FulaPoolError (251) */ interface FulaPoolError extends Enum { readonly isUserBusy: boolean; readonly isMaxPools: boolean; @@ -1999,7 +2118,13 @@ declare module '@polkadot/types/lookup' { readonly type: 'UserBusy' | 'MaxPools' | 'NameTooLong' | 'PoolDoesNotExist' | 'RequestDoesNotExist' | 'CapacityReached' | 'UserDoesNotExist' | 'AccessDenied' | 'InternalError' | 'AlreadyVoted'; } - /** @name SpRuntimeMultiSignature (230) */ + /** @name PalletUtilityError (252) */ + interface PalletUtilityError extends Enum { + readonly isTooManyCalls: boolean; + readonly type: 'TooManyCalls'; + } + + /** @name SpRuntimeMultiSignature (254) */ interface SpRuntimeMultiSignature extends Enum { readonly isEd25519: boolean; readonly asEd25519: SpCoreEd25519Signature; @@ -2010,34 +2135,31 @@ declare module '@polkadot/types/lookup' { readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa'; } - /** @name SpCoreSr25519Signature (231) */ - interface SpCoreSr25519Signature extends U8aFixed {} - - /** @name SpCoreEcdsaSignature (232) */ + /** @name SpCoreEcdsaSignature (255) */ interface SpCoreEcdsaSignature extends U8aFixed {} - /** @name FrameSystemExtensionsCheckNonZeroSender (235) */ + /** @name FrameSystemExtensionsCheckNonZeroSender (258) */ type FrameSystemExtensionsCheckNonZeroSender = Null; - /** @name FrameSystemExtensionsCheckSpecVersion (236) */ + /** @name FrameSystemExtensionsCheckSpecVersion (259) */ type FrameSystemExtensionsCheckSpecVersion = Null; - /** @name FrameSystemExtensionsCheckTxVersion (237) */ + /** @name FrameSystemExtensionsCheckTxVersion (260) */ type FrameSystemExtensionsCheckTxVersion = Null; - /** @name FrameSystemExtensionsCheckGenesis (238) */ + /** @name FrameSystemExtensionsCheckGenesis (261) */ type FrameSystemExtensionsCheckGenesis = Null; - /** @name FrameSystemExtensionsCheckNonce (241) */ + /** @name FrameSystemExtensionsCheckNonce (264) */ interface FrameSystemExtensionsCheckNonce extends Compact {} - /** @name FrameSystemExtensionsCheckWeight (242) */ + /** @name FrameSystemExtensionsCheckWeight (265) */ type FrameSystemExtensionsCheckWeight = Null; - /** @name PalletTransactionPaymentChargeTransactionPayment (243) */ + /** @name PalletTransactionPaymentChargeTransactionPayment (266) */ interface PalletTransactionPaymentChargeTransactionPayment extends Compact {} - /** @name SugarfungeRuntimeRuntime (244) */ + /** @name SugarfungeRuntimeRuntime (267) */ type SugarfungeRuntimeRuntime = Null; } // declare module