Type Alias dry_run_call

dry_run_call: RuntimeDescriptor<
    [
        origin: Enum<
            {
                CumulusXcm: Enum<{ Relay: undefined; SiblingParachain: number }>;
                PolkadotXcm: Enum<
                    {
                        Response: { interior: XcmV5Junctions; parents: number };
                        Xcm: { interior: XcmV5Junctions; parents: number };
                    },
                >;
                system: Enum<
                    {
                        Authorized: undefined;
                        None: undefined;
                        Root: undefined;
                        Signed: SS58String;
                    },
                >;
            },
        >,
        call: TxCallData,
        result_xcms_version: number,
    ],
    ResultPayload<
        {
            emitted_events: Enum<
                {
                    Balances: Enum<
                        {
                            BalanceSet: { free: bigint; who: SS58String };
                            Burned: { amount: bigint; who: SS58String };
                            BurnedDebt: { amount: bigint };
                            BurnedHeld: {
                                amount: bigint;
                                reason: Enum<
                                    { PolkadotXcm: ...; Session: ...; XcmOverBridgeHubRococo: ... },
                                >;
                                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<
                                    { PolkadotXcm: ...; Session: ...; XcmOverBridgeHubRococo: ... },
                                >;
                                who: SS58String;
                            };
                            Issued: { amount: bigint };
                            Locked: { amount: bigint; who: SS58String };
                            Minted: { amount: bigint; who: SS58String };
                            MintedCredit: { amount: bigint };
                            Released: {
                                amount: bigint;
                                reason: Enum<
                                    { PolkadotXcm: ...; Session: ...; XcmOverBridgeHubRococo: ... },
                                >;
                                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<
                                    { PolkadotXcm: ...; Session: ...; XcmOverBridgeHubRococo: ... },
                                >;
                                source: SS58String;
                                transferred: bigint;
                            };
                            TransferOnHold: {
                                amount: bigint;
                                dest: SS58String;
                                reason: Enum<
                                    { PolkadotXcm: ...; Session: ...; XcmOverBridgeHubRococo: ... },
                                >;
                                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 };
                        },
                    >;
                    BridgeRelayers: Enum<
                        {
                            Deregistered: { relayer: SS58String };
                            RegistrationUpdated: {
                                registration: { stake: bigint; valid_till: number };
                                relayer: SS58String;
                            };
                            RewardPaid: {
                                beneficiary: Enum<{ AssetHubLocation: ...; LocalAccount: ... }>;
                                relayer: SS58String;
                                reward_balance: bigint;
                                reward_kind: Enum<{ RococoWestend: ...; Snowbridge: ... }>;
                            };
                            RewardRegistered: {
                                relayer: SS58String;
                                reward_balance: bigint;
                                reward_kind: Enum<{ RococoWestend: ...; Snowbridge: ... }>;
                            };
                            SlashedAndDeregistered: {
                                registration: { stake: bigint; valid_till: number };
                                relayer: SS58String;
                            };
                        },
                    >;
                    BridgeRococoGrandpa: Enum<
                        {
                            UpdatedBestFinalizedHeader: {
                                grandpa_info: {
                                    finality_proof: {
                                        commit: ...;
                                        round: ...;
                                        votes_ancestries: ...;
                                    };
                                    new_verification_context?: (...)
                                    | (...);
                                };
                                hash: FixedSizeBinary<32>;
                                number: number;
                            };
                        },
                    >;
                    BridgeRococoMessages: Enum<
                        {
                            MessageAccepted: { lane_id: FixedSizeBinary<4>; nonce: bigint };
                            MessagesDelivered: {
                                lane_id: FixedSizeBinary<4>;
                                messages: { begin: bigint; end: bigint };
                            };
                            MessagesReceived: {
                                lane: FixedSizeBinary<4>;
                                receive_results: [(...), (...)][];
                            };
                        },
                    >;
                    BridgeRococoParachains: Enum<
                        {
                            IncorrectParachainHeadHash: {
                                actual_parachain_head_hash: FixedSizeBinary<32>;
                                parachain: number;
                                parachain_head_hash: FixedSizeBinary<32>;
                            };
                            MissingParachainHead: { parachain: number };
                            RejectedLargeParachainHead: {
                                parachain: number;
                                parachain_head_hash: FixedSizeBinary<32>;
                                parachain_head_size: number;
                            };
                            RejectedObsoleteParachainHead: {
                                parachain: number;
                                parachain_head_hash: FixedSizeBinary<32>;
                            };
                            UntrackedParachainRejected: { parachain: number };
                            UpdatedParachainHead: {
                                parachain: number;
                                parachain_head_hash: FixedSizeBinary<32>;
                            };
                        },
                    >;
                    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[] };
                        },
                    >;
                    CumulusXcm: Enum<
                        {
                            ExecutedDownward: [
                                FixedSizeBinary<32>,
                                Enum<{ Complete: ...; Error: ...; Incomplete: ... }>,
                            ];
                            InvalidFormat: FixedSizeBinary<32>;
                            UnsupportedVersion: FixedSizeBinary<32>;
                        },
                    >;
                    EthereumBeaconClient: Enum<
                        {
                            BeaconHeaderImported: {
                                block_hash: FixedSizeBinary<32>;
                                slot: bigint;
                            };
                            OperatingModeChanged: { mode: Enum<{ Halted: ...; Normal: ... }> };
                            SyncCommitteeUpdated: { period: bigint };
                        },
                    >;
                    EthereumInboundQueue: Enum<
                        {
                            MessageReceived: {
                                channel_id: FixedSizeBinary<32>;
                                fee_burned: bigint;
                                message_id: FixedSizeBinary<32>;
                                nonce: bigint;
                            };
                            OperatingModeChanged: { mode: Enum<{ Halted: ...; Normal: ... }> };
                        },
                    >;
                    EthereumInboundQueueV2: Enum<
                        {
                            MessageReceived: {
                                message_id: FixedSizeBinary<32>;
                                nonce: bigint;
                            };
                            OperatingModeChanged: { mode: Enum<{ Halted: ...; Normal: ... }> };
                        },
                    >;
                    EthereumOutboundQueue: Enum<
                        {
                            MessageAccepted: { id: FixedSizeBinary<32>; nonce: bigint };
                            MessageQueued: { id: FixedSizeBinary<32> };
                            MessagesCommitted: { count: bigint; root: FixedSizeBinary<32> };
                            OperatingModeChanged: { mode: Enum<{ Halted: ...; Normal: ... }> };
                        },
                    >;
                    EthereumOutboundQueueV2: Enum<
                        {
                            MessageAccepted: { id: FixedSizeBinary<32>; nonce: bigint };
                            MessageDelivered: { nonce: bigint };
                            MessagePostponed: {
                                payload: Binary;
                                reason: Enum<
                                    {
                                        BadFormat: ...;
                                        Corrupt: ...;
                                        Overweight: ...;
                                        StackLimitReached: ...;
                                        Unsupported: ...;
                                        Yield: ...;
                                    },
                                >;
                            };
                            MessageQueued: {
                                message: {
                                    commands: (...)[];
                                    fee: bigint;
                                    id: FixedSizeBinary<(...)>;
                                    origin: FixedSizeBinary<(...)>;
                                };
                            };
                            MessageRejected: {
                                error: Enum<
                                    {
                                        BadFormat: ...;
                                        Corrupt: ...;
                                        Overweight: ...;
                                        StackLimitReached: ...;
                                        Unsupported: ...;
                                        Yield: ...;
                                    },
                                >;
                                id?: ...;
                                payload: Binary;
                            };
                            MessagesCommitted: { count: bigint; root: FixedSizeBinary<32> };
                            OperatingModeChanged: { mode: Enum<{ Halted: ...; Normal: ... }> };
                        },
                    >;
                    EthereumSystem: Enum<
                        {
                            CreateAgent: {
                                agent_id: FixedSizeBinary<32>;
                                location: { interior: XcmV5Junctions; parents: number };
                            };
                            CreateChannel: {
                                agent_id: FixedSizeBinary<32>;
                                channel_id: FixedSizeBinary<32>;
                            };
                            PricingParametersChanged: {
                                params: {
                                    exchange_rate: bigint;
                                    fee_per_gas: FixedSizeArray<(...), (...)>;
                                    multiplier: bigint;
                                    rewards: { local: ...; remote: ... };
                                };
                            };
                            RegisterToken: {
                                foreign_token_id: FixedSizeBinary<32>;
                                location: XcmVersionedLocation;
                            };
                            SetOperatingMode: {
                                mode: Enum<{ Normal: ...; RejectingOutboundMessages: ... }>;
                            };
                            SetTokenTransferFees: {
                                create_asset_xcm: bigint;
                                register_token: FixedSizeArray<4, bigint>;
                                transfer_asset_xcm: bigint;
                            };
                            TransferNativeFromAgent: {
                                agent_id: FixedSizeBinary<32>;
                                amount: bigint;
                                recipient: FixedSizeBinary<20>;
                            };
                            UpdateChannel: {
                                channel_id: FixedSizeBinary<32>;
                                mode: Enum<{ Normal: ...; RejectingOutboundMessages: ... }>;
                            };
                            Upgrade: {
                                impl_address: FixedSizeBinary<20>;
                                impl_code_hash: FixedSizeBinary<32>;
                                initializer_params_hash?: ...;
                            };
                        },
                    >;
                    EthereumSystemV2: Enum<
                        {
                            RegisterToken: {
                                foreign_token_id: FixedSizeBinary<32>;
                                location: XcmVersionedLocation;
                            };
                            SetOperatingMode: {
                                mode: Enum<{ Normal: ...; RejectingOutboundMessages: ... }>;
                            };
                            TipProcessed: {
                                amount: bigint;
                                message_id: Enum<{ Inbound: ...; Outbound: ... }>;
                                sender: SS58String;
                                success: boolean;
                            };
                            Upgrade: {
                                impl_address: FixedSizeBinary<20>;
                                impl_code_hash: FixedSizeBinary<32>;
                                initializer_params_hash: FixedSizeBinary<32>;
                            };
                        },
                    >;
                    MessageQueue: Enum<
                        {
                            OverweightEnqueued: {
                                id: FixedSizeBinary<32>;
                                message_index: number;
                                origin: Enum<
                                    {
                                        Here: ...;
                                        Parent: ...;
                                        Sibling: ...;
                                        Snowbridge: ...;
                                        SnowbridgeV2: ...;
                                    },
                                >;
                                page_index: number;
                            };
                            PageReaped: {
                                index: number;
                                origin: Enum<
                                    {
                                        Here: ...;
                                        Parent: ...;
                                        Sibling: ...;
                                        Snowbridge: ...;
                                        SnowbridgeV2: ...;
                                    },
                                >;
                            };
                            Processed: {
                                id: FixedSizeBinary<32>;
                                origin: Enum<
                                    {
                                        Here: ...;
                                        Parent: ...;
                                        Sibling: ...;
                                        Snowbridge: ...;
                                        SnowbridgeV2: ...;
                                    },
                                >;
                                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: ...;
                                        Snowbridge: ...;
                                        SnowbridgeV2: ...;
                                    },
                                >;
                            };
                        },
                    >;
                    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;
                            };
                        },
                    >;
                    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>;
                            };
                        },
                    >;
                    Session: Enum<
                        {
                            NewQueued: undefined;
                            NewSession: { session_index: number };
                            ValidatorDisabled: { validator: SS58String };
                            ValidatorReenabled: { validator: SS58String };
                        },
                    >;
                    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>;
                            };
                        },
                    >;
                    TransactionPayment: TransactionPaymentEvent;
                    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: ...;
                                    },
                                >;
                            };
                        },
                    >;
                    XcmOverBridgeHubRococo: Enum<
                        {
                            BridgeOpened: {
                                bridge_deposit: bigint;
                                bridge_id: FixedSizeBinary<32>;
                                lane_id: FixedSizeBinary<4>;
                                local_endpoint: XcmV5Junctions;
                                remote_endpoint: XcmV5Junctions;
                            };
                            BridgePruned: {
                                bridge_deposit: bigint;
                                bridge_id: FixedSizeBinary<32>;
                                lane_id: FixedSizeBinary<4>;
                                pruned_messages: bigint;
                            };
                            ClosingBridge: {
                                bridge_id: FixedSizeBinary<32>;
                                enqueued_messages: bigint;
                                lane_id: FixedSizeBinary<4>;
                                pruned_messages: bigint;
                            };
                        },
                    >;
                    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<
                                {
                                    Aura: undefined;
                                    AuraExt: undefined;
                                    Authorship: undefined;
                                    Balances: Enum<
                                        {
                                            DeadAccount: ...;
                                            DeltaZero: ...;
                                            ExistentialDeposit: ...;
                                            ExistingVestingSchedule: ...;
                                            Expendability: ...;
                                            InsufficientBalance: ...;
                                            IssuanceDeactivated: ...;
                                            LiquidityRestrictions: ...;
                                            TooManyFreezes: ...;
                                            TooManyHolds: ...;
                                            TooManyReserves: ...;
                                            VestingBalance: ...;
                                        },
                                    >;
                                    BridgeRelayers: Enum<
                                        {
                                            CannotReduceRegistrationLease: ...;
                                            FailedToPayReward: ...;
                                            FailedToReserve: ...;
                                            FailedToUnreserve: ...;
                                            InvalidRegistrationLease: ...;
                                            NoRewardForRelayer: ...;
                                            NotRegistered: ...;
                                            RegistrationIsStillActive: ...;
                                        },
                                    >;
                                    BridgeRococoGrandpa: Enum<
                                        {
                                            AlreadyInitialized: ...;
                                            BelowFreeHeaderInterval: ...;
                                            BridgeModule: ...;
                                            FreeHeadersLimitExceded: ...;
                                            HeaderOverflowLimits: ...;
                                            InvalidAuthoritySet: ...;
                                            InvalidAuthoritySetId: ...;
                                            InvalidJustification: ...;
                                            NotInitialized: ...;
                                            OldHeader: ...;
                                            TooManyAuthoritiesInSet: ...;
                                            UnsupportedScheduledChange: ...;
                                        },
                                    >;
                                    BridgeRococoMessages: Enum<
                                        {
                                            BridgeModule: ...;
                                            InsufficientDispatchWeight: ...;
                                            InvalidMessagesDeliveryProof: ...;
                                            InvalidMessagesProof: ...;
                                            InvalidUnrewardedRelayersState: ...;
                                            LanesManager: ...;
                                            MessageRejectedByPallet: ...;
                                            NotOperatingNormally: ...;
                                            ReceptionConfirmation: ...;
                                            TooManyMessagesInTheProof: ...;
                                        },
                                    >;
                                    BridgeRococoParachains: Enum<
                                        {
                                            BridgeModule: ...;
                                            HeaderChainStorageProof: ...;
                                            InvalidRelayChainBlockNumber: ...;
                                            UnknownRelayChainBlock: ...;
                                        },
                                    >;
                                    CollatorSelection: Enum<
                                        {
                                            AlreadyCandidate: ...;
                                            AlreadyInvulnerable: ...;
                                            DepositTooLow: ...;
                                            IdenticalDeposit: ...;
                                            InsertToCandidateListFailed: ...;
                                            InsufficientBond: ...;
                                            InvalidUnreserve: ...;
                                            NoAssociatedValidatorId: ...;
                                            NotCandidate: ...;
                                            NotInvulnerable: ...;
                                            RemoveFromCandidateListFailed: ...;
                                            TargetIsNotCandidate: ...;
                                            TooFewEligibleCollators: ...;
                                            TooManyCandidates: ...;
                                            TooManyInvulnerables: ...;
                                            UpdateCandidateListFailed: ...;
                                            ValidatorNotRegistered: ...;
                                        },
                                    >;
                                    CumulusXcm: undefined;
                                    EthereumBeaconClient: Enum<
                                        {
                                            BlockBodyHashTreeRootFailed: ...;
                                            BLSPreparePublicKeysFailed: ...;
                                            BLSVerificationFailed: ...;
                                            ExecutionHeaderSkippedBlock: ...;
                                            ExecutionHeaderTooFarBehind: ...;
                                            ExpectedFinalizedHeaderNotStored: ...;
                                            ForkDataHashTreeRootFailed: ...;
                                            Halted: ...;
                                            HeaderHashTreeRootFailed: ...;
                                            HeaderNotFinalized: ...;
                                            InvalidAncestryMerkleProof: ...;
                                            InvalidBlockRootsRootMerkleProof: ...;
                                            InvalidExecutionHeaderProof: ...;
                                            InvalidFinalizedHeaderGap: ...;
                                            InvalidHeaderMerkleProof: ...;
                                            InvalidSyncCommitteeMerkleProof: ...;
                                            InvalidSyncCommitteeUpdate: ...;
                                            InvalidUpdateSlot: ...;
                                            IrrelevantUpdate: ...;
                                            NotBootstrapped: ...;
                                            SigningRootHashTreeRootFailed: ...;
                                            SkippedSyncCommitteePeriod: ...;
                                            SyncCommitteeHashTreeRootFailed: ...;
                                            SyncCommitteeParticipantsNotSupermajority: ...;
                                            SyncCommitteeUpdateRequired: ...;
                                        },
                                    >;
                                    EthereumInboundQueue: Enum<
                                        {
                                            ConvertMessage: ...;
                                            Halted: ...;
                                            InvalidAccountConversion: ...;
                                            InvalidChannel: ...;
                                            InvalidEnvelope: ...;
                                            InvalidGateway: ...;
                                            InvalidNonce: ...;
                                            InvalidPayload: ...;
                                            MaxNonceReached: ...;
                                            Send: ...;
                                            Verification: ...;
                                        },
                                    >;
                                    EthereumInboundQueueV2: Enum<
                                        {
                                            CannotReanchor: ...;
                                            FeesNotMet: ...;
                                            Halted: ...;
                                            InvalidAccount: ...;
                                            InvalidAccountConversion: ...;
                                            InvalidAsset: ...;
                                            InvalidChannel: ...;
                                            InvalidFee: ...;
                                            InvalidGateway: ...;
                                            InvalidMessage: ...;
                                            InvalidNetwork: ...;
                                            InvalidNonce: ...;
                                            InvalidPayload: ...;
                                            MaxNonceReached: ...;
                                            SendFailure: ...;
                                            Unreachable: ...;
                                            Verification: ...;
                                        },
                                    >;
                                    EthereumOutboundQueue: Enum<
                                        { Halted: ...; InvalidChannel: ...; MessageTooLarge: ... },
                                    >;
                                    EthereumOutboundQueueV2: Enum<
                                        {
                                            Halted: ...;
                                            InvalidChannel: ...;
                                            InvalidEnvelope: ...;
                                            InvalidGateway: ...;
                                            InvalidPendingNonce: ...;
                                            MessageTooLarge: ...;
                                            RewardPaymentFailed: ...;
                                            Verification: ...;
                                        },
                                    >;
                                    EthereumSystem: Enum<
                                        {
                                            AgentAlreadyCreated: ...;
                                            ChannelAlreadyCreated: ...;
                                            InvalidLocation: ...;
                                            InvalidPricingParameters: ...;
                                            InvalidTokenTransferFees: ...;
                                            InvalidUpgradeParameters: ...;
                                            LocationConversionFailed: ...;
                                            NoAgent: ...;
                                            NoChannel: ...;
                                            Send: ...;
                                            UnsupportedLocationVersion: ...;
                                        },
                                    >;
                                    EthereumSystemV2: Enum<
                                        {
                                            InvalidUpgradeParameters: ...;
                                            LocationConversionFailed: ...;
                                            LocationReanchorFailed: ...;
                                            Send: ...;
                                            UnsupportedLocationVersion: ...;
                                        },
                                    >;
                                    MessageQueue: Enum<
                                        {
                                            AlreadyProcessed: ...;
                                            InsufficientWeight: ...;
                                            NoMessage: ...;
                                            NoPage: ...;
                                            NotReapable: ...;
                                            Queued: ...;
                                            QueuePaused: ...;
                                            RecursiveDisallowed: ...;
                                            TemporarilyUnprocessable: ...;
                                        },
                                    >;
                                    Multisig: Enum<
                                        {
                                            AlreadyApproved: ...;
                                            AlreadyStored: ...;
                                            MaxWeightTooLow: ...;
                                            MinimumThreshold: ...;
                                            NoApprovalsNeeded: ...;
                                            NotFound: ...;
                                            NoTimepoint: ...;
                                            NotOwner: ...;
                                            SenderInSignatories: ...;
                                            SignatoriesOutOfOrder: ...;
                                            TooFewSignatories: ...;
                                            TooManySignatories: ...;
                                            UnexpectedTimepoint: ...;
                                            WrongTimepoint: ...;
                                        },
                                    >;
                                    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: ...;
                                        },
                                    >;
                                    Session: Enum<
                                        {
                                            DuplicatedKey: ...;
                                            InvalidProof: ...;
                                            NoAccount: ...;
                                            NoAssociatedValidatorId: ...;
                                            NoKeys: ...;
                                        },
                                    >;
                                    System: Enum<
                                        {
                                            CallFiltered: ...;
                                            FailedToExtractRuntimeVersion: ...;
                                            InvalidSpecName: ...;
                                            MultiBlockMigrationsOngoing: ...;
                                            NonDefaultComposite: ...;
                                            NonZeroRefCount: ...;
                                            NothingAuthorized: ...;
                                            SpecVersionNeedsToIncrease: ...;
                                            Unauthorized: ...;
                                        },
                                    >;
                                    Timestamp: undefined;
                                    TransactionPayment: undefined;
                                    Utility: Enum<{ TooManyCalls: ... }>;
                                    WeightReclaim: undefined;
                                    XcmOverBridgeHubRococo: Enum<
                                        {
                                            BridgeAlreadyClosed: ...;
                                            BridgeAlreadyExists: ...;
                                            BridgeLocations: ...;
                                            FailedToReserveBridgeDeposit: ...;
                                            InvalidBridgeOriginAccount: ...;
                                            LanesManager: ...;
                                            TooManyBridgesForLocalOrigin: ...;
                                            UnknownBridge: ...;
                                            UnsupportedXcmVersion: ...;
                                        },
                                    >;
                                    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 }>,
    >,
>