All chains
    Preparing search index...

    Type Alias dry_run_call

    dry_run_call: RuntimeDescriptor<
        [
            origin: Enum<
                {
                    CumulusXcm: Enum<{ Relay: undefined; SiblingParachain: number }>;
                    Origins: Enum<
                        {
                            AuctionAdmin: undefined;
                            BigSpender: undefined;
                            BigTipper: undefined;
                            FellowshipAdmin: undefined;
                            GeneralAdmin: undefined;
                            LeaseAdmin: undefined;
                            MediumSpender: undefined;
                            ReferendumCanceller: undefined;
                            ReferendumKiller: undefined;
                            SmallSpender: undefined;
                            SmallTipper: undefined;
                            StakingAdmin: undefined;
                            Treasurer: undefined;
                            WhitelistedCaller: undefined;
                        },
                    >;
                    PolkadotXcm: Enum<
                        {
                            Response: { interior: XcmV5Junctions; parents: number };
                            Xcm: { interior: XcmV5Junctions; parents: number };
                        },
                    >;
                    Revive: Enum<{ EthTransaction: SS58String }>;
                    system: Enum<
                        {
                            Authorized: undefined;
                            None: undefined;
                            Root: undefined;
                            Signed: SS58String;
                        },
                    >;
                },
            >,
            call: TxCallData,
            result_xcms_version: number,
        ],
        ResultPayload<
            {
                emitted_events: Enum<
                    {
                        AhOps: Enum<
                            {
                                CrowdloanUnreserveRemaining: {
                                    depositor: SS58String;
                                    para_id: number;
                                    remaining: bigint;
                                };
                                HoldPlaced: {
                                    account: SS58String;
                                    amount: bigint;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                };
                                HoldReleased: {
                                    account: SS58String;
                                    amount: bigint;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                };
                                LeaseUnreserveRemaining: {
                                    depositor: SS58String;
                                    para_id: number;
                                    remaining: bigint;
                                };
                                SovereignMigrated: {
                                    derivation_index?: ...;
                                    from: SS58String;
                                    para_id: number;
                                    to: SS58String;
                                };
                            },
                        >;
                        AssetConversion: Enum<
                            {
                                LiquidityAdded: {
                                    amount1_provided: bigint;
                                    amount2_provided: bigint;
                                    lp_token: number;
                                    lp_token_minted: bigint;
                                    mint_to: SS58String;
                                    pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                    who: SS58String;
                                };
                                LiquidityRemoved: {
                                    amount1: bigint;
                                    amount2: bigint;
                                    lp_token: number;
                                    lp_token_burned: bigint;
                                    pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                    who: SS58String;
                                    withdraw_to: SS58String;
                                    withdrawal_fee: number;
                                };
                                PoolCreated: {
                                    creator: SS58String;
                                    lp_token: number;
                                    pool_account: SS58String;
                                    pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                };
                                SwapCreditExecuted: {
                                    amount_in: bigint;
                                    amount_out: bigint;
                                    path: [(...), (...)][];
                                };
                                SwapExecuted: {
                                    amount_in: bigint;
                                    amount_out: bigint;
                                    path: [(...), (...)][];
                                    send_to: SS58String;
                                    who: SS58String;
                                };
                                Touched: {
                                    pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                    who: SS58String;
                                };
                            },
                        >;
                        AssetConversionMigration: Enum<
                            {
                                MigratedToNewAccount: {
                                    new_account: SS58String;
                                    pool_id: FixedSizeArray<2, { interior: ...; parents: ... }>;
                                    prior_account: SS58String;
                                };
                            },
                        >;
                        AssetRate: Enum<
                            {
                                AssetRateCreated: {
                                    asset_kind: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                    rate: bigint;
                                };
                                AssetRateRemoved: { asset_kind: Enum<{ V3: ...; V4: ...; V5: ... }> };
                                AssetRateUpdated: {
                                    asset_kind: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                    new: bigint;
                                    old: bigint;
                                };
                            },
                        >;
                        AssetRewards: Enum<
                            {
                                PoolAdminModified: { new_admin: SS58String; pool_id: number };
                                PoolCleanedUp: { pool_id: number };
                                PoolCreated: {
                                    admin: SS58String;
                                    creator: SS58String;
                                    expiry_block: number;
                                    pool_id: number;
                                    reward_asset_id: { interior: XcmV5Junctions; parents: number };
                                    reward_rate_per_block: bigint;
                                    staked_asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                PoolExpiryBlockModified: {
                                    new_expiry_block: number;
                                    pool_id: number;
                                };
                                PoolRewardRateModified: {
                                    new_reward_rate_per_block: bigint;
                                    pool_id: number;
                                };
                                RewardsHarvested: {
                                    amount: bigint;
                                    caller: SS58String;
                                    pool_id: number;
                                    staker: SS58String;
                                };
                                Staked: { amount: bigint; pool_id: number; staker: SS58String };
                                Unstaked: {
                                    amount: bigint;
                                    caller: SS58String;
                                    pool_id: number;
                                    staker: SS58String;
                                };
                            },
                        >;
                        Assets: Enum<
                            {
                                AccountsDestroyed: {
                                    accounts_destroyed: number;
                                    accounts_remaining: number;
                                    asset_id: number;
                                };
                                ApprovalCancelled: {
                                    asset_id: number;
                                    delegate: SS58String;
                                    owner: SS58String;
                                };
                                ApprovalsDestroyed: {
                                    approvals_destroyed: number;
                                    approvals_remaining: number;
                                    asset_id: number;
                                };
                                ApprovedTransfer: {
                                    amount: bigint;
                                    asset_id: number;
                                    delegate: SS58String;
                                    source: SS58String;
                                };
                                AssetFrozen: { asset_id: number };
                                AssetMinBalanceChanged: { asset_id: number; new_min_balance: bigint };
                                AssetStatusChanged: { asset_id: number };
                                AssetThawed: { asset_id: number };
                                Blocked: { asset_id: number; who: SS58String };
                                Burned: { asset_id: number; balance: bigint; owner: SS58String };
                                Created: { asset_id: number; creator: SS58String; owner: SS58String };
                                Deposited: { amount: bigint; asset_id: number; who: SS58String };
                                Destroyed: { asset_id: number };
                                DestructionStarted: { asset_id: number };
                                ForceCreated: { asset_id: number; owner: SS58String };
                                Frozen: { asset_id: number; who: SS58String };
                                Issued: { amount: bigint; asset_id: number; owner: SS58String };
                                MetadataCleared: { asset_id: number };
                                MetadataSet: {
                                    asset_id: number;
                                    decimals: number;
                                    is_frozen: boolean;
                                    name: Binary;
                                    symbol: Binary;
                                };
                                OwnerChanged: { asset_id: number; owner: SS58String };
                                TeamChanged: {
                                    admin: SS58String;
                                    asset_id: number;
                                    freezer: SS58String;
                                    issuer: SS58String;
                                };
                                Thawed: { asset_id: number; who: SS58String };
                                Touched: { asset_id: number; depositor: SS58String; who: SS58String };
                                Transferred: {
                                    amount: bigint;
                                    asset_id: number;
                                    from: SS58String;
                                    to: SS58String;
                                };
                                TransferredApproved: {
                                    amount: bigint;
                                    asset_id: number;
                                    delegate: SS58String;
                                    destination: SS58String;
                                    owner: SS58String;
                                };
                                Withdrawn: { amount: bigint; asset_id: number; who: SS58String };
                            },
                        >;
                        AssetsFreezer: Enum<
                            {
                                Frozen: { amount: bigint; asset_id: number; who: SS58String };
                                Thawed: { amount: bigint; asset_id: number; who: SS58String };
                            },
                        >;
                        AssetTxPayment: Enum<
                            {
                                AssetRefundFailed: { native_amount_kept: bigint };
                                AssetTxFeePaid: {
                                    actual_fee: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    tip: bigint;
                                    who: SS58String;
                                };
                            },
                        >;
                        Balances: Enum<
                            {
                                BalanceSet: { free: bigint; who: SS58String };
                                Burned: { amount: bigint; who: SS58String };
                                BurnedDebt: { amount: bigint };
                                BurnedHeld: {
                                    amount: bigint;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                    who: SS58String;
                                };
                                Deposit: { amount: bigint; who: SS58String };
                                DustLost: { account: SS58String; amount: bigint };
                                Endowed: { account: SS58String; free_balance: bigint };
                                Frozen: { amount: bigint; who: SS58String };
                                Held: {
                                    amount: bigint;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                    who: SS58String;
                                };
                                Issued: { amount: bigint };
                                Locked: { amount: bigint; who: SS58String };
                                Minted: { amount: bigint; who: SS58String };
                                MintedCredit: { amount: bigint };
                                Released: {
                                    amount: bigint;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                    who: SS58String;
                                };
                                Rescinded: { amount: bigint };
                                Reserved: { amount: bigint; who: SS58String };
                                ReserveRepatriated: {
                                    amount: bigint;
                                    destination_status: BalanceStatus;
                                    from: SS58String;
                                    to: SS58String;
                                };
                                Restored: { amount: bigint; who: SS58String };
                                Slashed: { amount: bigint; who: SS58String };
                                Suspended: { amount: bigint; who: SS58String };
                                Thawed: { amount: bigint; who: SS58String };
                                TotalIssuanceForced: { new: bigint; old: bigint };
                                Transfer: { amount: bigint; from: SS58String; to: SS58String };
                                TransferAndHold: {
                                    dest: SS58String;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                    source: SS58String;
                                    transferred: bigint;
                                };
                                TransferOnHold: {
                                    amount: bigint;
                                    dest: SS58String;
                                    reason: Enum<
                                        {
                                            AssetRewards: ...;
                                            DelegatedStaking: ...;
                                            MultiBlockElectionSigned: ...;
                                            NftFractionalization: ...;
                                            PolkadotXcm: ...;
                                            Preimage: ...;
                                            Revive: ...;
                                            Session: ...;
                                            Staking: ...;
                                            StateTrieMigration: ...;
                                        },
                                    >;
                                    source: SS58String;
                                };
                                Unexpected: Enum<
                                    { BalanceUpdated: undefined; FailedToMutateAccount: undefined },
                                >;
                                Unlocked: { amount: bigint; who: SS58String };
                                Unreserved: { amount: bigint; who: SS58String };
                                Upgraded: { who: SS58String };
                                Withdraw: { amount: bigint; who: SS58String };
                            },
                        >;
                        CollatorSelection: Enum<
                            {
                                CandidateAdded: { account_id: SS58String; deposit: bigint };
                                CandidateBondUpdated: { account_id: SS58String; deposit: bigint };
                                CandidateRemoved: { account_id: SS58String };
                                CandidateReplaced: {
                                    deposit: bigint;
                                    new: SS58String;
                                    old: SS58String;
                                };
                                InvalidInvulnerableSkipped: { account_id: SS58String };
                                InvulnerableAdded: { account_id: SS58String };
                                InvulnerableRemoved: { account_id: SS58String };
                                NewCandidacyBond: { bond_amount: bigint };
                                NewDesiredCandidates: { desired_candidates: number };
                                NewInvulnerables: { invulnerables: SS58String[] };
                            },
                        >;
                        ConvictionVoting: Enum<
                            {
                                Delegated: [SS58String, SS58String, number];
                                Undelegated: [SS58String, number];
                                Voted: {
                                    poll_index: number;
                                    vote: ConvictionVotingVoteAccountVote;
                                    who: SS58String;
                                };
                                VoteRemoved: {
                                    poll_index: number;
                                    vote: ConvictionVotingVoteAccountVote;
                                    who: SS58String;
                                };
                                VoteUnlocked: { class: number; who: SS58String };
                            },
                        >;
                        CumulusXcm: Enum<
                            {
                                ExecutedDownward: [
                                    FixedSizeBinary<32>,
                                    Enum<{ Complete: ...; Error: ...; Incomplete: ... }>,
                                ];
                                InvalidFormat: FixedSizeBinary<32>;
                                UnsupportedVersion: FixedSizeBinary<32>;
                            },
                        >;
                        DelegatedStaking: Enum<
                            {
                                Delegated: {
                                    agent: SS58String;
                                    amount: bigint;
                                    delegator: SS58String;
                                };
                                MigratedDelegation: {
                                    agent: SS58String;
                                    amount: bigint;
                                    delegator: SS58String;
                                };
                                Released: {
                                    agent: SS58String;
                                    amount: bigint;
                                    delegator: SS58String;
                                };
                                Slashed: { agent: SS58String; amount: bigint; delegator: SS58String };
                            },
                        >;
                        FastUnstake: Enum<
                            {
                                BatchChecked: { eras: number[] };
                                BatchFinished: { size: number };
                                InternalError: undefined;
                                Slashed: { amount: bigint; stash: SS58String };
                                Unstaked: {
                                    result: ResultPayload<undefined, Enum<(...)>>;
                                    stash: SS58String;
                                };
                            },
                        >;
                        ForeignAssets: Enum<
                            {
                                AccountsDestroyed: {
                                    accounts_destroyed: number;
                                    accounts_remaining: number;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                ApprovalCancelled: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    delegate: SS58String;
                                    owner: SS58String;
                                };
                                ApprovalsDestroyed: {
                                    approvals_destroyed: number;
                                    approvals_remaining: number;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                ApprovedTransfer: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    delegate: SS58String;
                                    source: SS58String;
                                };
                                AssetFrozen: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                AssetMinBalanceChanged: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    new_min_balance: bigint;
                                };
                                AssetStatusChanged: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                AssetThawed: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                Blocked: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                                Burned: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    balance: bigint;
                                    owner: SS58String;
                                };
                                Created: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    creator: SS58String;
                                    owner: SS58String;
                                };
                                Deposited: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                                Destroyed: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                DestructionStarted: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                ForceCreated: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    owner: SS58String;
                                };
                                Frozen: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                                Issued: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    owner: SS58String;
                                };
                                MetadataCleared: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                };
                                MetadataSet: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    decimals: number;
                                    is_frozen: boolean;
                                    name: Binary;
                                    symbol: Binary;
                                };
                                OwnerChanged: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    owner: SS58String;
                                };
                                TeamChanged: {
                                    admin: SS58String;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    freezer: SS58String;
                                    issuer: SS58String;
                                };
                                Thawed: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                                Touched: {
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    depositor: SS58String;
                                    who: SS58String;
                                };
                                Transferred: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    from: SS58String;
                                    to: SS58String;
                                };
                                TransferredApproved: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    delegate: SS58String;
                                    destination: SS58String;
                                    owner: SS58String;
                                };
                                Withdrawn: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                            },
                        >;
                        ForeignAssetsFreezer: Enum<
                            {
                                Frozen: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                                Thawed: {
                                    amount: bigint;
                                    asset_id: { interior: XcmV5Junctions; parents: number };
                                    who: SS58String;
                                };
                            },
                        >;
                        Indices: Enum<
                            {
                                DepositPoked: {
                                    index: number;
                                    new_deposit: bigint;
                                    old_deposit: bigint;
                                    who: SS58String;
                                };
                                IndexAssigned: { index: number; who: SS58String };
                                IndexFreed: { index: number };
                                IndexFrozen: { index: number; who: SS58String };
                            },
                        >;
                        MessageQueue: Enum<
                            {
                                OverweightEnqueued: {
                                    id: FixedSizeBinary<32>;
                                    message_index: number;
                                    origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                    page_index: number;
                                };
                                PageReaped: {
                                    index: number;
                                    origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                };
                                Processed: {
                                    id: FixedSizeBinary<32>;
                                    origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                    success: boolean;
                                    weight_used: { proof_size: bigint; ref_time: bigint };
                                };
                                ProcessingFailed: {
                                    error: Enum<
                                        {
                                            BadFormat: ...;
                                            Corrupt: ...;
                                            Overweight: ...;
                                            StackLimitReached: ...;
                                            Unsupported: ...;
                                            Yield: ...;
                                        },
                                    >;
                                    id: FixedSizeBinary<32>;
                                    origin: Enum<{ Here: ...; Parent: ...; Sibling: ... }>;
                                };
                            },
                        >;
                        MultiBlockElection: Enum<
                            {
                                PhaseTransitioned: {
                                    from: Enum<
                                        {
                                            Done: ...;
                                            Emergency: ...;
                                            Export: ...;
                                            Off: ...;
                                            Signed: ...;
                                            SignedValidation: ...;
                                            Snapshot: ...;
                                            Unsigned: ...;
                                        },
                                    >;
                                    to: Enum<
                                        {
                                            Done: ...;
                                            Emergency: ...;
                                            Export: ...;
                                            Off: ...;
                                            Signed: ...;
                                            SignedValidation: ...;
                                            Snapshot: ...;
                                            Unsigned: ...;
                                        },
                                    >;
                                };
                                UnexpectedTargetSnapshotFailed: undefined;
                                UnexpectedVoterSnapshotFailed: undefined;
                            },
                        >;
                        MultiBlockElectionSigned: Enum<
                            {
                                Bailed: [number, SS58String];
                                Discarded: [number, SS58String];
                                Ejected: [number, SS58String];
                                Registered: [
                                    number,
                                    SS58String,
                                    {
                                        minimal_stake: bigint;
                                        sum_stake: bigint;
                                        sum_stake_squared: bigint;
                                    },
                                ];
                                Rewarded: [number, SS58String, bigint];
                                Slashed: [number, SS58String, bigint];
                                Stored: [number, SS58String, number];
                            },
                        >;
                        MultiBlockElectionVerifier: Enum<
                            {
                                Queued: [
                                    {
                                        minimal_stake: bigint;
                                        sum_stake: bigint;
                                        sum_stake_squared: bigint;
                                    },
                                    (...)
                                    | undefined,
                                ];
                                VerificationFailed: [
                                    number,
                                    Enum<
                                        {
                                            FailedToBoundSupport: ...;
                                            Incomplete: ...;
                                            InvalidRound: ...;
                                            InvalidScore: ...;
                                            InvalidVote: ...;
                                            InvalidVoter: ...;
                                            InvalidWinner: ...;
                                            NposElection: ...;
                                            ScoreTooLow: ...;
                                            SnapshotUnavailable: ...;
                                            WrongWinnerCount: ...;
                                        },
                                    >,
                                ];
                                Verified: FixedSizeArray<2, number>;
                            },
                        >;
                        MultiBlockMigrations: Enum<
                            {
                                HistoricCleared: { next_cursor?: ... };
                                MigrationAdvanced: { index: number; took: number };
                                MigrationCompleted: { index: number; took: number };
                                MigrationFailed: { index: number; took: number };
                                MigrationSkipped: { index: number };
                                UpgradeCompleted: undefined;
                                UpgradeFailed: undefined;
                                UpgradeStarted: { migrations: number };
                            },
                        >;
                        Multisig: Enum<
                            {
                                DepositPoked: {
                                    call_hash: FixedSizeBinary<32>;
                                    new_deposit: bigint;
                                    old_deposit: bigint;
                                    who: SS58String;
                                };
                                MultisigApproval: {
                                    approving: SS58String;
                                    call_hash: FixedSizeBinary<32>;
                                    multisig: SS58String;
                                    timepoint: { height: number; index: number };
                                };
                                MultisigCancelled: {
                                    call_hash: FixedSizeBinary<32>;
                                    cancelling: SS58String;
                                    multisig: SS58String;
                                    timepoint: { height: number; index: number };
                                };
                                MultisigExecuted: {
                                    approving: SS58String;
                                    call_hash: FixedSizeBinary<32>;
                                    multisig: SS58String;
                                    result: ResultPayload<undefined, Enum<(...)>>;
                                    timepoint: { height: number; index: number };
                                };
                                NewMultisig: {
                                    approving: SS58String;
                                    call_hash: FixedSizeBinary<32>;
                                    multisig: SS58String;
                                };
                            },
                        >;
                        NftFractionalization: Enum<
                            {
                                NftFractionalized: {
                                    asset: number;
                                    beneficiary: SS58String;
                                    fractions: bigint;
                                    nft: number;
                                    nft_collection: number;
                                };
                                NftUnified: {
                                    asset: number;
                                    beneficiary: SS58String;
                                    nft: number;
                                    nft_collection: number;
                                };
                            },
                        >;
                        Nfts: Enum<
                            {
                                AllApprovalsCancelled: {
                                    collection: number;
                                    item: number;
                                    owner: SS58String;
                                };
                                ApprovalCancelled: {
                                    collection: number;
                                    delegate: SS58String;
                                    item: number;
                                    owner: SS58String;
                                };
                                AttributeCleared: {
                                    collection: number;
                                    key: Binary;
                                    maybe_item?: ...;
                                    namespace: Enum<
                                        {
                                            Account: ...;
                                            CollectionOwner: ...;
                                            ItemOwner: ...;
                                            Pallet: ...;
                                        },
                                    >;
                                };
                                AttributeSet: {
                                    collection: number;
                                    key: Binary;
                                    maybe_item?: ...;
                                    namespace: Enum<
                                        {
                                            Account: ...;
                                            CollectionOwner: ...;
                                            ItemOwner: ...;
                                            Pallet: ...;
                                        },
                                    >;
                                    value: Binary;
                                };
                                Burned: { collection: number; item: number; owner: SS58String };
                                CollectionConfigChanged: { collection: number };
                                CollectionLocked: { collection: number };
                                CollectionMaxSupplySet: { collection: number; max_supply: number };
                                CollectionMetadataCleared: { collection: number };
                                CollectionMetadataSet: { collection: number; data: Binary };
                                CollectionMintSettingsUpdated: { collection: number };
                                Created: {
                                    collection: number;
                                    creator: SS58String;
                                    owner: SS58String;
                                };
                                Destroyed: { collection: number };
                                ForceCreated: { collection: number; owner: SS58String };
                                Issued: { collection: number; item: number; owner: SS58String };
                                ItemAttributesApprovalAdded: {
                                    collection: number;
                                    delegate: SS58String;
                                    item: number;
                                };
                                ItemAttributesApprovalRemoved: {
                                    collection: number;
                                    delegate: SS58String;
                                    item: number;
                                };
                                ItemBought: {
                                    buyer: SS58String;
                                    collection: number;
                                    item: number;
                                    price: bigint;
                                    seller: SS58String;
                                };
                                ItemMetadataCleared: { collection: number; item: number };
                                ItemMetadataSet: { collection: number; data: Binary; item: number };
                                ItemPriceRemoved: { collection: number; item: number };
                                ItemPriceSet: {
                                    collection: number;
                                    item: number;
                                    price: bigint;
                                    whitelisted_buyer?: ...;
                                };
                                ItemPropertiesLocked: {
                                    collection: number;
                                    item: number;
                                    lock_attributes: boolean;
                                    lock_metadata: boolean;
                                };
                                ItemTransferLocked: { collection: number; item: number };
                                ItemTransferUnlocked: { collection: number; item: number };
                                NextCollectionIdIncremented: { next_id?: ... };
                                OwnerChanged: { collection: number; new_owner: SS58String };
                                OwnershipAcceptanceChanged: {
                                    maybe_collection?: ...;
                                    who: SS58String;
                                };
                                PalletAttributeSet: {
                                    attribute: Enum<{ TransferDisabled: ...; UsedToClaim: ... }>;
                                    collection: number;
                                    item?: ...;
                                    value: Binary;
                                };
                                PreSignedAttributesSet: {
                                    collection: number;
                                    item: number;
                                    namespace: Enum<
                                        {
                                            Account: ...;
                                            CollectionOwner: ...;
                                            ItemOwner: ...;
                                            Pallet: ...;
                                        },
                                    >;
                                };
                                Redeposited: { collection: number; successful_items: number[] };
                                SwapCancelled: {
                                    deadline: number;
                                    desired_collection: number;
                                    desired_item?: ...;
                                    offered_collection: number;
                                    offered_item: number;
                                    price?: ...;
                                };
                                SwapClaimed: {
                                    deadline: number;
                                    price?: ...;
                                    received_collection: number;
                                    received_item: number;
                                    received_item_owner: SS58String;
                                    sent_collection: number;
                                    sent_item: number;
                                    sent_item_owner: SS58String;
                                };
                                SwapCreated: {
                                    deadline: number;
                                    desired_collection: number;
                                    desired_item?: ...;
                                    offered_collection: number;
                                    offered_item: number;
                                    price?: ...;
                                };
                                TeamChanged: {
                                    admin?: ...;
                                    collection: number;
                                    freezer?: ...;
                                    issuer?: ...;
                                };
                                TipSent: {
                                    amount: bigint;
                                    collection: number;
                                    item: number;
                                    receiver: SS58String;
                                    sender: SS58String;
                                };
                                TransferApproved: {
                                    collection: number;
                                    deadline?: ...;
                                    delegate: SS58String;
                                    item: number;
                                    owner: SS58String;
                                };
                                Transferred: {
                                    collection: number;
                                    from: SS58String;
                                    item: number;
                                    to: SS58String;
                                };
                            },
                        >;
                        NominationPools: Enum<
                            {
                                Bonded: {
                                    bonded: bigint;
                                    joined: boolean;
                                    member: SS58String;
                                    pool_id: number;
                                };
                                Created: { depositor: SS58String; pool_id: number };
                                Destroyed: { pool_id: number };
                                GlobalParamsUpdated: {
                                    global_max_commission?: ...;
                                    max_members?: ...;
                                    max_members_per_pool?: ...;
                                    max_pools?: ...;
                                    min_create_bond: bigint;
                                    min_join_bond: bigint;
                                };
                                MemberClaimPermissionUpdated: {
                                    member: SS58String;
                                    permission: NominationPoolsClaimPermission;
                                };
                                MemberRemoved: {
                                    member: SS58String;
                                    pool_id: number;
                                    released_balance: bigint;
                                };
                                MetadataUpdated: { caller: SS58String; pool_id: number };
                                MinBalanceDeficitAdjusted: { amount: bigint; pool_id: number };
                                MinBalanceExcessAdjusted: { amount: bigint; pool_id: number };
                                PaidOut: { member: SS58String; payout: bigint; pool_id: number };
                                PoolCommissionChangeRateUpdated: {
                                    change_rate: { max_increase: number; min_delay: number };
                                    pool_id: number;
                                };
                                PoolCommissionClaimed: { commission: bigint; pool_id: number };
                                PoolCommissionClaimPermissionUpdated: {
                                    permission?: ...;
                                    pool_id: number;
                                };
                                PoolCommissionUpdated: { current?: ...; pool_id: number };
                                PoolMaxCommissionUpdated: { max_commission: number; pool_id: number };
                                PoolNominationMade: { caller: SS58String; pool_id: number };
                                PoolNominatorChilled: { caller: SS58String; pool_id: number };
                                PoolSlashed: { balance: bigint; pool_id: number };
                                RolesUpdated: { bouncer?: ...; nominator?: ...; root?: ... };
                                StateChanged: {
                                    new_state: NominationPoolsPoolState;
                                    pool_id: number;
                                };
                                Unbonded: {
                                    balance: bigint;
                                    era: number;
                                    member: SS58String;
                                    points: bigint;
                                    pool_id: number;
                                };
                                UnbondingPoolSlashed: {
                                    balance: bigint;
                                    era: number;
                                    pool_id: number;
                                };
                                Withdrawn: {
                                    balance: bigint;
                                    member: SS58String;
                                    points: bigint;
                                    pool_id: number;
                                };
                            },
                        >;
                        ParachainSystem: Enum<
                            {
                                DownwardMessagesProcessed: {
                                    dmq_head: FixedSizeBinary<32>;
                                    weight_used: { proof_size: bigint; ref_time: bigint };
                                };
                                DownwardMessagesReceived: { count: number };
                                UpwardMessageSent: { message_hash?: ... };
                                ValidationFunctionApplied: { relay_chain_block_num: number };
                                ValidationFunctionDiscarded: undefined;
                                ValidationFunctionStored: undefined;
                            },
                        >;
                        PolkadotXcm: Enum<
                            {
                                AliasAuthorizationRemoved: {
                                    aliaser: { interior: XcmV5Junctions; parents: number };
                                    target: { interior: XcmV5Junctions; parents: number };
                                };
                                AliasAuthorized: {
                                    aliaser: { interior: XcmV5Junctions; parents: number };
                                    expiry?: ...;
                                    target: { interior: XcmV5Junctions; parents: number };
                                };
                                AliasesAuthorizationsRemoved: {
                                    target: { interior: XcmV5Junctions; parents: number };
                                };
                                AssetsClaimed: {
                                    assets: XcmVersionedAssets;
                                    hash: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                                AssetsTrapped: {
                                    assets: XcmVersionedAssets;
                                    hash: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                                Attempted: {
                                    outcome: Enum<{ Complete: ...; Error: ...; Incomplete: ... }>;
                                };
                                FeesPaid: {
                                    fees: { fun: ...; id: ... }[];
                                    paying: { interior: XcmV5Junctions; parents: number };
                                };
                                InvalidQuerier: {
                                    expected_querier: { interior: XcmV5Junctions; parents: number };
                                    maybe_actual_querier?: ...;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                InvalidQuerierVersion: {
                                    origin: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                InvalidResponder: {
                                    expected_location?: ...;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                InvalidResponderVersion: {
                                    origin: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                Notified: {
                                    call_index: number;
                                    pallet_index: number;
                                    query_id: bigint;
                                };
                                NotifyDecodeFailed: {
                                    call_index: number;
                                    pallet_index: number;
                                    query_id: bigint;
                                };
                                NotifyDispatchError: {
                                    call_index: number;
                                    pallet_index: number;
                                    query_id: bigint;
                                };
                                NotifyOverweight: {
                                    actual_weight: { proof_size: bigint; ref_time: bigint };
                                    call_index: number;
                                    max_budgeted_weight: { proof_size: bigint; ref_time: bigint };
                                    pallet_index: number;
                                    query_id: bigint;
                                };
                                NotifyTargetMigrationFail: {
                                    location: XcmVersionedLocation;
                                    query_id: bigint;
                                };
                                NotifyTargetSendFail: {
                                    error: Enum<
                                        {
                                            AssetNotFound: ...;
                                            BadOrigin: ...;
                                            Barrier: ...;
                                            DestinationUnsupported: ...;
                                            ExceedsMaxMessageSize: ...;
                                            ExceedsStackLimit: ...;
                                            ExpectationFalse: ...;
                                            ExportError: ...;
                                            FailedToDecode: ...;
                                            FailedToTransactAsset: ...;
                                            FeesNotMet: ...;
                                            HoldingWouldOverflow: ...;
                                            InvalidLocation: ...;
                                            LocationCannotHold: ...;
                                            LocationFull: ...;
                                            LocationNotInvertible: ...;
                                            LockError: ...;
                                            MaxWeightInvalid: ...;
                                            NameMismatch: ...;
                                            NoDeal: ...;
                                            NoPermission: ...;
                                            NotDepositable: ...;
                                            NotHoldingFees: ...;
                                            NotWithdrawable: ...;
                                            Overflow: ...;
                                            PalletNotFound: ...;
                                            ReanchorFailed: ...;
                                            TooExpensive: ...;
                                            TooManyAssets: ...;
                                            Transport: ...;
                                            Trap: ...;
                                            Unanchored: ...;
                                            UnhandledXcmVersion: ...;
                                            Unimplemented: ...;
                                            UnknownClaim: ...;
                                            Unroutable: ...;
                                            UntrustedReserveLocation: ...;
                                            UntrustedTeleportLocation: ...;
                                            VersionIncompatible: ...;
                                            WeightLimitReached: ...;
                                            WeightNotComputable: ...;
                                        },
                                    >;
                                    location: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                ProcessXcmError: {
                                    error: Enum<
                                        {
                                            AssetNotFound: ...;
                                            BadOrigin: ...;
                                            Barrier: ...;
                                            DestinationUnsupported: ...;
                                            ExceedsMaxMessageSize: ...;
                                            ExceedsStackLimit: ...;
                                            ExpectationFalse: ...;
                                            ExportError: ...;
                                            FailedToDecode: ...;
                                            FailedToTransactAsset: ...;
                                            FeesNotMet: ...;
                                            HoldingWouldOverflow: ...;
                                            InvalidLocation: ...;
                                            LocationCannotHold: ...;
                                            LocationFull: ...;
                                            LocationNotInvertible: ...;
                                            LockError: ...;
                                            MaxWeightInvalid: ...;
                                            NameMismatch: ...;
                                            NoDeal: ...;
                                            NoPermission: ...;
                                            NotDepositable: ...;
                                            NotHoldingFees: ...;
                                            NotWithdrawable: ...;
                                            Overflow: ...;
                                            PalletNotFound: ...;
                                            ReanchorFailed: ...;
                                            TooExpensive: ...;
                                            TooManyAssets: ...;
                                            Transport: ...;
                                            Trap: ...;
                                            Unanchored: ...;
                                            UnhandledXcmVersion: ...;
                                            Unimplemented: ...;
                                            UnknownClaim: ...;
                                            Unroutable: ...;
                                            UntrustedReserveLocation: ...;
                                            UntrustedTeleportLocation: ...;
                                            VersionIncompatible: ...;
                                            WeightLimitReached: ...;
                                            WeightNotComputable: ...;
                                        },
                                    >;
                                    message_id: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                                ResponseReady: {
                                    query_id: bigint;
                                    response: Enum<
                                        {
                                            Assets: ...;
                                            DispatchResult: ...;
                                            ExecutionResult?: ...;
                                            Null: ...;
                                            PalletsInfo: ...;
                                            Version: ...;
                                        },
                                    >;
                                };
                                ResponseTaken: { query_id: bigint };
                                SendFailed: {
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    error: Enum<
                                        {
                                            DestinationUnsupported: ...;
                                            ExceedsMaxMessageSize: ...;
                                            Fees: ...;
                                            MissingArgument: ...;
                                            NotApplicable: ...;
                                            Transport: ...;
                                            Unroutable: ...;
                                        },
                                    >;
                                    message_id: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                                Sent: {
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message: XcmV5Instruction[];
                                    message_id: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                                SupportedVersionChanged: {
                                    location: { interior: XcmV5Junctions; parents: number };
                                    version: number;
                                };
                                UnexpectedResponse: {
                                    origin: { interior: XcmV5Junctions; parents: number };
                                    query_id: bigint;
                                };
                                VersionChangeNotified: {
                                    cost: { fun: ...; id: ... }[];
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message_id: FixedSizeBinary<32>;
                                    result: number;
                                };
                                VersionMigrationFinished: { version: number };
                                VersionNotifyRequested: {
                                    cost: { fun: ...; id: ... }[];
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message_id: FixedSizeBinary<32>;
                                };
                                VersionNotifyStarted: {
                                    cost: { fun: ...; id: ... }[];
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message_id: FixedSizeBinary<32>;
                                };
                                VersionNotifyUnrequested: {
                                    cost: { fun: ...; id: ... }[];
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message_id: FixedSizeBinary<32>;
                                };
                            },
                        >;
                        PoolAssets: Enum<
                            {
                                AccountsDestroyed: {
                                    accounts_destroyed: number;
                                    accounts_remaining: number;
                                    asset_id: number;
                                };
                                ApprovalCancelled: {
                                    asset_id: number;
                                    delegate: SS58String;
                                    owner: SS58String;
                                };
                                ApprovalsDestroyed: {
                                    approvals_destroyed: number;
                                    approvals_remaining: number;
                                    asset_id: number;
                                };
                                ApprovedTransfer: {
                                    amount: bigint;
                                    asset_id: number;
                                    delegate: SS58String;
                                    source: SS58String;
                                };
                                AssetFrozen: { asset_id: number };
                                AssetMinBalanceChanged: { asset_id: number; new_min_balance: bigint };
                                AssetStatusChanged: { asset_id: number };
                                AssetThawed: { asset_id: number };
                                Blocked: { asset_id: number; who: SS58String };
                                Burned: { asset_id: number; balance: bigint; owner: SS58String };
                                Created: { asset_id: number; creator: SS58String; owner: SS58String };
                                Deposited: { amount: bigint; asset_id: number; who: SS58String };
                                Destroyed: { asset_id: number };
                                DestructionStarted: { asset_id: number };
                                ForceCreated: { asset_id: number; owner: SS58String };
                                Frozen: { asset_id: number; who: SS58String };
                                Issued: { amount: bigint; asset_id: number; owner: SS58String };
                                MetadataCleared: { asset_id: number };
                                MetadataSet: {
                                    asset_id: number;
                                    decimals: number;
                                    is_frozen: boolean;
                                    name: Binary;
                                    symbol: Binary;
                                };
                                OwnerChanged: { asset_id: number; owner: SS58String };
                                TeamChanged: {
                                    admin: SS58String;
                                    asset_id: number;
                                    freezer: SS58String;
                                    issuer: SS58String;
                                };
                                Thawed: { asset_id: number; who: SS58String };
                                Touched: { asset_id: number; depositor: SS58String; who: SS58String };
                                Transferred: {
                                    amount: bigint;
                                    asset_id: number;
                                    from: SS58String;
                                    to: SS58String;
                                };
                                TransferredApproved: {
                                    amount: bigint;
                                    asset_id: number;
                                    delegate: SS58String;
                                    destination: SS58String;
                                    owner: SS58String;
                                };
                                Withdrawn: { amount: bigint; asset_id: number; who: SS58String };
                            },
                        >;
                        PoolAssetsFreezer: Enum<
                            {
                                Frozen: { amount: bigint; asset_id: number; who: SS58String };
                                Thawed: { amount: bigint; asset_id: number; who: SS58String };
                            },
                        >;
                        Preimage: PreimageEvent;
                        Proxy: Enum<
                            {
                                Announced: {
                                    call_hash: FixedSizeBinary<32>;
                                    proxy: SS58String;
                                    real: SS58String;
                                };
                                DepositPoked: {
                                    kind: Enum<{ Announcements: ...; Proxies: ... }>;
                                    new_deposit: bigint;
                                    old_deposit: bigint;
                                    who: SS58String;
                                };
                                ProxyAdded: {
                                    delay: number;
                                    delegatee: SS58String;
                                    delegator: SS58String;
                                    proxy_type: Enum<
                                        {
                                            Any: ...;
                                            AssetManager: ...;
                                            AssetOwner: ...;
                                            Assets: ...;
                                            CancelProxy: ...;
                                            Collator: ...;
                                            Governance: ...;
                                            NominationPools: ...;
                                            NonTransfer: ...;
                                            OldAuction: ...;
                                            OldIdentityJudgement: ...;
                                            OldParaRegistration: ...;
                                            OldSudoBalances: ...;
                                            Staking: ...;
                                        },
                                    >;
                                };
                                ProxyExecuted: { result: ResultPayload<undefined, Enum<(...)>> };
                                ProxyRemoved: {
                                    delay: number;
                                    delegatee: SS58String;
                                    delegator: SS58String;
                                    proxy_type: Enum<
                                        {
                                            Any: ...;
                                            AssetManager: ...;
                                            AssetOwner: ...;
                                            Assets: ...;
                                            CancelProxy: ...;
                                            Collator: ...;
                                            Governance: ...;
                                            NominationPools: ...;
                                            NonTransfer: ...;
                                            OldAuction: ...;
                                            OldIdentityJudgement: ...;
                                            OldParaRegistration: ...;
                                            OldSudoBalances: ...;
                                            Staking: ...;
                                        },
                                    >;
                                };
                                PureCreated: {
                                    at: number;
                                    disambiguation_index: number;
                                    extrinsic_index: number;
                                    proxy_type: Enum<
                                        {
                                            Any: ...;
                                            AssetManager: ...;
                                            AssetOwner: ...;
                                            Assets: ...;
                                            CancelProxy: ...;
                                            Collator: ...;
                                            Governance: ...;
                                            NominationPools: ...;
                                            NonTransfer: ...;
                                            OldAuction: ...;
                                            OldIdentityJudgement: ...;
                                            OldParaRegistration: ...;
                                            OldSudoBalances: ...;
                                            Staking: ...;
                                        },
                                    >;
                                    pure: SS58String;
                                    who: SS58String;
                                };
                                PureKilled: {
                                    disambiguation_index: number;
                                    proxy_type: Enum<
                                        {
                                            Any: ...;
                                            AssetManager: ...;
                                            AssetOwner: ...;
                                            Assets: ...;
                                            CancelProxy: ...;
                                            Collator: ...;
                                            Governance: ...;
                                            NominationPools: ...;
                                            NonTransfer: ...;
                                            OldAuction: ...;
                                            OldIdentityJudgement: ...;
                                            OldParaRegistration: ...;
                                            OldSudoBalances: ...;
                                            Staking: ...;
                                        },
                                    >;
                                    pure: SS58String;
                                    spawner: SS58String;
                                };
                            },
                        >;
                        Referenda: Enum<
                            {
                                Approved: { index: number };
                                Cancelled: {
                                    index: number;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                };
                                ConfirmAborted: { index: number };
                                Confirmed: {
                                    index: number;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                };
                                ConfirmStarted: { index: number };
                                DecisionDepositPlaced: {
                                    amount: bigint;
                                    index: number;
                                    who: SS58String;
                                };
                                DecisionDepositRefunded: {
                                    amount: bigint;
                                    index: number;
                                    who: SS58String;
                                };
                                DecisionStarted: {
                                    index: number;
                                    proposal: PreimagesBounded;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                    track: number;
                                };
                                DepositSlashed: { amount: bigint; who: SS58String };
                                Killed: {
                                    index: number;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                };
                                MetadataCleared: { hash: FixedSizeBinary<32>; index: number };
                                MetadataSet: { hash: FixedSizeBinary<32>; index: number };
                                Rejected: {
                                    index: number;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                };
                                SubmissionDepositRefunded: {
                                    amount: bigint;
                                    index: number;
                                    who: SS58String;
                                };
                                Submitted: {
                                    index: number;
                                    proposal: PreimagesBounded;
                                    track: number;
                                };
                                TimedOut: {
                                    index: number;
                                    tally: { ayes: bigint; nays: bigint; support: bigint };
                                };
                            },
                        >;
                        Revive: Enum<
                            {
                                ContractEmitted: {
                                    contract: FixedSizeBinary<20>;
                                    data: Binary;
                                    topics: FixedSizeBinary<(...)>[];
                                };
                                EthExtrinsicRevert: {
                                    dispatch_error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                };
                                Instantiated: {
                                    contract: FixedSizeBinary<20>;
                                    deployer: FixedSizeBinary<20>;
                                };
                            },
                        >;
                        Scheduler: Enum<
                            {
                                AgendaIncomplete: { when: number };
                                CallUnavailable: { id?: ...; task: FixedSizeArray<2, number> };
                                Canceled: { index: number; when: number };
                                Dispatched: {
                                    id?: ...;
                                    result: ResultPayload<undefined, Enum<(...)>>;
                                    task: FixedSizeArray<2, number>;
                                };
                                PeriodicFailed: { id?: ...; task: FixedSizeArray<2, number> };
                                PermanentlyOverweight: { id?: ...; task: FixedSizeArray<2, number> };
                                RetryCancelled: { id?: ...; task: FixedSizeArray<2, number> };
                                RetryFailed: { id?: ...; task: FixedSizeArray<2, number> };
                                RetrySet: {
                                    id?: ...;
                                    period: number;
                                    retries: number;
                                    task: FixedSizeArray<2, number>;
                                };
                                Scheduled: { index: number; when: number };
                            },
                        >;
                        Session: Enum<
                            {
                                NewQueued: undefined;
                                NewSession: { session_index: number };
                                ValidatorDisabled: { validator: SS58String };
                                ValidatorReenabled: { validator: SS58String };
                            },
                        >;
                        SnowbridgeSystemFrontend: Enum<
                            {
                                ExportOperatingModeChanged: {
                                    mode: Enum<{ Halted: ...; Normal: ... }>;
                                };
                                MessageSent: {
                                    destination: { interior: XcmV5Junctions; parents: number };
                                    message: XcmV5Instruction[];
                                    message_id: FixedSizeBinary<32>;
                                    origin: { interior: XcmV5Junctions; parents: number };
                                };
                            },
                        >;
                        Staking: Enum<
                            {
                                Bonded: { amount: bigint; stash: SS58String };
                                Chilled: { stash: SS58String };
                                ControllerBatchDeprecated: { failures: number };
                                CurrencyMigrated: { force_withdraw: bigint; stash: SS58String };
                                EraPaid: {
                                    era_index: number;
                                    remainder: bigint;
                                    validator_payout: bigint;
                                };
                                EraPruned: { index: number };
                                ForceEra: { mode: StakingForcing };
                                Kicked: { nominator: SS58String; stash: SS58String };
                                OffenceReported: {
                                    fraction: number;
                                    offence_era: number;
                                    validator: SS58String;
                                };
                                OffenceTooOld: {
                                    fraction: number;
                                    offence_era: number;
                                    validator: SS58String;
                                };
                                OldSlashingReportDiscarded: { session_index: number };
                                PagedElectionProceeded: {
                                    page: number;
                                    result: ResultPayload<number, number>;
                                };
                                PayoutStarted: {
                                    era_index: number;
                                    next?: ...;
                                    page: number;
                                    validator_stash: SS58String;
                                };
                                Rewarded: {
                                    amount: bigint;
                                    dest: StakingRewardDestination;
                                    stash: SS58String;
                                };
                                SessionRotated: {
                                    active_era: number;
                                    planned_era: number;
                                    starting_session: number;
                                };
                                SlashCancelled: { slash_era: number; validator: SS58String };
                                SlashComputed: {
                                    offence_era: number;
                                    offender: SS58String;
                                    page: number;
                                    slash_era: number;
                                };
                                Slashed: { amount: bigint; staker: SS58String };
                                SnapshotTargetsSizeExceeded: { size: number };
                                SnapshotVotersSizeExceeded: { size: number };
                                StakerRemoved: { stash: SS58String };
                                Unbonded: { amount: bigint; stash: SS58String };
                                Unexpected: Enum<
                                    {
                                        EraDurationBoundExceeded: undefined;
                                        UnknownValidatorActivation: undefined;
                                    },
                                >;
                                ValidatorPrefsSet: {
                                    prefs: { blocked: boolean; commission: number };
                                    stash: SS58String;
                                };
                                Withdrawn: { amount: bigint; stash: SS58String };
                            },
                        >;
                        StakingRcClient: Enum<
                            {
                                OffenceReceived: { offences_count: number; slash_session: number };
                                SessionReportReceived: {
                                    activation_timestamp?: ...;
                                    end_index: number;
                                    leftover: boolean;
                                    validator_points_counts: number;
                                };
                                Unexpected: Enum<
                                    {
                                        SessionAlreadyProcessed: undefined;
                                        SessionReportIntegrityFailed: undefined;
                                        SessionSkipped: undefined;
                                        ValidatorSetDropped: undefined;
                                        ValidatorSetIntegrityFailed: undefined;
                                        ValidatorSetSendFailed: undefined;
                                    },
                                >;
                            },
                        >;
                        StateTrieMigration: Enum<
                            {
                                AutoMigrationFinished: undefined;
                                Halted: {
                                    error: Enum<
                                        {
                                            BadChildRoot: ...;
                                            BadWitness: ...;
                                            KeyTooLong: ...;
                                            MaxSignedLimits: ...;
                                            NotEnoughFunds: ...;
                                            SignedMigrationNotAllowed: ...;
                                        },
                                    >;
                                };
                                Migrated: {
                                    child: number;
                                    compute: Enum<{ Auto: ...; Signed: ... }>;
                                    top: number;
                                };
                                Slashed: { amount: bigint; who: SS58String };
                            },
                        >;
                        Sudo: Enum<
                            {
                                KeyChanged: { new: SS58String; old?: ... };
                                KeyRemoved: undefined;
                                Sudid: { sudo_result: ResultPayload<undefined, Enum<(...)>> };
                                SudoAsDone: { sudo_result: ResultPayload<undefined, Enum<(...)>> };
                            },
                        >;
                        System: Enum<
                            {
                                CodeUpdated: undefined;
                                ExtrinsicFailed: {
                                    dispatch_error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                    dispatch_info: {
                                        class: DispatchClass;
                                        pays_fee: Enum<(...)>;
                                        weight: { proof_size: ...; ref_time: ... };
                                    };
                                };
                                ExtrinsicSuccess: {
                                    dispatch_info: {
                                        class: DispatchClass;
                                        pays_fee: Enum<(...)>;
                                        weight: { proof_size: ...; ref_time: ... };
                                    };
                                };
                                KilledAccount: { account: SS58String };
                                NewAccount: { account: SS58String };
                                RejectedInvalidAuthorizedUpgrade: {
                                    code_hash: FixedSizeBinary<32>;
                                    error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                };
                                Remarked: { hash: FixedSizeBinary<32>; sender: SS58String };
                                UpgradeAuthorized: {
                                    check_version: boolean;
                                    code_hash: FixedSizeBinary<32>;
                                };
                            },
                        >;
                        ToRococoXcmRouter: Enum<
                            {
                                DeliveryFeeFactorDecreased: { new_value: bigint };
                                DeliveryFeeFactorIncreased: { new_value: bigint };
                            },
                        >;
                        TransactionPayment: TransactionPaymentEvent;
                        Treasury: Enum<
                            {
                                AssetSpendApproved: {
                                    amount: bigint;
                                    asset_kind: Enum<{ V3: ...; V4: ...; V5: ... }>;
                                    beneficiary: Enum<{ V4: ...; V5: ... }>;
                                    expire_at: number;
                                    index: number;
                                    valid_from: number;
                                };
                                AssetSpendVoided: { index: number };
                                Awarded: {
                                    account: SS58String;
                                    award: bigint;
                                    proposal_index: number;
                                };
                                Burnt: { burnt_funds: bigint };
                                Deposit: { value: bigint };
                                Paid: { index: number; payment_id: bigint };
                                PaymentFailed: { index: number; payment_id: bigint };
                                Rollover: { rollover_balance: bigint };
                                SpendApproved: {
                                    amount: bigint;
                                    beneficiary: SS58String;
                                    proposal_index: number;
                                };
                                Spending: { budget_remaining: bigint };
                                SpendProcessed: { index: number };
                                UpdatedInactive: { deactivated: bigint; reactivated: bigint };
                            },
                        >;
                        Uniques: Enum<
                            {
                                ApprovalCancelled: {
                                    collection: number;
                                    delegate: SS58String;
                                    item: number;
                                    owner: SS58String;
                                };
                                ApprovedTransfer: {
                                    collection: number;
                                    delegate: SS58String;
                                    item: number;
                                    owner: SS58String;
                                };
                                AttributeCleared: {
                                    collection: number;
                                    key: Binary;
                                    maybe_item?: ...;
                                };
                                AttributeSet: {
                                    collection: number;
                                    key: Binary;
                                    maybe_item?: ...;
                                    value: Binary;
                                };
                                Burned: { collection: number; item: number; owner: SS58String };
                                CollectionFrozen: { collection: number };
                                CollectionMaxSupplySet: { collection: number; max_supply: number };
                                CollectionMetadataCleared: { collection: number };
                                CollectionMetadataSet: {
                                    collection: number;
                                    data: Binary;
                                    is_frozen: boolean;
                                };
                                CollectionThawed: { collection: number };
                                Created: {
                                    collection: number;
                                    creator: SS58String;
                                    owner: SS58String;
                                };
                                Destroyed: { collection: number };
                                ForceCreated: { collection: number; owner: SS58String };
                                Frozen: { collection: number; item: number };
                                Issued: { collection: number; item: number; owner: SS58String };
                                ItemBought: {
                                    buyer: SS58String;
                                    collection: number;
                                    item: number;
                                    price: bigint;
                                    seller: SS58String;
                                };
                                ItemPriceRemoved: { collection: number; item: number };
                                ItemPriceSet: {
                                    collection: number;
                                    item: number;
                                    price: bigint;
                                    whitelisted_buyer?: ...;
                                };
                                ItemStatusChanged: { collection: number };
                                MetadataCleared: { collection: number; item: number };
                                MetadataSet: {
                                    collection: number;
                                    data: Binary;
                                    is_frozen: boolean;
                                    item: number;
                                };
                                OwnerChanged: { collection: number; new_owner: SS58String };
                                OwnershipAcceptanceChanged: {
                                    maybe_collection?: ...;
                                    who: SS58String;
                                };
                                Redeposited: { collection: number; successful_items: number[] };
                                TeamChanged: {
                                    admin: SS58String;
                                    collection: number;
                                    freezer: SS58String;
                                    issuer: SS58String;
                                };
                                Thawed: { collection: number; item: number };
                                Transferred: {
                                    collection: number;
                                    from: SS58String;
                                    item: number;
                                    to: SS58String;
                                };
                            },
                        >;
                        Utility: Enum<
                            {
                                BatchCompleted: undefined;
                                BatchCompletedWithErrors: undefined;
                                BatchInterrupted: {
                                    error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                    index: number;
                                };
                                DispatchedAs: { result: ResultPayload<undefined, Enum<(...)>> };
                                IfElseFallbackCalled: {
                                    main_error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                };
                                IfElseMainSuccess: undefined;
                                ItemCompleted: undefined;
                                ItemFailed: {
                                    error: Enum<
                                        {
                                            Arithmetic: ...;
                                            BadOrigin: ...;
                                            CannotLookup: ...;
                                            ConsumerRemaining: ...;
                                            Corruption: ...;
                                            Exhausted: ...;
                                            Module: ...;
                                            NoProviders: ...;
                                            Other: ...;
                                            RootNotAllowed: ...;
                                            Token: ...;
                                            TooManyConsumers: ...;
                                            Transactional: ...;
                                            Trie: ...;
                                            Unavailable: ...;
                                        },
                                    >;
                                };
                            },
                        >;
                        Vesting: Enum<
                            {
                                VestingCompleted: { account: SS58String };
                                VestingCreated: { account: SS58String; schedule_index: number };
                                VestingUpdated: { account: SS58String; unvested: bigint };
                            },
                        >;
                        VoterList: BagsListEvent;
                        Whitelist: Enum<
                            {
                                CallWhitelisted: { call_hash: FixedSizeBinary<32> };
                                WhitelistedCallDispatched: {
                                    call_hash: FixedSizeBinary<32>;
                                    result: ResultPayload<
                                        { actual_weight?: ...; pays_fee: ... },
                                        { error: ...; post_info: ... },
                                    >;
                                };
                                WhitelistedCallRemoved: { call_hash: FixedSizeBinary<32> };
                            },
                        >;
                        XcmpQueue: Enum<
                            { XcmpMessageSent: { message_hash: FixedSizeBinary<32> } },
                        >;
                    },
                >[];
                execution_result: ResultPayload<
                    {
                        actual_weight?: { proof_size: bigint; ref_time: bigint };
                        pays_fee: Enum<{ No: undefined; Yes: undefined }>;
                    },
                    {
                        error: Enum<
                            {
                                Arithmetic: ArithmeticError;
                                BadOrigin: undefined;
                                CannotLookup: undefined;
                                ConsumerRemaining: undefined;
                                Corruption: undefined;
                                Exhausted: undefined;
                                Module: Enum<
                                    {
                                        AhOps: Enum<
                                            {
                                                AccountIdentical: ...;
                                                CannotUnreserve: ...;
                                                ContributionsRemaining: ...;
                                                FailedToPutHold: ...;
                                                FailedToReleaseHold: ...;
                                                FailedToReserve: ...;
                                                FailedToSetFreeze: ...;
                                                FailedToThaw: ...;
                                                FailedToTransfer: ...;
                                                FailedToWithdrawCrowdloanContribution: ...;
                                                InternalError: ...;
                                                NoCrowdloanContribution: ...;
                                                NoCrowdloanReserve: ...;
                                                NoLeaseReserve: ...;
                                                NotSovereign: ...;
                                                NotYet: ...;
                                                WouldReap: ...;
                                                WrongDerivedTranslation: ...;
                                                WrongSovereignTranslation: ...;
                                            },
                                        >;
                                        AssetConversion: Enum<
                                            {
                                                AmountOneLessThanMinimal: ...;
                                                AmountOutTooHigh: ...;
                                                AmountTwoLessThanMinimal: ...;
                                                AssetOneDepositDidNotMeetMinimum: ...;
                                                AssetOneWithdrawalDidNotMeetMinimum: ...;
                                                AssetTwoDepositDidNotMeetMinimum: ...;
                                                AssetTwoWithdrawalDidNotMeetMinimum: ...;
                                                BelowMinimum: ...;
                                                IncorrectPoolAssetId: ...;
                                                InsufficientLiquidityMinted: ...;
                                                InvalidAssetPair: ...;
                                                InvalidPath: ...;
                                                NonUniquePath: ...;
                                                OptimalAmountLessThanDesired: ...;
                                                Overflow: ...;
                                                PoolExists: ...;
                                                PoolNotFound: ...;
                                                ProvidedMaximumNotSufficientForSwap: ...;
                                                ProvidedMinimumNotSufficientForSwap: ...;
                                                ReserveLeftLessThanMinimal: ...;
                                                WrongDesiredAmount: ...;
                                                ZeroAmount: ...;
                                                ZeroLiquidity: ...;
                                            },
                                        >;
                                        AssetConversionMigration: Enum<
                                            {
                                                InvalidAssetPair: ...;
                                                PartialTransfer: ...;
                                                PoolNotFound: ...;
                                                ZeroBalance: ...;
                                            },
                                        >;
                                        AssetRate: Enum<
                                            { AlreadyExists: ...; Overflow: ...; UnknownAssetKind: ... },
                                        >;
                                        AssetRewards: Enum<
                                            {
                                                BlockNumberConversionError: ...;
                                                ExpiryBlockMustBeInTheFuture: ...;
                                                ExpiryCut: ...;
                                                InsufficientFunds: ...;
                                                NonEmptyPool: ...;
                                                NonExistentAsset: ...;
                                                NonExistentPool: ...;
                                                NonExistentStaker: ...;
                                                NotEnoughTokens: ...;
                                                RewardRateCut: ...;
                                            },
                                        >;
                                        Assets: Enum<
                                            {
                                                AlreadyExists: ...;
                                                AssetNotLive: ...;
                                                BadAssetId: ...;
                                                BadMetadata: ...;
                                                BadWitness: ...;
                                                BalanceLow: ...;
                                                CallbackFailed: ...;
                                                ContainsFreezes: ...;
                                                ContainsHolds: ...;
                                                Frozen: ...;
                                                IncorrectStatus: ...;
                                                InUse: ...;
                                                LiveAsset: ...;
                                                MinBalanceZero: ...;
                                                NoAccount: ...;
                                                NoDeposit: ...;
                                                NoPermission: ...;
                                                NotFrozen: ...;
                                                Unapproved: ...;
                                                UnavailableConsumer: ...;
                                                Unknown: ...;
                                                WouldBurn: ...;
                                                WouldDie: ...;
                                            },
                                        >;
                                        AssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                        AssetTxPayment: undefined;
                                        Aura: undefined;
                                        AuraExt: undefined;
                                        Authorship: undefined;
                                        Balances: Enum<
                                            {
                                                DeadAccount: ...;
                                                DeltaZero: ...;
                                                ExistentialDeposit: ...;
                                                ExistingVestingSchedule: ...;
                                                Expendability: ...;
                                                InsufficientBalance: ...;
                                                IssuanceDeactivated: ...;
                                                LiquidityRestrictions: ...;
                                                TooManyFreezes: ...;
                                                TooManyHolds: ...;
                                                TooManyReserves: ...;
                                                VestingBalance: ...;
                                            },
                                        >;
                                        CollatorSelection: Enum<
                                            {
                                                AlreadyCandidate: ...;
                                                AlreadyInvulnerable: ...;
                                                DepositTooLow: ...;
                                                IdenticalDeposit: ...;
                                                InsertToCandidateListFailed: ...;
                                                InsufficientBond: ...;
                                                InvalidUnreserve: ...;
                                                NoAssociatedValidatorId: ...;
                                                NotCandidate: ...;
                                                NotInvulnerable: ...;
                                                RemoveFromCandidateListFailed: ...;
                                                TargetIsNotCandidate: ...;
                                                TooFewEligibleCollators: ...;
                                                TooManyCandidates: ...;
                                                TooManyInvulnerables: ...;
                                                UpdateCandidateListFailed: ...;
                                                ValidatorNotRegistered: ...;
                                            },
                                        >;
                                        ConvictionVoting: Enum<
                                            {
                                                AlreadyDelegating: ...;
                                                AlreadyVoting: ...;
                                                BadClass: ...;
                                                ClassNeeded: ...;
                                                InsufficientFunds: ...;
                                                MaxVotesReached: ...;
                                                Nonsense: ...;
                                                NoPermission: ...;
                                                NoPermissionYet: ...;
                                                NotDelegating: ...;
                                                NotOngoing: ...;
                                                NotVoter: ...;
                                            },
                                        >;
                                        CumulusXcm: undefined;
                                        DelegatedStaking: Enum<
                                            {
                                                AlreadyStaking: ...;
                                                BadState: ...;
                                                InvalidDelegation: ...;
                                                InvalidRewardDestination: ...;
                                                NotAgent: ...;
                                                NotAllowed: ...;
                                                NotDelegator: ...;
                                                NotEnoughFunds: ...;
                                                NothingToSlash: ...;
                                                NotSupported: ...;
                                                UnappliedSlash: ...;
                                                WithdrawFailed: ...;
                                            },
                                        >;
                                        FastUnstake: Enum<
                                            {
                                                AlreadyHead: ...;
                                                AlreadyQueued: ...;
                                                CallNotAllowed: ...;
                                                NotController: ...;
                                                NotFullyBonded: ...;
                                                NotQueued: ...;
                                            },
                                        >;
                                        ForeignAssets: Enum<
                                            {
                                                AlreadyExists: ...;
                                                AssetNotLive: ...;
                                                BadAssetId: ...;
                                                BadMetadata: ...;
                                                BadWitness: ...;
                                                BalanceLow: ...;
                                                CallbackFailed: ...;
                                                ContainsFreezes: ...;
                                                ContainsHolds: ...;
                                                Frozen: ...;
                                                IncorrectStatus: ...;
                                                InUse: ...;
                                                LiveAsset: ...;
                                                MinBalanceZero: ...;
                                                NoAccount: ...;
                                                NoDeposit: ...;
                                                NoPermission: ...;
                                                NotFrozen: ...;
                                                Unapproved: ...;
                                                UnavailableConsumer: ...;
                                                Unknown: ...;
                                                WouldBurn: ...;
                                                WouldDie: ...;
                                            },
                                        >;
                                        ForeignAssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                        Indices: Enum<
                                            {
                                                InUse: ...;
                                                NotAssigned: ...;
                                                NotOwner: ...;
                                                NotTransfer: ...;
                                                Permanent: ...;
                                            },
                                        >;
                                        MessageQueue: Enum<
                                            {
                                                AlreadyProcessed: ...;
                                                InsufficientWeight: ...;
                                                NoMessage: ...;
                                                NoPage: ...;
                                                NotReapable: ...;
                                                Queued: ...;
                                                QueuePaused: ...;
                                                RecursiveDisallowed: ...;
                                                TemporarilyUnprocessable: ...;
                                            },
                                        >;
                                        MultiBlockElection: Enum<
                                            { Fallback: ...; Snapshot: ...; UnexpectedPhase: ... },
                                        >;
                                        MultiBlockElectionSigned: Enum<
                                            {
                                                BadPageIndex: ...;
                                                BadWitnessData: ...;
                                                Duplicate: ...;
                                                NoSubmission: ...;
                                                NotRegistered: ...;
                                                PhaseNotSigned: ...;
                                                QueueFull: ...;
                                                RoundNotOver: ...;
                                                TooManyInvulnerables: ...;
                                            },
                                        >;
                                        MultiBlockElectionUnsigned: undefined;
                                        MultiBlockElectionVerifier: undefined;
                                        MultiBlockMigrations: Enum<{ Ongoing: ... }>;
                                        Multisig: Enum<
                                            {
                                                AlreadyApproved: ...;
                                                AlreadyStored: ...;
                                                MaxWeightTooLow: ...;
                                                MinimumThreshold: ...;
                                                NoApprovalsNeeded: ...;
                                                NotFound: ...;
                                                NoTimepoint: ...;
                                                NotOwner: ...;
                                                SenderInSignatories: ...;
                                                SignatoriesOutOfOrder: ...;
                                                TooFewSignatories: ...;
                                                TooManySignatories: ...;
                                                UnexpectedTimepoint: ...;
                                                WrongTimepoint: ...;
                                            },
                                        >;
                                        NftFractionalization: Enum<
                                            {
                                                IncorrectAssetId: ...;
                                                NftNotFound: ...;
                                                NftNotFractionalized: ...;
                                                NoPermission: ...;
                                            },
                                        >;
                                        Nfts: Enum<
                                            {
                                                AlreadyClaimed: ...;
                                                AlreadyExists: ...;
                                                ApprovalExpired: ...;
                                                AttributeNotFound: ...;
                                                BadWitness: ...;
                                                BidTooLow: ...;
                                                CollectionIdInUse: ...;
                                                CollectionNotEmpty: ...;
                                                DeadlineExpired: ...;
                                                InconsistentItemConfig: ...;
                                                IncorrectData: ...;
                                                IncorrectMetadata: ...;
                                                ItemLocked: ...;
                                                ItemsNonTransferable: ...;
                                                LockedCollectionAttributes: ...;
                                                LockedCollectionMetadata: ...;
                                                LockedItemAttributes: ...;
                                                LockedItemMetadata: ...;
                                                MaxAttributesLimitReached: ...;
                                                MaxSupplyLocked: ...;
                                                MaxSupplyReached: ...;
                                                MaxSupplyTooSmall: ...;
                                                MetadataNotFound: ...;
                                                MethodDisabled: ...;
                                                MintEnded: ...;
                                                MintNotStarted: ...;
                                                NoConfig: ...;
                                                NoPermission: ...;
                                                NotDelegate: ...;
                                                NotForSale: ...;
                                                ReachedApprovalLimit: ...;
                                                RolesNotCleared: ...;
                                                Unaccepted: ...;
                                                Unapproved: ...;
                                                UnknownCollection: ...;
                                                UnknownItem: ...;
                                                UnknownSwap: ...;
                                                WitnessRequired: ...;
                                                WrongDelegate: ...;
                                                WrongDuration: ...;
                                                WrongNamespace: ...;
                                                WrongOrigin: ...;
                                                WrongOwner: ...;
                                                WrongSetting: ...;
                                                WrongSignature: ...;
                                            },
                                        >;
                                        NominationPools: Enum<
                                            {
                                                AccountBelongsToOtherPool: ...;
                                                AlreadyMigrated: ...;
                                                BondExtraRestricted: ...;
                                                CanNotChangeState: ...;
                                                CannotWithdrawAny: ...;
                                                CommissionChangeRateNotAllowed: ...;
                                                CommissionChangeThrottled: ...;
                                                CommissionExceedsGlobalMaximum: ...;
                                                CommissionExceedsMaximum: ...;
                                                Defensive: ...;
                                                DoesNotHavePermission: ...;
                                                FullyUnbonding: ...;
                                                InvalidPoolId: ...;
                                                MaxCommissionRestricted: ...;
                                                MaxPoolMembers: ...;
                                                MaxPools: ...;
                                                MaxUnbondingLimit: ...;
                                                MetadataExceedsMaxLen: ...;
                                                MinimumBondNotMet: ...;
                                                NoCommissionCurrentSet: ...;
                                                NoPendingCommission: ...;
                                                NotDestroying: ...;
                                                NothingToAdjust: ...;
                                                NothingToSlash: ...;
                                                NotKickerOrDestroying: ...;
                                                NotMigrated: ...;
                                                NotNominator: ...;
                                                NotOpen: ...;
                                                NotSupported: ...;
                                                OverflowRisk: ...;
                                                PartialUnbondNotAllowedPermissionlessly: ...;
                                                PoolIdInUse: ...;
                                                PoolMemberNotFound: ...;
                                                PoolNotFound: ...;
                                                Restricted: ...;
                                                RewardPoolNotFound: ...;
                                                SlashTooLow: ...;
                                                SubPoolsNotFound: ...;
                                            },
                                        >;
                                        Origins: undefined;
                                        ParachainInfo: undefined;
                                        ParachainSystem: Enum<
                                            {
                                                HostConfigurationNotAvailable: ...;
                                                NotScheduled: ...;
                                                OverlappingUpgrades: ...;
                                                ProhibitedByPolkadot: ...;
                                                TooBig: ...;
                                                ValidationDataNotAvailable: ...;
                                            },
                                        >;
                                        PolkadotXcm: Enum<
                                            {
                                                AccountNotSovereign: ...;
                                                AliasNotFound: ...;
                                                AlreadySubscribed: ...;
                                                BadLocation: ...;
                                                BadVersion: ...;
                                                CannotCheckOutTeleport: ...;
                                                CannotReanchor: ...;
                                                DestinationNotInvertible: ...;
                                                Empty: ...;
                                                ExpiresInPast: ...;
                                                FeesNotMet: ...;
                                                Filtered: ...;
                                                InUse: ...;
                                                InvalidAssetUnknownReserve: ...;
                                                InvalidAssetUnsupportedReserve: ...;
                                                InvalidOrigin: ...;
                                                LocalExecutionIncomplete: ...;
                                                LocalExecutionIncompleteWithError: ...;
                                                LockNotFound: ...;
                                                LowBalance: ...;
                                                NoSubscription: ...;
                                                SendFailure: ...;
                                                TooManyAssets: ...;
                                                TooManyAuthorizedAliases: ...;
                                                TooManyLocks: ...;
                                                TooManyReserves: ...;
                                                Unreachable: ...;
                                                UnweighableMessage: ...;
                                            },
                                        >;
                                        PoolAssets: Enum<
                                            {
                                                AlreadyExists: ...;
                                                AssetNotLive: ...;
                                                BadAssetId: ...;
                                                BadMetadata: ...;
                                                BadWitness: ...;
                                                BalanceLow: ...;
                                                CallbackFailed: ...;
                                                ContainsFreezes: ...;
                                                ContainsHolds: ...;
                                                Frozen: ...;
                                                IncorrectStatus: ...;
                                                InUse: ...;
                                                LiveAsset: ...;
                                                MinBalanceZero: ...;
                                                NoAccount: ...;
                                                NoDeposit: ...;
                                                NoPermission: ...;
                                                NotFrozen: ...;
                                                Unapproved: ...;
                                                UnavailableConsumer: ...;
                                                Unknown: ...;
                                                WouldBurn: ...;
                                                WouldDie: ...;
                                            },
                                        >;
                                        PoolAssetsFreezer: Enum<{ TooManyFreezes: ... }>;
                                        Preimage: Enum<
                                            {
                                                AlreadyNoted: ...;
                                                NotAuthorized: ...;
                                                NotNoted: ...;
                                                NotRequested: ...;
                                                Requested: ...;
                                                TooBig: ...;
                                                TooFew: ...;
                                                TooMany: ...;
                                            },
                                        >;
                                        Proxy: Enum<
                                            {
                                                Duplicate: ...;
                                                NoPermission: ...;
                                                NoSelfProxy: ...;
                                                NotFound: ...;
                                                NotProxy: ...;
                                                TooMany: ...;
                                                Unannounced: ...;
                                                Unproxyable: ...;
                                            },
                                        >;
                                        Referenda: Enum<
                                            {
                                                BadReferendum: ...;
                                                BadStatus: ...;
                                                BadTrack: ...;
                                                Full: ...;
                                                HasDeposit: ...;
                                                NoDeposit: ...;
                                                NoPermission: ...;
                                                NothingToDo: ...;
                                                NotOngoing: ...;
                                                NoTrack: ...;
                                                PreimageNotExist: ...;
                                                PreimageStoredWithDifferentLength: ...;
                                                QueueEmpty: ...;
                                                Unfinished: ...;
                                            },
                                        >;
                                        Revive: Enum<
                                            {
                                                AccountAlreadyMapped: ...;
                                                AccountUnmapped: ...;
                                                BalanceConversionFailed: ...;
                                                BasicBlockTooLarge: ...;
                                                BlobTooLarge: ...;
                                                CallDataTooLarge: ...;
                                                CannotAddSelfAsDelegateDependency: ...;
                                                CodeInfoNotFound: ...;
                                                CodeInUse: ...;
                                                CodeNotFound: ...;
                                                CodeRejected: ...;
                                                ContractNotFound: ...;
                                                ContractReverted: ...;
                                                ContractTrapped: ...;
                                                DecodingFailed: ...;
                                                DelegateDependencyAlreadyExists: ...;
                                                DelegateDependencyNotFound: ...;
                                                DuplicateContract: ...;
                                                ExecutionFailed: ...;
                                                InputForwarded: ...;
                                                InvalidCallFlags: ...;
                                                InvalidGenericTransaction: ...;
                                                InvalidImmutableAccess: ...;
                                                InvalidInstruction: ...;
                                                InvalidJump: ...;
                                                InvalidSchedule: ...;
                                                InvalidStorageFlags: ...;
                                                InvalidSyscall: ...;
                                                MaxCallDepthReached: ...;
                                                MaxDelegateDependenciesReached: ...;
                                                OutOfBounds: ...;
                                                OutOfGas: ...;
                                                OutOfTransientStorage: ...;
                                                ReenteredPallet: ...;
                                                ReentranceDenied: ...;
                                                RefcountOverOrUnderflow: ...;
                                                ReturnDataTooLarge: ...;
                                                StackOverflow: ...;
                                                StackUnderflow: ...;
                                                StateChangeDenied: ...;
                                                StaticMemoryTooLarge: ...;
                                                StorageDepositLimitExhausted: ...;
                                                StorageDepositNotEnoughFunds: ...;
                                                TerminatedInConstructor: ...;
                                                TerminatedWhileReentrant: ...;
                                                TooManyTopics: ...;
                                                TransferFailed: ...;
                                                TxFeeOverdraw: ...;
                                                UnsupportedPrecompileAddress: ...;
                                                ValueTooLarge: ...;
                                            },
                                        >;
                                        Scheduler: Enum<
                                            {
                                                FailedToSchedule: ...;
                                                Named: ...;
                                                NotFound: ...;
                                                RescheduleNoChange: ...;
                                                TargetBlockNumberInPast: ...;
                                            },
                                        >;
                                        Session: Enum<
                                            {
                                                DuplicatedKey: ...;
                                                InvalidProof: ...;
                                                NoAccount: ...;
                                                NoAssociatedValidatorId: ...;
                                                NoKeys: ...;
                                            },
                                        >;
                                        SnowbridgeSystemFrontend: Enum<
                                            {
                                                BurnError: ...;
                                                FeesNotMet: ...;
                                                Halted: ...;
                                                InvalidAccount: ...;
                                                InvalidAssetOwner: ...;
                                                LocationConversionFailed: ...;
                                                SendFailure: ...;
                                                SwapError: ...;
                                                TipAmountZero: ...;
                                                Unreachable: ...;
                                                UnsupportedAsset: ...;
                                                UnsupportedLocationVersion: ...;
                                                WithdrawError: ...;
                                            },
                                        >;
                                        Staking: Enum<
                                            {
                                                AlreadyBonded: ...;
                                                AlreadyClaimed: ...;
                                                AlreadyMigrated: ...;
                                                AlreadyPaired: ...;
                                                BadState: ...;
                                                BadTarget: ...;
                                                BoundNotMet: ...;
                                                CancelledSlash: ...;
                                                CannotChillOther: ...;
                                                CannotReapStash: ...;
                                                CannotRestoreLedger: ...;
                                                CommissionTooLow: ...;
                                                ControllerDeprecated: ...;
                                                DuplicateIndex: ...;
                                                EmptyTargets: ...;
                                                EraNotPrunable: ...;
                                                EraNotStarted: ...;
                                                FundedTarget: ...;
                                                IncorrectHistoryDepth: ...;
                                                InsufficientBond: ...;
                                                InvalidEraToReward: ...;
                                                InvalidNumberOfNominations: ...;
                                                InvalidPage: ...;
                                                InvalidSlashRecord: ...;
                                                NoMoreChunks: ...;
                                                NotController: ...;
                                                NotEnoughFunds: ...;
                                                NotStash: ...;
                                                NoUnlockChunk: ...;
                                                Restricted: ...;
                                                RewardDestinationRestricted: ...;
                                                TooManyNominators: ...;
                                                TooManyTargets: ...;
                                                TooManyValidators: ...;
                                                UnappliedSlashesInPreviousEra: ...;
                                                VirtualStakerNotAllowed: ...;
                                            },
                                        >;
                                        StakingRcClient: undefined;
                                        StateTrieMigration: Enum<
                                            {
                                                BadChildRoot: ...;
                                                BadWitness: ...;
                                                KeyTooLong: ...;
                                                MaxSignedLimits: ...;
                                                NotEnoughFunds: ...;
                                                SignedMigrationNotAllowed: ...;
                                            },
                                        >;
                                        Sudo: Enum<{ RequireSudo: ... }>;
                                        System: Enum<
                                            {
                                                CallFiltered: ...;
                                                FailedToExtractRuntimeVersion: ...;
                                                InvalidSpecName: ...;
                                                MultiBlockMigrationsOngoing: ...;
                                                NonDefaultComposite: ...;
                                                NonZeroRefCount: ...;
                                                NothingAuthorized: ...;
                                                SpecVersionNeedsToIncrease: ...;
                                                Unauthorized: ...;
                                            },
                                        >;
                                        Timestamp: undefined;
                                        ToRococoXcmRouter: undefined;
                                        TransactionPayment: undefined;
                                        Treasury: Enum<
                                            {
                                                AlreadyAttempted: ...;
                                                EarlyPayout: ...;
                                                FailedToConvertBalance: ...;
                                                Inconclusive: ...;
                                                InsufficientPermission: ...;
                                                InvalidIndex: ...;
                                                NotAttempted: ...;
                                                PayoutError: ...;
                                                ProposalNotApproved: ...;
                                                SpendExpired: ...;
                                                TooManyApprovals: ...;
                                            },
                                        >;
                                        Uniques: Enum<
                                            {
                                                AlreadyExists: ...;
                                                AttributeNotFound: ...;
                                                BadWitness: ...;
                                                BidTooLow: ...;
                                                Frozen: ...;
                                                InUse: ...;
                                                Locked: ...;
                                                MaxSupplyAlreadySet: ...;
                                                MaxSupplyReached: ...;
                                                MaxSupplyTooSmall: ...;
                                                NoDelegate: ...;
                                                NoMetadata: ...;
                                                NoPermission: ...;
                                                NotForSale: ...;
                                                Unaccepted: ...;
                                                Unapproved: ...;
                                                UnknownCollection: ...;
                                                UnknownItem: ...;
                                                WrongAttribute: ...;
                                                WrongDelegate: ...;
                                                WrongMetadata: ...;
                                                WrongOwner: ...;
                                            },
                                        >;
                                        Utility: Enum<{ TooManyCalls: ... }>;
                                        Vesting: Enum<
                                            {
                                                AmountLow: ...;
                                                AtMaxVestingSchedules: ...;
                                                InvalidScheduleParams: ...;
                                                NotVesting: ...;
                                                ScheduleIndexOutOfBounds: ...;
                                            },
                                        >;
                                        VoterList: Enum<{ List: ...; Locked: ... }>;
                                        WeightReclaim: undefined;
                                        Whitelist: Enum<
                                            {
                                                CallAlreadyWhitelisted: ...;
                                                CallIsNotWhitelisted: ...;
                                                InvalidCallWeightWitness: ...;
                                                UnavailablePreImage: ...;
                                                UndecodableCall: ...;
                                            },
                                        >;
                                        XcmpQueue: Enum<
                                            {
                                                AlreadyResumed: ...;
                                                AlreadySuspended: ...;
                                                BadQueueConfig: ...;
                                                TooBig: ...;
                                                TooManyActiveOutboundChannels: ...;
                                            },
                                        >;
                                    },
                                >;
                                NoProviders: undefined;
                                Other: undefined;
                                RootNotAllowed: undefined;
                                Token: TokenError;
                                TooManyConsumers: undefined;
                                Transactional: TransactionalError;
                                Trie: Enum<
                                    {
                                        DecodeError: undefined;
                                        DecoderError: undefined;
                                        DuplicateKey: undefined;
                                        ExtraneousHashReference: undefined;
                                        ExtraneousNode: undefined;
                                        ExtraneousValue: undefined;
                                        IncompleteDatabase: undefined;
                                        IncompleteProof: undefined;
                                        InvalidChildReference: undefined;
                                        InvalidHash: undefined;
                                        InvalidStateRoot: undefined;
                                        RootMismatch: undefined;
                                        ValueAtIncompleteKey: undefined;
                                        ValueMismatch: undefined;
                                    },
                                >;
                                Unavailable: undefined;
                            },
                        >;
                        post_info: {
                            actual_weight?: { proof_size: bigint; ref_time: bigint };
                            pays_fee: Enum<{ No: undefined; Yes: undefined }>;
                        };
                    },
                >;
                forwarded_xcms: [XcmVersionedLocation, XcmVersionedXcm[]][];
                local_xcm?: XcmVersionedXcm;
            },
            Enum<{ Unimplemented: undefined; VersionedConversionFailed: undefined }>,
        >,
    >

    Dry run call V2.

    Settings

    Member Visibility