@dedot/chaintypes 0.194.0 → 0.195.0

package/moonbeam/errors.d.ts

@@ -1,8 +1,8 @@
 // Generated by dedot cli
 
-import type { GenericChainErrors, GenericPalletError, RpcVersion } from 'dedot/types';
+import type { GenericChainErrors, GenericPalletError } from 'dedot/types';
 
-export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+export interface ChainErrors extends GenericChainErrors {
   /**
    * Pallet `System`'s errors
    **/
@@ -11,55 +11,55 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The name of specification does not match between the current runtime
      * and the new runtime.
      **/
-    InvalidSpecName: GenericPalletError<Rv>;
+    InvalidSpecName: GenericPalletError;
 
     /**
      * The specification version is not allowed to decrease between the current runtime
      * and the new runtime.
      **/
-    SpecVersionNeedsToIncrease: GenericPalletError<Rv>;
+    SpecVersionNeedsToIncrease: GenericPalletError;
 
     /**
      * Failed to extract the runtime version from the new runtime.
      *
      * Either calling `Core_version` or decoding `RuntimeVersion` failed.
      **/
-    FailedToExtractRuntimeVersion: GenericPalletError<Rv>;
+    FailedToExtractRuntimeVersion: GenericPalletError;
 
     /**
      * Suicide called when the account has non-default composite data.
      **/
-    NonDefaultComposite: GenericPalletError<Rv>;
+    NonDefaultComposite: GenericPalletError;
 
     /**
      * There is a non-zero reference count preventing the account from being purged.
      **/
-    NonZeroRefCount: GenericPalletError<Rv>;
+    NonZeroRefCount: GenericPalletError;
 
     /**
      * The origin filter prevent the call to be dispatched.
      **/
-    CallFiltered: GenericPalletError<Rv>;
+    CallFiltered: GenericPalletError;
 
     /**
      * A multi-block migration is ongoing and prevents the current code from being replaced.
      **/
-    MultiBlockMigrationsOngoing: GenericPalletError<Rv>;
+    MultiBlockMigrationsOngoing: GenericPalletError;
 
     /**
      * No upgrade authorized.
      **/
-    NothingAuthorized: GenericPalletError<Rv>;
+    NothingAuthorized: GenericPalletError;
 
     /**
      * The submitted code is not authorized.
      **/
-    Unauthorized: GenericPalletError<Rv>;
+    Unauthorized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParachainSystem`'s errors
@@ -68,38 +68,38 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Attempt to upgrade validation function while existing upgrade pending.
      **/
-    OverlappingUpgrades: GenericPalletError<Rv>;
+    OverlappingUpgrades: GenericPalletError;
 
     /**
      * Polkadot currently prohibits this parachain from upgrading its validation function.
      **/
-    ProhibitedByPolkadot: GenericPalletError<Rv>;
+    ProhibitedByPolkadot: GenericPalletError;
 
     /**
      * The supplied validation function has compiled into a blob larger than Polkadot is
      * willing to run.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * The inherent which supplies the validation data did not run this block.
      **/
-    ValidationDataNotAvailable: GenericPalletError<Rv>;
+    ValidationDataNotAvailable: GenericPalletError;
 
     /**
      * The inherent which supplies the host configuration did not run this block.
      **/
-    HostConfigurationNotAvailable: GenericPalletError<Rv>;
+    HostConfigurationNotAvailable: GenericPalletError;
 
     /**
      * No validation function upgrade is currently scheduled.
      **/
-    NotScheduled: GenericPalletError<Rv>;
+    NotScheduled: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Balances`'s errors
@@ -108,132 +108,132 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Vesting balance too high to send value.
      **/
-    VestingBalance: GenericPalletError<Rv>;
+    VestingBalance: GenericPalletError;
 
     /**
      * Account liquidity restrictions prevent withdrawal.
      **/
-    LiquidityRestrictions: GenericPalletError<Rv>;
+    LiquidityRestrictions: GenericPalletError;
 
     /**
      * Balance too low to send value.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Value too low to create account due to existential deposit.
      **/
-    ExistentialDeposit: GenericPalletError<Rv>;
+    ExistentialDeposit: GenericPalletError;
 
     /**
      * Transfer/payment would kill account.
      **/
-    Expendability: GenericPalletError<Rv>;
+    Expendability: GenericPalletError;
 
     /**
      * A vesting schedule already exists for this account.
      **/
-    ExistingVestingSchedule: GenericPalletError<Rv>;
+    ExistingVestingSchedule: GenericPalletError;
 
     /**
      * Beneficiary account must pre-exist.
      **/
-    DeadAccount: GenericPalletError<Rv>;
+    DeadAccount: GenericPalletError;
 
     /**
      * Number of named reserves exceed `MaxReserves`.
      **/
-    TooManyReserves: GenericPalletError<Rv>;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
      **/
-    TooManyHolds: GenericPalletError<Rv>;
+    TooManyHolds: GenericPalletError;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError<Rv>;
+    TooManyFreezes: GenericPalletError;
 
     /**
      * The issuance cannot be modified since it is already deactivated.
      **/
-    IssuanceDeactivated: GenericPalletError<Rv>;
+    IssuanceDeactivated: GenericPalletError;
 
     /**
      * The delta cannot be zero.
      **/
-    DeltaZero: GenericPalletError<Rv>;
+    DeltaZero: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParachainStaking`'s errors
    **/
   parachainStaking: {
-    DelegatorDNE: GenericPalletError<Rv>;
-    DelegatorDNEinTopNorBottom: GenericPalletError<Rv>;
-    DelegatorDNEInDelegatorSet: GenericPalletError<Rv>;
-    CandidateDNE: GenericPalletError<Rv>;
-    DelegationDNE: GenericPalletError<Rv>;
-    DelegatorExists: GenericPalletError<Rv>;
-    CandidateExists: GenericPalletError<Rv>;
-    CandidateBondBelowMin: GenericPalletError<Rv>;
-    InsufficientBalance: GenericPalletError<Rv>;
-    DelegatorBondBelowMin: GenericPalletError<Rv>;
-    DelegationBelowMin: GenericPalletError<Rv>;
-    AlreadyOffline: GenericPalletError<Rv>;
-    AlreadyActive: GenericPalletError<Rv>;
-    DelegatorAlreadyLeaving: GenericPalletError<Rv>;
-    DelegatorNotLeaving: GenericPalletError<Rv>;
-    DelegatorCannotLeaveYet: GenericPalletError<Rv>;
-    CannotDelegateIfLeaving: GenericPalletError<Rv>;
-    CandidateAlreadyLeaving: GenericPalletError<Rv>;
-    CandidateNotLeaving: GenericPalletError<Rv>;
-    CandidateCannotLeaveYet: GenericPalletError<Rv>;
-    CannotGoOnlineIfLeaving: GenericPalletError<Rv>;
-    ExceedMaxDelegationsPerDelegator: GenericPalletError<Rv>;
-    AlreadyDelegatedCandidate: GenericPalletError<Rv>;
-    InvalidSchedule: GenericPalletError<Rv>;
-    CannotSetBelowMin: GenericPalletError<Rv>;
-    RoundLengthMustBeGreaterThanTotalSelectedCollators: GenericPalletError<Rv>;
-    NoWritingSameValue: GenericPalletError<Rv>;
-    TotalInflationDistributionPercentExceeds100: GenericPalletError<Rv>;
-    TooLowCandidateCountWeightHintJoinCandidates: GenericPalletError<Rv>;
-    TooLowCandidateCountWeightHintCancelLeaveCandidates: GenericPalletError<Rv>;
-    TooLowCandidateCountToLeaveCandidates: GenericPalletError<Rv>;
-    TooLowDelegationCountToDelegate: GenericPalletError<Rv>;
-    TooLowCandidateDelegationCountToDelegate: GenericPalletError<Rv>;
-    TooLowCandidateDelegationCountToLeaveCandidates: GenericPalletError<Rv>;
-    TooLowDelegationCountToLeaveDelegators: GenericPalletError<Rv>;
-    PendingCandidateRequestsDNE: GenericPalletError<Rv>;
-    PendingCandidateRequestAlreadyExists: GenericPalletError<Rv>;
-    PendingCandidateRequestNotDueYet: GenericPalletError<Rv>;
-    PendingDelegationRequestDNE: GenericPalletError<Rv>;
-    PendingDelegationRequestAlreadyExists: GenericPalletError<Rv>;
-    PendingDelegationRequestNotDueYet: GenericPalletError<Rv>;
-    CannotDelegateLessThanOrEqualToLowestBottomWhenFull: GenericPalletError<Rv>;
-    PendingDelegationRevoke: GenericPalletError<Rv>;
-    TooLowDelegationCountToAutoCompound: GenericPalletError<Rv>;
-    TooLowCandidateAutoCompoundingDelegationCountToAutoCompound: GenericPalletError<Rv>;
-    TooLowCandidateAutoCompoundingDelegationCountToDelegate: GenericPalletError<Rv>;
-    TooLowCollatorCountToNotifyAsInactive: GenericPalletError<Rv>;
-    CannotBeNotifiedAsInactive: GenericPalletError<Rv>;
-    TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates: GenericPalletError<Rv>;
-    TooLowCandidateCountWeightHint: GenericPalletError<Rv>;
-    TooLowCandidateCountWeightHintGoOffline: GenericPalletError<Rv>;
-    CandidateLimitReached: GenericPalletError<Rv>;
-    CannotSetAboveMaxCandidates: GenericPalletError<Rv>;
-    MarkingOfflineNotEnabled: GenericPalletError<Rv>;
-    CurrentRoundTooLow: GenericPalletError<Rv>;
+    DelegatorDNE: GenericPalletError;
+    DelegatorDNEinTopNorBottom: GenericPalletError;
+    DelegatorDNEInDelegatorSet: GenericPalletError;
+    CandidateDNE: GenericPalletError;
+    DelegationDNE: GenericPalletError;
+    DelegatorExists: GenericPalletError;
+    CandidateExists: GenericPalletError;
+    CandidateBondBelowMin: GenericPalletError;
+    InsufficientBalance: GenericPalletError;
+    DelegatorBondBelowMin: GenericPalletError;
+    DelegationBelowMin: GenericPalletError;
+    AlreadyOffline: GenericPalletError;
+    AlreadyActive: GenericPalletError;
+    DelegatorAlreadyLeaving: GenericPalletError;
+    DelegatorNotLeaving: GenericPalletError;
+    DelegatorCannotLeaveYet: GenericPalletError;
+    CannotDelegateIfLeaving: GenericPalletError;
+    CandidateAlreadyLeaving: GenericPalletError;
+    CandidateNotLeaving: GenericPalletError;
+    CandidateCannotLeaveYet: GenericPalletError;
+    CannotGoOnlineIfLeaving: GenericPalletError;
+    ExceedMaxDelegationsPerDelegator: GenericPalletError;
+    AlreadyDelegatedCandidate: GenericPalletError;
+    InvalidSchedule: GenericPalletError;
+    CannotSetBelowMin: GenericPalletError;
+    RoundLengthMustBeGreaterThanTotalSelectedCollators: GenericPalletError;
+    NoWritingSameValue: GenericPalletError;
+    TotalInflationDistributionPercentExceeds100: GenericPalletError;
+    TooLowCandidateCountWeightHintJoinCandidates: GenericPalletError;
+    TooLowCandidateCountWeightHintCancelLeaveCandidates: GenericPalletError;
+    TooLowCandidateCountToLeaveCandidates: GenericPalletError;
+    TooLowDelegationCountToDelegate: GenericPalletError;
+    TooLowCandidateDelegationCountToDelegate: GenericPalletError;
+    TooLowCandidateDelegationCountToLeaveCandidates: GenericPalletError;
+    TooLowDelegationCountToLeaveDelegators: GenericPalletError;
+    PendingCandidateRequestsDNE: GenericPalletError;
+    PendingCandidateRequestAlreadyExists: GenericPalletError;
+    PendingCandidateRequestNotDueYet: GenericPalletError;
+    PendingDelegationRequestDNE: GenericPalletError;
+    PendingDelegationRequestAlreadyExists: GenericPalletError;
+    PendingDelegationRequestNotDueYet: GenericPalletError;
+    CannotDelegateLessThanOrEqualToLowestBottomWhenFull: GenericPalletError;
+    PendingDelegationRevoke: GenericPalletError;
+    TooLowDelegationCountToAutoCompound: GenericPalletError;
+    TooLowCandidateAutoCompoundingDelegationCountToAutoCompound: GenericPalletError;
+    TooLowCandidateAutoCompoundingDelegationCountToDelegate: GenericPalletError;
+    TooLowCollatorCountToNotifyAsInactive: GenericPalletError;
+    CannotBeNotifiedAsInactive: GenericPalletError;
+    TooLowCandidateAutoCompoundingDelegationCountToLeaveCandidates: GenericPalletError;
+    TooLowCandidateCountWeightHint: GenericPalletError;
+    TooLowCandidateCountWeightHintGoOffline: GenericPalletError;
+    CandidateLimitReached: GenericPalletError;
+    CannotSetAboveMaxCandidates: GenericPalletError;
+    MarkingOfflineNotEnabled: GenericPalletError;
+    CurrentRoundTooLow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AuthorInherent`'s errors
@@ -242,22 +242,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Author already set in block.
      **/
-    AuthorAlreadySet: GenericPalletError<Rv>;
+    AuthorAlreadySet: GenericPalletError;
 
     /**
      * No AccountId was found to be associated with this author
      **/
-    NoAccountId: GenericPalletError<Rv>;
+    NoAccountId: GenericPalletError;
 
     /**
      * The author in the inherent is not an eligible author.
      **/
-    CannotBeAuthor: GenericPalletError<Rv>;
+    CannotBeAuthor: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AuthorMapping`'s errors
@@ -266,47 +266,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The association can't be cleared because it is not found.
      **/
-    AssociationNotFound: GenericPalletError<Rv>;
+    AssociationNotFound: GenericPalletError;
 
     /**
      * The association can't be cleared because it belongs to another account.
      **/
-    NotYourAssociation: GenericPalletError<Rv>;
+    NotYourAssociation: GenericPalletError;
 
     /**
      * This account cannot set an author because it cannon afford the security deposit
      **/
-    CannotAffordSecurityDeposit: GenericPalletError<Rv>;
+    CannotAffordSecurityDeposit: GenericPalletError;
 
     /**
      * The NimbusId in question is already associated and cannot be overwritten
      **/
-    AlreadyAssociated: GenericPalletError<Rv>;
+    AlreadyAssociated: GenericPalletError;
 
     /**
      * No existing NimbusId can be found for the account
      **/
-    OldAuthorIdNotFound: GenericPalletError<Rv>;
+    OldAuthorIdNotFound: GenericPalletError;
 
     /**
      * Keys have wrong size
      **/
-    WrongKeySize: GenericPalletError<Rv>;
+    WrongKeySize: GenericPalletError;
 
     /**
      * Failed to decode NimbusId for `set_keys`
      **/
-    DecodeNimbusFailed: GenericPalletError<Rv>;
+    DecodeNimbusFailed: GenericPalletError;
 
     /**
      * Failed to decode T::Keys for `set_keys`
      **/
-    DecodeKeysFailed: GenericPalletError<Rv>;
+    DecodeKeysFailed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MoonbeamOrbiters`'s errors
@@ -315,53 +315,53 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The collator is already added in orbiters program.
      **/
-    CollatorAlreadyAdded: GenericPalletError<Rv>;
+    CollatorAlreadyAdded: GenericPalletError;
 
     /**
      * This collator is not in orbiters program.
      **/
-    CollatorNotFound: GenericPalletError<Rv>;
+    CollatorNotFound: GenericPalletError;
 
     /**
      * There are already too many orbiters associated with this collator.
      **/
-    CollatorPoolTooLarge: GenericPalletError<Rv>;
+    CollatorPoolTooLarge: GenericPalletError;
 
     /**
      * There are more collator pools than the number specified in the parameter.
      **/
-    CollatorsPoolCountTooLow: GenericPalletError<Rv>;
+    CollatorsPoolCountTooLow: GenericPalletError;
 
     /**
      * The minimum deposit required to register as an orbiter has not yet been included in the
      * onchain storage
      **/
-    MinOrbiterDepositNotSet: GenericPalletError<Rv>;
+    MinOrbiterDepositNotSet: GenericPalletError;
 
     /**
      * This orbiter is already associated with this collator.
      **/
-    OrbiterAlreadyInPool: GenericPalletError<Rv>;
+    OrbiterAlreadyInPool: GenericPalletError;
 
     /**
      * This orbiter has not made a deposit
      **/
-    OrbiterDepositNotFound: GenericPalletError<Rv>;
+    OrbiterDepositNotFound: GenericPalletError;
 
     /**
      * This orbiter is not found
      **/
-    OrbiterNotFound: GenericPalletError<Rv>;
+    OrbiterNotFound: GenericPalletError;
 
     /**
      * The orbiter is still at least in one pool
      **/
-    OrbiterStillInAPool: GenericPalletError<Rv>;
+    OrbiterStillInAPool: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Utility`'s errors
@@ -370,12 +370,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Too many calls batched.
      **/
-    TooManyCalls: GenericPalletError<Rv>;
+    TooManyCalls: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -384,47 +384,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * There are too many proxies registered or too many announcements pending.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Proxy registration not found.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Sender is not a proxy of the account to be proxied.
      **/
-    NotProxy: GenericPalletError<Rv>;
+    NotProxy: GenericPalletError;
 
     /**
      * A call which is incompatible with the proxy type's filter was attempted.
      **/
-    Unproxyable: GenericPalletError<Rv>;
+    Unproxyable: GenericPalletError;
 
     /**
      * Account is already a proxy.
      **/
-    Duplicate: GenericPalletError<Rv>;
+    Duplicate: GenericPalletError;
 
     /**
      * Call may not be made by proxy because it may escalate its privileges.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError<Rv>;
+    Unannounced: GenericPalletError;
 
     /**
      * Cannot add self as proxy.
      **/
-    NoSelfProxy: GenericPalletError<Rv>;
+    NoSelfProxy: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MaintenanceMode`'s errors
@@ -433,17 +433,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The chain cannot enter maintenance mode because it is already in maintenance mode
      **/
-    AlreadyInMaintenanceMode: GenericPalletError<Rv>;
+    AlreadyInMaintenanceMode: GenericPalletError;
 
     /**
      * The chain cannot resume normal operation because it is not in maintenance mode
      **/
-    NotInMaintenanceMode: GenericPalletError<Rv>;
+    NotInMaintenanceMode: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Identity`'s errors
@@ -452,158 +452,158 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Too many subs-accounts.
      **/
-    TooManySubAccounts: GenericPalletError<Rv>;
+    TooManySubAccounts: GenericPalletError;
 
     /**
      * Account isn't found.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Account isn't named.
      **/
-    NotNamed: GenericPalletError<Rv>;
+    NotNamed: GenericPalletError;
 
     /**
      * Empty index.
      **/
-    EmptyIndex: GenericPalletError<Rv>;
+    EmptyIndex: GenericPalletError;
 
     /**
      * Fee is changed.
      **/
-    FeeChanged: GenericPalletError<Rv>;
+    FeeChanged: GenericPalletError;
 
     /**
      * No identity found.
      **/
-    NoIdentity: GenericPalletError<Rv>;
+    NoIdentity: GenericPalletError;
 
     /**
      * Sticky judgement.
      **/
-    StickyJudgement: GenericPalletError<Rv>;
+    StickyJudgement: GenericPalletError;
 
     /**
      * Judgement given.
      **/
-    JudgementGiven: GenericPalletError<Rv>;
+    JudgementGiven: GenericPalletError;
 
     /**
      * Invalid judgement.
      **/
-    InvalidJudgement: GenericPalletError<Rv>;
+    InvalidJudgement: GenericPalletError;
 
     /**
      * The index is invalid.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * The target is invalid.
      **/
-    InvalidTarget: GenericPalletError<Rv>;
+    InvalidTarget: GenericPalletError;
 
     /**
      * Maximum amount of registrars reached. Cannot add any more.
      **/
-    TooManyRegistrars: GenericPalletError<Rv>;
+    TooManyRegistrars: GenericPalletError;
 
     /**
      * Account ID is already named.
      **/
-    AlreadyClaimed: GenericPalletError<Rv>;
+    AlreadyClaimed: GenericPalletError;
 
     /**
      * Sender is not a sub-account.
      **/
-    NotSub: GenericPalletError<Rv>;
+    NotSub: GenericPalletError;
 
     /**
      * Sub-account isn't owned by sender.
      **/
-    NotOwned: GenericPalletError<Rv>;
+    NotOwned: GenericPalletError;
 
     /**
      * The provided judgement was for a different identity.
      **/
-    JudgementForDifferentIdentity: GenericPalletError<Rv>;
+    JudgementForDifferentIdentity: GenericPalletError;
 
     /**
      * Error that occurs when there is an issue paying for judgement.
      **/
-    JudgementPaymentFailed: GenericPalletError<Rv>;
+    JudgementPaymentFailed: GenericPalletError;
 
     /**
      * The provided suffix is too long.
      **/
-    InvalidSuffix: GenericPalletError<Rv>;
+    InvalidSuffix: GenericPalletError;
 
     /**
      * The sender does not have permission to issue a username.
      **/
-    NotUsernameAuthority: GenericPalletError<Rv>;
+    NotUsernameAuthority: GenericPalletError;
 
     /**
      * The authority cannot allocate any more usernames.
      **/
-    NoAllocation: GenericPalletError<Rv>;
+    NoAllocation: GenericPalletError;
 
     /**
      * The signature on a username was not valid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * Setting this username requires a signature, but none was provided.
      **/
-    RequiresSignature: GenericPalletError<Rv>;
+    RequiresSignature: GenericPalletError;
 
     /**
      * The username does not meet the requirements.
      **/
-    InvalidUsername: GenericPalletError<Rv>;
+    InvalidUsername: GenericPalletError;
 
     /**
      * The username is already taken.
      **/
-    UsernameTaken: GenericPalletError<Rv>;
+    UsernameTaken: GenericPalletError;
 
     /**
      * The requested username does not exist.
      **/
-    NoUsername: GenericPalletError<Rv>;
+    NoUsername: GenericPalletError;
 
     /**
      * The username cannot be forcefully removed because it can still be accepted.
      **/
-    NotExpired: GenericPalletError<Rv>;
+    NotExpired: GenericPalletError;
 
     /**
      * The username cannot be removed because it's still in the grace period.
      **/
-    TooEarly: GenericPalletError<Rv>;
+    TooEarly: GenericPalletError;
 
     /**
      * The username cannot be removed because it is not unbinding.
      **/
-    NotUnbinding: GenericPalletError<Rv>;
+    NotUnbinding: GenericPalletError;
 
     /**
      * The username cannot be unbound because it is already unbinding.
      **/
-    AlreadyUnbinding: GenericPalletError<Rv>;
+    AlreadyUnbinding: GenericPalletError;
 
     /**
      * The action cannot be performed because of insufficient privileges (e.g. authority
      * trying to unbind a username provided by the system).
      **/
-    InsufficientPrivileges: GenericPalletError<Rv>;
+    InsufficientPrivileges: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Multisig`'s errors
@@ -612,78 +612,78 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Threshold must be 2 or greater.
      **/
-    MinimumThreshold: GenericPalletError<Rv>;
+    MinimumThreshold: GenericPalletError;
 
     /**
      * Call is already approved by this signatory.
      **/
-    AlreadyApproved: GenericPalletError<Rv>;
+    AlreadyApproved: GenericPalletError;
 
     /**
      * Call doesn't need any (more) approvals.
      **/
-    NoApprovalsNeeded: GenericPalletError<Rv>;
+    NoApprovalsNeeded: GenericPalletError;
 
     /**
      * There are too few signatories in the list.
      **/
-    TooFewSignatories: GenericPalletError<Rv>;
+    TooFewSignatories: GenericPalletError;
 
     /**
      * There are too many signatories in the list.
      **/
-    TooManySignatories: GenericPalletError<Rv>;
+    TooManySignatories: GenericPalletError;
 
     /**
      * The signatories were provided out of order; they should be ordered.
      **/
-    SignatoriesOutOfOrder: GenericPalletError<Rv>;
+    SignatoriesOutOfOrder: GenericPalletError;
 
     /**
      * The sender was contained in the other signatories; it shouldn't be.
      **/
-    SenderInSignatories: GenericPalletError<Rv>;
+    SenderInSignatories: GenericPalletError;
 
     /**
      * Multisig operation not found in storage.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Only the account that originally created the multisig is able to cancel it or update
      * its deposits.
      **/
-    NotOwner: GenericPalletError<Rv>;
+    NotOwner: GenericPalletError;
 
     /**
      * No timepoint was given, yet the multisig operation is already underway.
      **/
-    NoTimepoint: GenericPalletError<Rv>;
+    NoTimepoint: GenericPalletError;
 
     /**
      * A different timepoint was given to the multisig operation that is underway.
      **/
-    WrongTimepoint: GenericPalletError<Rv>;
+    WrongTimepoint: GenericPalletError;
 
     /**
      * A timepoint was given, yet no multisig operation is underway.
      **/
-    UnexpectedTimepoint: GenericPalletError<Rv>;
+    UnexpectedTimepoint: GenericPalletError;
 
     /**
      * The maximum weight information provided was too low.
      **/
-    MaxWeightTooLow: GenericPalletError<Rv>;
+    MaxWeightTooLow: GenericPalletError;
 
     /**
      * The data to be stored is already stored.
      **/
-    AlreadyStored: GenericPalletError<Rv>;
+    AlreadyStored: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MoonbeamLazyMigrations`'s errors
@@ -692,17 +692,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The contract already have metadata
      **/
-    ContractMetadataAlreadySet: GenericPalletError<Rv>;
+    ContractMetadataAlreadySet: GenericPalletError;
 
     /**
      * Contract not exist
      **/
-    ContractNotExist: GenericPalletError<Rv>;
+    ContractNotExist: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EVM`'s errors
@@ -711,77 +711,77 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Not enough balance to perform action
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * Calculating total fee overflowed
      **/
-    FeeOverflow: GenericPalletError<Rv>;
+    FeeOverflow: GenericPalletError;
 
     /**
      * Calculating total payment overflowed
      **/
-    PaymentOverflow: GenericPalletError<Rv>;
+    PaymentOverflow: GenericPalletError;
 
     /**
      * Withdraw fee failed
      **/
-    WithdrawFailed: GenericPalletError<Rv>;
+    WithdrawFailed: GenericPalletError;
 
     /**
      * Gas price is too low.
      **/
-    GasPriceTooLow: GenericPalletError<Rv>;
+    GasPriceTooLow: GenericPalletError;
 
     /**
      * Nonce is invalid
      **/
-    InvalidNonce: GenericPalletError<Rv>;
+    InvalidNonce: GenericPalletError;
 
     /**
      * Gas limit is too low.
      **/
-    GasLimitTooLow: GenericPalletError<Rv>;
+    GasLimitTooLow: GenericPalletError;
 
     /**
      * Gas limit is too high.
      **/
-    GasLimitTooHigh: GenericPalletError<Rv>;
+    GasLimitTooHigh: GenericPalletError;
 
     /**
      * The chain id is invalid.
      **/
-    InvalidChainId: GenericPalletError<Rv>;
+    InvalidChainId: GenericPalletError;
 
     /**
      * the signature is invalid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * EVM reentrancy
      **/
-    Reentrancy: GenericPalletError<Rv>;
+    Reentrancy: GenericPalletError;
 
     /**
      * EIP-3607,
      **/
-    TransactionMustComeFromEOA: GenericPalletError<Rv>;
+    TransactionMustComeFromEOA: GenericPalletError;
 
     /**
      * Undefined error.
      **/
-    Undefined: GenericPalletError<Rv>;
+    Undefined: GenericPalletError;
 
     /**
      * Address not allowed to deploy contracts either via CREATE or CALL(CREATE).
      **/
-    CreateOriginNotAllowed: GenericPalletError<Rv>;
+    CreateOriginNotAllowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Ethereum`'s errors
@@ -790,17 +790,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Signature is invalid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * Pre-log is present, therefore transact is not allowed.
      **/
-    PreLogExists: GenericPalletError<Rv>;
+    PreLogExists: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Scheduler`'s errors
@@ -809,32 +809,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Failed to schedule a call
      **/
-    FailedToSchedule: GenericPalletError<Rv>;
+    FailedToSchedule: GenericPalletError;
 
     /**
      * Cannot find the scheduled call.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Given target block number is in the past.
      **/
-    TargetBlockNumberInPast: GenericPalletError<Rv>;
+    TargetBlockNumberInPast: GenericPalletError;
 
     /**
      * Reschedule failed because it does not change scheduled time.
      **/
-    RescheduleNoChange: GenericPalletError<Rv>;
+    RescheduleNoChange: GenericPalletError;
 
     /**
      * Attempt to use a non-named function on a named task.
      **/
-    Named: GenericPalletError<Rv>;
+    Named: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Preimage`'s errors
@@ -843,47 +843,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Preimage is too large to store on-chain.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Preimage has already been noted on-chain.
      **/
-    AlreadyNoted: GenericPalletError<Rv>;
+    AlreadyNoted: GenericPalletError;
 
     /**
      * The user is not authorized to perform this action.
      **/
-    NotAuthorized: GenericPalletError<Rv>;
+    NotAuthorized: GenericPalletError;
 
     /**
      * The preimage cannot be removed since it has not yet been noted.
      **/
-    NotNoted: GenericPalletError<Rv>;
+    NotNoted: GenericPalletError;
 
     /**
      * A preimage may not be removed when there are outstanding requests.
      **/
-    Requested: GenericPalletError<Rv>;
+    Requested: GenericPalletError;
 
     /**
      * The preimage request cannot be removed since no outstanding requests exist.
      **/
-    NotRequested: GenericPalletError<Rv>;
+    NotRequested: GenericPalletError;
 
     /**
      * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Too few hashes were requested to be upgraded (i.e. zero).
      **/
-    TooFew: GenericPalletError<Rv>;
+    TooFew: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ConvictionVoting`'s errors
@@ -892,68 +892,68 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Poll is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * The given account did not vote on the poll.
      **/
-    NotVoter: GenericPalletError<Rv>;
+    NotVoter: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action right now but will do in the future.
      **/
-    NoPermissionYet: GenericPalletError<Rv>;
+    NoPermissionYet: GenericPalletError;
 
     /**
      * The account is already delegating.
      **/
-    AlreadyDelegating: GenericPalletError<Rv>;
+    AlreadyDelegating: GenericPalletError;
 
     /**
      * The account currently has votes attached to it and the operation cannot succeed until
      * these are removed through `remove_vote`.
      **/
-    AlreadyVoting: GenericPalletError<Rv>;
+    AlreadyVoting: GenericPalletError;
 
     /**
      * Too high a balance was provided that the account cannot afford.
      **/
-    InsufficientFunds: GenericPalletError<Rv>;
+    InsufficientFunds: GenericPalletError;
 
     /**
      * The account is not currently delegating.
      **/
-    NotDelegating: GenericPalletError<Rv>;
+    NotDelegating: GenericPalletError;
 
     /**
      * Delegation to oneself makes no sense.
      **/
-    Nonsense: GenericPalletError<Rv>;
+    Nonsense: GenericPalletError;
 
     /**
      * Maximum number of votes reached.
      **/
-    MaxVotesReached: GenericPalletError<Rv>;
+    MaxVotesReached: GenericPalletError;
 
     /**
      * The class must be supplied since it is not easily determinable from the state.
      **/
-    ClassNeeded: GenericPalletError<Rv>;
+    ClassNeeded: GenericPalletError;
 
     /**
      * The class ID supplied is invalid.
      **/
-    BadClass: GenericPalletError<Rv>;
+    BadClass: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Referenda`'s errors
@@ -962,77 +962,77 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Referendum is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * Referendum's decision deposit is already paid.
      **/
-    HasDeposit: GenericPalletError<Rv>;
+    HasDeposit: GenericPalletError;
 
     /**
      * The track identifier given was invalid.
      **/
-    BadTrack: GenericPalletError<Rv>;
+    BadTrack: GenericPalletError;
 
     /**
      * There are already a full complement of referenda in progress for this track.
      **/
-    Full: GenericPalletError<Rv>;
+    Full: GenericPalletError;
 
     /**
      * The queue of the track is empty.
      **/
-    QueueEmpty: GenericPalletError<Rv>;
+    QueueEmpty: GenericPalletError;
 
     /**
      * The referendum index provided is invalid in this context.
      **/
-    BadReferendum: GenericPalletError<Rv>;
+    BadReferendum: GenericPalletError;
 
     /**
      * There was nothing to do in the advancement.
      **/
-    NothingToDo: GenericPalletError<Rv>;
+    NothingToDo: GenericPalletError;
 
     /**
      * No track exists for the proposal origin.
      **/
-    NoTrack: GenericPalletError<Rv>;
+    NoTrack: GenericPalletError;
 
     /**
      * Any deposit cannot be refunded until after the decision is over.
      **/
-    Unfinished: GenericPalletError<Rv>;
+    Unfinished: GenericPalletError;
 
     /**
      * The deposit refunder is not the depositor.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The deposit cannot be refunded since none was made.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The referendum status is invalid for this operation.
      **/
-    BadStatus: GenericPalletError<Rv>;
+    BadStatus: GenericPalletError;
 
     /**
      * The preimage does not exist.
      **/
-    PreimageNotExist: GenericPalletError<Rv>;
+    PreimageNotExist: GenericPalletError;
 
     /**
      * The preimage is stored with a different length than the one provided.
      **/
-    PreimageStoredWithDifferentLength: GenericPalletError<Rv>;
+    PreimageStoredWithDifferentLength: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Whitelist`'s errors
@@ -1041,32 +1041,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The preimage of the call hash could not be loaded.
      **/
-    UnavailablePreImage: GenericPalletError<Rv>;
+    UnavailablePreImage: GenericPalletError;
 
     /**
      * The call could not be decoded.
      **/
-    UndecodableCall: GenericPalletError<Rv>;
+    UndecodableCall: GenericPalletError;
 
     /**
      * The weight of the decoded call was higher than the witness.
      **/
-    InvalidCallWeightWitness: GenericPalletError<Rv>;
+    InvalidCallWeightWitness: GenericPalletError;
 
     /**
      * The call was not whitelisted.
      **/
-    CallIsNotWhitelisted: GenericPalletError<Rv>;
+    CallIsNotWhitelisted: GenericPalletError;
 
     /**
      * The call was already whitelisted; No-Op.
      **/
-    CallAlreadyWhitelisted: GenericPalletError<Rv>;
+    CallAlreadyWhitelisted: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `TreasuryCouncilCollective`'s errors
@@ -1075,67 +1075,67 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account is not a member
      **/
-    NotMember: GenericPalletError<Rv>;
+    NotMember: GenericPalletError;
 
     /**
      * Duplicate proposals not allowed
      **/
-    DuplicateProposal: GenericPalletError<Rv>;
+    DuplicateProposal: GenericPalletError;
 
     /**
      * Proposal must exist
      **/
-    ProposalMissing: GenericPalletError<Rv>;
+    ProposalMissing: GenericPalletError;
 
     /**
      * Mismatched index
      **/
-    WrongIndex: GenericPalletError<Rv>;
+    WrongIndex: GenericPalletError;
 
     /**
      * Duplicate vote ignored
      **/
-    DuplicateVote: GenericPalletError<Rv>;
+    DuplicateVote: GenericPalletError;
 
     /**
      * Members are already initialized!
      **/
-    AlreadyInitialized: GenericPalletError<Rv>;
+    AlreadyInitialized: GenericPalletError;
 
     /**
      * The close call was made too early, before the end of the voting.
      **/
-    TooEarly: GenericPalletError<Rv>;
+    TooEarly: GenericPalletError;
 
     /**
      * There can only be a maximum of `MaxProposals` active proposals.
      **/
-    TooManyProposals: GenericPalletError<Rv>;
+    TooManyProposals: GenericPalletError;
 
     /**
      * The given weight bound for the proposal was too low.
      **/
-    WrongProposalWeight: GenericPalletError<Rv>;
+    WrongProposalWeight: GenericPalletError;
 
     /**
      * The given length bound for the proposal was too low.
      **/
-    WrongProposalLength: GenericPalletError<Rv>;
+    WrongProposalLength: GenericPalletError;
 
     /**
      * Prime account is not a member
      **/
-    PrimeAccountNotMember: GenericPalletError<Rv>;
+    PrimeAccountNotMember: GenericPalletError;
 
     /**
      * Proposal is still active.
      **/
-    ProposalActive: GenericPalletError<Rv>;
+    ProposalActive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OpenTechCommitteeCollective`'s errors
@@ -1144,67 +1144,67 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account is not a member
      **/
-    NotMember: GenericPalletError<Rv>;
+    NotMember: GenericPalletError;
 
     /**
      * Duplicate proposals not allowed
      **/
-    DuplicateProposal: GenericPalletError<Rv>;
+    DuplicateProposal: GenericPalletError;
 
     /**
      * Proposal must exist
      **/
-    ProposalMissing: GenericPalletError<Rv>;
+    ProposalMissing: GenericPalletError;
 
     /**
      * Mismatched index
      **/
-    WrongIndex: GenericPalletError<Rv>;
+    WrongIndex: GenericPalletError;
 
     /**
      * Duplicate vote ignored
      **/
-    DuplicateVote: GenericPalletError<Rv>;
+    DuplicateVote: GenericPalletError;
 
     /**
      * Members are already initialized!
      **/
-    AlreadyInitialized: GenericPalletError<Rv>;
+    AlreadyInitialized: GenericPalletError;
 
     /**
      * The close call was made too early, before the end of the voting.
      **/
-    TooEarly: GenericPalletError<Rv>;
+    TooEarly: GenericPalletError;
 
     /**
      * There can only be a maximum of `MaxProposals` active proposals.
      **/
-    TooManyProposals: GenericPalletError<Rv>;
+    TooManyProposals: GenericPalletError;
 
     /**
      * The given weight bound for the proposal was too low.
      **/
-    WrongProposalWeight: GenericPalletError<Rv>;
+    WrongProposalWeight: GenericPalletError;
 
     /**
      * The given length bound for the proposal was too low.
      **/
-    WrongProposalLength: GenericPalletError<Rv>;
+    WrongProposalLength: GenericPalletError;
 
     /**
      * Prime account is not a member
      **/
-    PrimeAccountNotMember: GenericPalletError<Rv>;
+    PrimeAccountNotMember: GenericPalletError;
 
     /**
      * Proposal is still active.
      **/
-    ProposalActive: GenericPalletError<Rv>;
+    ProposalActive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Treasury`'s errors
@@ -1213,63 +1213,63 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * No proposal, bounty or spend at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * Too many approvals in the queue.
      **/
-    TooManyApprovals: GenericPalletError<Rv>;
+    TooManyApprovals: GenericPalletError;
 
     /**
      * The spend origin is valid but the amount it is allowed to spend is lower than the
      * amount to be spent.
      **/
-    InsufficientPermission: GenericPalletError<Rv>;
+    InsufficientPermission: GenericPalletError;
 
     /**
      * Proposal has not been approved.
      **/
-    ProposalNotApproved: GenericPalletError<Rv>;
+    ProposalNotApproved: GenericPalletError;
 
     /**
      * The balance of the asset kind is not convertible to the balance of the native asset.
      **/
-    FailedToConvertBalance: GenericPalletError<Rv>;
+    FailedToConvertBalance: GenericPalletError;
 
     /**
      * The spend has expired and cannot be claimed.
      **/
-    SpendExpired: GenericPalletError<Rv>;
+    SpendExpired: GenericPalletError;
 
     /**
      * The spend is not yet eligible for payout.
      **/
-    EarlyPayout: GenericPalletError<Rv>;
+    EarlyPayout: GenericPalletError;
 
     /**
      * The payment has already been attempted.
      **/
-    AlreadyAttempted: GenericPalletError<Rv>;
+    AlreadyAttempted: GenericPalletError;
 
     /**
      * There was some issue with the mechanism of payment.
      **/
-    PayoutError: GenericPalletError<Rv>;
+    PayoutError: GenericPalletError;
 
     /**
      * The payout was not yet attempted/claimed.
      **/
-    NotAttempted: GenericPalletError<Rv>;
+    NotAttempted: GenericPalletError;
 
     /**
      * The payment has neither failed nor succeeded yet.
      **/
-    Inconclusive: GenericPalletError<Rv>;
+    Inconclusive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CrowdloanRewards`'s errors
@@ -1279,86 +1279,86 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * User trying to associate a native identity with a relay chain identity for posterior
      * reward claiming provided an already associated relay chain identity
      **/
-    AlreadyAssociated: GenericPalletError<Rv>;
+    AlreadyAssociated: GenericPalletError;
 
     /**
      * Trying to introduce a batch that goes beyond the limits of the funds
      **/
-    BatchBeyondFundPot: GenericPalletError<Rv>;
+    BatchBeyondFundPot: GenericPalletError;
 
     /**
      * First claim already done
      **/
-    FirstClaimAlreadyDone: GenericPalletError<Rv>;
+    FirstClaimAlreadyDone: GenericPalletError;
 
     /**
      * The contribution is not high enough to be eligible for rewards
      **/
-    RewardNotHighEnough: GenericPalletError<Rv>;
+    RewardNotHighEnough: GenericPalletError;
 
     /**
      * User trying to associate a native identity with a relay chain identity for posterior
      * reward claiming provided a wrong signature
      **/
-    InvalidClaimSignature: GenericPalletError<Rv>;
+    InvalidClaimSignature: GenericPalletError;
 
     /**
      * User trying to claim the first free reward provided the wrong signature
      **/
-    InvalidFreeClaimSignature: GenericPalletError<Rv>;
+    InvalidFreeClaimSignature: GenericPalletError;
 
     /**
      * User trying to claim an award did not have an claim associated with it. This may mean
      * they did not contribute to the crowdloan, or they have not yet associated a native id
      * with their contribution
      **/
-    NoAssociatedClaim: GenericPalletError<Rv>;
+    NoAssociatedClaim: GenericPalletError;
 
     /**
      * User trying to claim rewards has already claimed all rewards associated with its
      * identity and contribution
      **/
-    RewardsAlreadyClaimed: GenericPalletError<Rv>;
+    RewardsAlreadyClaimed: GenericPalletError;
 
     /**
      * Reward vec has already been initialized
      **/
-    RewardVecAlreadyInitialized: GenericPalletError<Rv>;
+    RewardVecAlreadyInitialized: GenericPalletError;
 
     /**
      * Reward vec has not yet been fully initialized
      **/
-    RewardVecNotFullyInitializedYet: GenericPalletError<Rv>;
+    RewardVecNotFullyInitializedYet: GenericPalletError;
 
     /**
      * Rewards should match funds of the pallet
      **/
-    RewardsDoNotMatchFund: GenericPalletError<Rv>;
+    RewardsDoNotMatchFund: GenericPalletError;
 
     /**
      * Initialize_reward_vec received too many contributors
      **/
-    TooManyContributors: GenericPalletError<Rv>;
+    TooManyContributors: GenericPalletError;
 
     /**
      * Provided vesting period is not valid
      **/
-    VestingPeriodNonValid: GenericPalletError<Rv>;
+    VestingPeriodNonValid: GenericPalletError;
 
     /**
      * User provided a signature from a non-contributor relay account
      **/
-    NonContributedAddressProvided: GenericPalletError<Rv>;
+    NonContributedAddressProvided: GenericPalletError;
 
     /**
      * User submitted an unsifficient number of proofs to change the reward address
      **/
-    InsufficientNumberOfValidProofs: GenericPalletError<Rv>;
+    InsufficientNumberOfValidProofs: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XcmpQueue`'s errors
@@ -1367,32 +1367,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Setting the queue config failed since one of its values was invalid.
      **/
-    BadQueueConfig: GenericPalletError<Rv>;
+    BadQueueConfig: GenericPalletError;
 
     /**
      * The execution is already suspended.
      **/
-    AlreadySuspended: GenericPalletError<Rv>;
+    AlreadySuspended: GenericPalletError;
 
     /**
      * The execution is already resumed.
      **/
-    AlreadyResumed: GenericPalletError<Rv>;
+    AlreadyResumed: GenericPalletError;
 
     /**
      * There are too many active outbound channels.
      **/
-    TooManyActiveOutboundChannels: GenericPalletError<Rv>;
+    TooManyActiveOutboundChannels: GenericPalletError;
 
     /**
      * The message is too big.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `PolkadotXcm`'s errors
@@ -1402,144 +1402,144 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The desired destination was unreachable, generally because there is a no way of routing
      * to it.
      **/
-    Unreachable: GenericPalletError<Rv>;
+    Unreachable: GenericPalletError;
 
     /**
      * There was some other issue (i.e. not to do with routing) in sending the message.
      * Perhaps a lack of space for buffering the message.
      **/
-    SendFailure: GenericPalletError<Rv>;
+    SendFailure: GenericPalletError;
 
     /**
      * The message execution fails the filter.
      **/
-    Filtered: GenericPalletError<Rv>;
+    Filtered: GenericPalletError;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError<Rv>;
+    UnweighableMessage: GenericPalletError;
 
     /**
      * The destination `Location` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError<Rv>;
+    DestinationNotInvertible: GenericPalletError;
 
     /**
      * The assets to be sent are empty.
      **/
-    Empty: GenericPalletError<Rv>;
+    Empty: GenericPalletError;
 
     /**
      * Could not re-anchor the assets to declare the fees for the destination chain.
      **/
-    CannotReanchor: GenericPalletError<Rv>;
+    CannotReanchor: GenericPalletError;
 
     /**
      * Too many assets have been attempted for transfer.
      **/
-    TooManyAssets: GenericPalletError<Rv>;
+    TooManyAssets: GenericPalletError;
 
     /**
      * Origin is invalid for sending.
      **/
-    InvalidOrigin: GenericPalletError<Rv>;
+    InvalidOrigin: GenericPalletError;
 
     /**
      * The version of the `Versioned` value used is not able to be interpreted.
      **/
-    BadVersion: GenericPalletError<Rv>;
+    BadVersion: GenericPalletError;
 
     /**
      * The given location could not be used (e.g. because it cannot be expressed in the
      * desired version of XCM).
      **/
-    BadLocation: GenericPalletError<Rv>;
+    BadLocation: GenericPalletError;
 
     /**
      * The referenced subscription could not be found.
      **/
-    NoSubscription: GenericPalletError<Rv>;
+    NoSubscription: GenericPalletError;
 
     /**
      * The location is invalid since it already has a subscription from us.
      **/
-    AlreadySubscribed: GenericPalletError<Rv>;
+    AlreadySubscribed: GenericPalletError;
 
     /**
      * Could not check-out the assets for teleportation to the destination chain.
      **/
-    CannotCheckOutTeleport: GenericPalletError<Rv>;
+    CannotCheckOutTeleport: GenericPalletError;
 
     /**
      * The owner does not own (all) of the asset that they wish to do the operation on.
      **/
-    LowBalance: GenericPalletError<Rv>;
+    LowBalance: GenericPalletError;
 
     /**
      * The asset owner has too many locks on the asset.
      **/
-    TooManyLocks: GenericPalletError<Rv>;
+    TooManyLocks: GenericPalletError;
 
     /**
      * The given account is not an identifiable sovereign account for any location.
      **/
-    AccountNotSovereign: GenericPalletError<Rv>;
+    AccountNotSovereign: GenericPalletError;
 
     /**
      * The operation required fees to be paid which the initiator could not meet.
      **/
-    FeesNotMet: GenericPalletError<Rv>;
+    FeesNotMet: GenericPalletError;
 
     /**
      * A remote lock with the corresponding data could not be found.
      **/
-    LockNotFound: GenericPalletError<Rv>;
+    LockNotFound: GenericPalletError;
 
     /**
      * The unlock operation cannot succeed because there are still consumers of the lock.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid asset, reserve chain could not be determined for it.
      **/
-    InvalidAssetUnknownReserve: GenericPalletError<Rv>;
+    InvalidAssetUnknownReserve: GenericPalletError;
 
     /**
      * Invalid asset, do not support remote asset reserves with different fees reserves.
      **/
-    InvalidAssetUnsupportedReserve: GenericPalletError<Rv>;
+    InvalidAssetUnsupportedReserve: GenericPalletError;
 
     /**
      * Too many assets with different reserve locations have been attempted for transfer.
      **/
-    TooManyReserves: GenericPalletError<Rv>;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Local XCM execution incomplete.
      **/
-    LocalExecutionIncomplete: GenericPalletError<Rv>;
+    LocalExecutionIncomplete: GenericPalletError;
 
     /**
      * Too many locations authorized to alias origin.
      **/
-    TooManyAuthorizedAliases: GenericPalletError<Rv>;
+    TooManyAuthorizedAliases: GenericPalletError;
 
     /**
      * Expiry block number is in the past.
      **/
-    ExpiresInPast: GenericPalletError<Rv>;
+    ExpiresInPast: GenericPalletError;
 
     /**
      * The alias to remove authorization for was not found.
      **/
-    AliasNotFound: GenericPalletError<Rv>;
+    AliasNotFound: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Assets`'s errors
@@ -1548,162 +1548,162 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account balance must be greater than or equal to the transfer amount.
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * The account to alter does not exist.
      **/
-    NoAccount: GenericPalletError<Rv>;
+    NoAccount: GenericPalletError;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given asset ID is unknown.
      **/
-    Unknown: GenericPalletError<Rv>;
+    Unknown: GenericPalletError;
 
     /**
      * The origin account is frozen.
      **/
-    Frozen: GenericPalletError<Rv>;
+    Frozen: GenericPalletError;
 
     /**
      * The asset ID is already taken.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Minimum balance should be non-zero.
      **/
-    MinBalanceZero: GenericPalletError<Rv>;
+    MinBalanceZero: GenericPalletError;
 
     /**
      * Unable to increment the consumer reference counters on the account. Either no provider
      * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
      * fewer then the maximum number of consumers has been reached.
      **/
-    UnavailableConsumer: GenericPalletError<Rv>;
+    UnavailableConsumer: GenericPalletError;
 
     /**
      * Invalid metadata given.
      **/
-    BadMetadata: GenericPalletError<Rv>;
+    BadMetadata: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The source account would not survive the transfer and it needs to stay alive.
      **/
-    WouldDie: GenericPalletError<Rv>;
+    WouldDie: GenericPalletError;
 
     /**
      * The asset-account already exists.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The asset-account doesn't have an associated deposit.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The operation would result in funds being burned.
      **/
-    WouldBurn: GenericPalletError<Rv>;
+    WouldBurn: GenericPalletError;
 
     /**
      * The asset is a live asset and is actively being used. Usually emit for operations such
      * as `start_destroy` which require the asset to be in a destroying state.
      **/
-    LiveAsset: GenericPalletError<Rv>;
+    LiveAsset: GenericPalletError;
 
     /**
      * The asset is not live, and likely being destroyed.
      **/
-    AssetNotLive: GenericPalletError<Rv>;
+    AssetNotLive: GenericPalletError;
 
     /**
      * The asset status is not the expected status.
      **/
-    IncorrectStatus: GenericPalletError<Rv>;
+    IncorrectStatus: GenericPalletError;
 
     /**
      * The asset should be frozen before the given operation.
      **/
-    NotFrozen: GenericPalletError<Rv>;
+    NotFrozen: GenericPalletError;
 
     /**
      * Callback action resulted in error
      **/
-    CallbackFailed: GenericPalletError<Rv>;
+    CallbackFailed: GenericPalletError;
 
     /**
      * The asset ID must be equal to the [`NextAssetId`].
      **/
-    BadAssetId: GenericPalletError<Rv>;
+    BadAssetId: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain freezes.
      **/
-    ContainsFreezes: GenericPalletError<Rv>;
+    ContainsFreezes: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain holds.
      **/
-    ContainsHolds: GenericPalletError<Rv>;
+    ContainsHolds: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XcmTransactor`'s errors
    **/
   xcmTransactor: {
-    IndexAlreadyClaimed: GenericPalletError<Rv>;
-    UnclaimedIndex: GenericPalletError<Rv>;
-    NotOwner: GenericPalletError<Rv>;
-    UnweighableMessage: GenericPalletError<Rv>;
-    CannotReanchor: GenericPalletError<Rv>;
-    AssetHasNoReserve: GenericPalletError<Rv>;
-    InvalidDest: GenericPalletError<Rv>;
-    NotCrossChainTransfer: GenericPalletError<Rv>;
-    AssetIsNotReserveInDestination: GenericPalletError<Rv>;
-    DestinationNotInvertible: GenericPalletError<Rv>;
-    ErrorDelivering: GenericPalletError<Rv>;
-    DispatchWeightBiggerThanTotalWeight: GenericPalletError<Rv>;
-    WeightOverflow: GenericPalletError<Rv>;
-    AmountOverflow: GenericPalletError<Rv>;
-    TransactorInfoNotSet: GenericPalletError<Rv>;
-    NotCrossChainTransferableCurrency: GenericPalletError<Rv>;
-    XcmExecuteError: GenericPalletError<Rv>;
-    BadVersion: GenericPalletError<Rv>;
-    MaxWeightTransactReached: GenericPalletError<Rv>;
-    UnableToWithdrawAsset: GenericPalletError<Rv>;
-    FeePerSecondNotSet: GenericPalletError<Rv>;
-    SignedTransactNotAllowedForDestination: GenericPalletError<Rv>;
-    FailedMultiLocationToJunction: GenericPalletError<Rv>;
-    HrmpHandlerNotImplemented: GenericPalletError<Rv>;
-    TooMuchFeeUsed: GenericPalletError<Rv>;
-    ErrorValidating: GenericPalletError<Rv>;
-    RefundNotSupportedWithTransactInfo: GenericPalletError<Rv>;
+    IndexAlreadyClaimed: GenericPalletError;
+    UnclaimedIndex: GenericPalletError;
+    NotOwner: GenericPalletError;
+    UnweighableMessage: GenericPalletError;
+    CannotReanchor: GenericPalletError;
+    AssetHasNoReserve: GenericPalletError;
+    InvalidDest: GenericPalletError;
+    NotCrossChainTransfer: GenericPalletError;
+    AssetIsNotReserveInDestination: GenericPalletError;
+    DestinationNotInvertible: GenericPalletError;
+    ErrorDelivering: GenericPalletError;
+    DispatchWeightBiggerThanTotalWeight: GenericPalletError;
+    WeightOverflow: GenericPalletError;
+    AmountOverflow: GenericPalletError;
+    TransactorInfoNotSet: GenericPalletError;
+    NotCrossChainTransferableCurrency: GenericPalletError;
+    XcmExecuteError: GenericPalletError;
+    BadVersion: GenericPalletError;
+    MaxWeightTransactReached: GenericPalletError;
+    UnableToWithdrawAsset: GenericPalletError;
+    FeePerSecondNotSet: GenericPalletError;
+    SignedTransactNotAllowedForDestination: GenericPalletError;
+    FailedMultiLocationToJunction: GenericPalletError;
+    HrmpHandlerNotImplemented: GenericPalletError;
+    TooMuchFeeUsed: GenericPalletError;
+    ErrorValidating: GenericPalletError;
+    RefundNotSupportedWithTransactInfo: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EthereumXcm`'s errors
@@ -1712,12 +1712,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Xcm to Ethereum execution is suspended
      **/
-    EthereumXcmExecutionSuspended: GenericPalletError<Rv>;
+    EthereumXcmExecutionSuspended: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MessageQueue`'s errors
@@ -1727,32 +1727,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Page is not reapable because it has items remaining to be processed and is not old
      * enough.
      **/
-    NotReapable: GenericPalletError<Rv>;
+    NotReapable: GenericPalletError;
 
     /**
      * Page to be reaped does not exist.
      **/
-    NoPage: GenericPalletError<Rv>;
+    NoPage: GenericPalletError;
 
     /**
      * The referenced message could not be found.
      **/
-    NoMessage: GenericPalletError<Rv>;
+    NoMessage: GenericPalletError;
 
     /**
      * The message was already processed and cannot be processed again.
      **/
-    AlreadyProcessed: GenericPalletError<Rv>;
+    AlreadyProcessed: GenericPalletError;
 
     /**
      * The message is queued for future execution.
      **/
-    Queued: GenericPalletError<Rv>;
+    Queued: GenericPalletError;
 
     /**
      * There is temporarily not enough weight to continue servicing messages.
      **/
-    InsufficientWeight: GenericPalletError<Rv>;
+    InsufficientWeight: GenericPalletError;
 
     /**
      * This message is temporarily unprocessable.
@@ -1760,58 +1760,58 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Such errors are expected, but not guaranteed, to resolve themselves eventually through
      * retrying.
      **/
-    TemporarilyUnprocessable: GenericPalletError<Rv>;
+    TemporarilyUnprocessable: GenericPalletError;
 
     /**
      * The queue is paused and no message can be executed from it.
      *
      * This can change at any time and may resolve in the future by re-trying.
      **/
-    QueuePaused: GenericPalletError<Rv>;
+    QueuePaused: GenericPalletError;
 
     /**
      * Another call is in progress and needs to finish before this call can happen.
      **/
-    RecursiveDisallowed: GenericPalletError<Rv>;
+    RecursiveDisallowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EvmForeignAssets`'s errors
    **/
   evmForeignAssets: {
-    AssetAlreadyExists: GenericPalletError<Rv>;
-    AssetAlreadyFrozen: GenericPalletError<Rv>;
-    AssetDoesNotExist: GenericPalletError<Rv>;
-    AssetIdFiltered: GenericPalletError<Rv>;
-    AssetNotFrozen: GenericPalletError<Rv>;
-    CorruptedStorageOrphanLocation: GenericPalletError<Rv>;
-    Erc20ContractCreationFail: GenericPalletError<Rv>;
-    EvmCallPauseFail: GenericPalletError<Rv>;
-    EvmCallUnpauseFail: GenericPalletError<Rv>;
-    EvmCallMintIntoFail: GenericPalletError<Rv>;
-    EvmCallTransferFail: GenericPalletError<Rv>;
-    EvmInternalError: GenericPalletError<Rv>;
+    AssetAlreadyExists: GenericPalletError;
+    AssetAlreadyFrozen: GenericPalletError;
+    AssetDoesNotExist: GenericPalletError;
+    AssetIdFiltered: GenericPalletError;
+    AssetNotFrozen: GenericPalletError;
+    CorruptedStorageOrphanLocation: GenericPalletError;
+    Erc20ContractCreationFail: GenericPalletError;
+    EvmCallPauseFail: GenericPalletError;
+    EvmCallUnpauseFail: GenericPalletError;
+    EvmCallMintIntoFail: GenericPalletError;
+    EvmCallTransferFail: GenericPalletError;
+    EvmInternalError: GenericPalletError;
 
     /**
      * Account has insufficient balance for locking
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
-    CannotConvertLocationToAccount: GenericPalletError<Rv>;
-    LocationOutsideOfOrigin: GenericPalletError<Rv>;
-    AssetNotInSiblingPara: GenericPalletError<Rv>;
-    InvalidSymbol: GenericPalletError<Rv>;
-    InvalidTokenName: GenericPalletError<Rv>;
-    LocationAlreadyExists: GenericPalletError<Rv>;
-    TooManyForeignAssets: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
+    CannotConvertLocationToAccount: GenericPalletError;
+    LocationOutsideOfOrigin: GenericPalletError;
+    AssetNotInSiblingPara: GenericPalletError;
+    InvalidSymbol: GenericPalletError;
+    InvalidTokenName: GenericPalletError;
+    LocationAlreadyExists: GenericPalletError;
+    TooManyForeignAssets: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XcmWeightTrader`'s errors
@@ -1820,42 +1820,42 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The given asset was already added
      **/
-    AssetAlreadyAdded: GenericPalletError<Rv>;
+    AssetAlreadyAdded: GenericPalletError;
 
     /**
      * The given asset was already paused
      **/
-    AssetAlreadyPaused: GenericPalletError<Rv>;
+    AssetAlreadyPaused: GenericPalletError;
 
     /**
      * The given asset was not found
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * The given asset is not paused
      **/
-    AssetNotPaused: GenericPalletError<Rv>;
+    AssetNotPaused: GenericPalletError;
 
     /**
      * XCM location filtered
      **/
-    XcmLocationFiltered: GenericPalletError<Rv>;
+    XcmLocationFiltered: GenericPalletError;
 
     /**
      * The relative price cannot be zero
      **/
-    PriceCannotBeZero: GenericPalletError<Rv>;
+    PriceCannotBeZero: GenericPalletError;
 
     /**
      * The relative price calculation overflowed
      **/
-    PriceOverflow: GenericPalletError<Rv>;
+    PriceOverflow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EmergencyParaXcm`'s errors
@@ -1864,12 +1864,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The current XCM Mode is not Paused
      **/
-    NotInPausedMode: GenericPalletError<Rv>;
+    NotInPausedMode: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MultiBlockMigrations`'s errors
@@ -1878,34 +1878,34 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The operation cannot complete since some MBMs are ongoing.
      **/
-    Ongoing: GenericPalletError<Rv>;
+    Ongoing: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Randomness`'s errors
    **/
   randomness: {
-    RequestCounterOverflowed: GenericPalletError<Rv>;
-    RequestFeeOverflowed: GenericPalletError<Rv>;
-    MustRequestAtLeastOneWord: GenericPalletError<Rv>;
-    CannotRequestMoreWordsThanMax: GenericPalletError<Rv>;
-    CannotRequestRandomnessAfterMaxDelay: GenericPalletError<Rv>;
-    CannotRequestRandomnessBeforeMinDelay: GenericPalletError<Rv>;
-    RequestDNE: GenericPalletError<Rv>;
-    RequestCannotYetBeFulfilled: GenericPalletError<Rv>;
-    OnlyRequesterCanIncreaseFee: GenericPalletError<Rv>;
-    RequestHasNotExpired: GenericPalletError<Rv>;
-    RandomnessResultDNE: GenericPalletError<Rv>;
-    RandomnessResultNotFilled: GenericPalletError<Rv>;
+    RequestCounterOverflowed: GenericPalletError;
+    RequestFeeOverflowed: GenericPalletError;
+    MustRequestAtLeastOneWord: GenericPalletError;
+    CannotRequestMoreWordsThanMax: GenericPalletError;
+    CannotRequestRandomnessAfterMaxDelay: GenericPalletError;
+    CannotRequestRandomnessBeforeMinDelay: GenericPalletError;
+    RequestDNE: GenericPalletError;
+    RequestCannotYetBeFulfilled: GenericPalletError;
+    OnlyRequesterCanIncreaseFee: GenericPalletError;
+    RequestHasNotExpired: GenericPalletError;
+    RandomnessResultDNE: GenericPalletError;
+    RandomnessResultNotFilled: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `BridgeKusamaGrandpa`'s errors
@@ -1914,73 +1914,73 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The given justification is invalid for the given header.
      **/
-    InvalidJustification: GenericPalletError<Rv>;
+    InvalidJustification: GenericPalletError;
 
     /**
      * The authority set from the underlying header chain is invalid.
      **/
-    InvalidAuthoritySet: GenericPalletError<Rv>;
+    InvalidAuthoritySet: GenericPalletError;
 
     /**
      * The header being imported is older than the best finalized header known to the pallet.
      **/
-    OldHeader: GenericPalletError<Rv>;
+    OldHeader: GenericPalletError;
 
     /**
      * The scheduled authority set change found in the header is unsupported by the pallet.
      *
      * This is the case for non-standard (e.g forced) authority set changes.
      **/
-    UnsupportedScheduledChange: GenericPalletError<Rv>;
+    UnsupportedScheduledChange: GenericPalletError;
 
     /**
      * The pallet is not yet initialized.
      **/
-    NotInitialized: GenericPalletError<Rv>;
+    NotInitialized: GenericPalletError;
 
     /**
      * The pallet has already been initialized.
      **/
-    AlreadyInitialized: GenericPalletError<Rv>;
+    AlreadyInitialized: GenericPalletError;
 
     /**
      * Too many authorities in the set.
      **/
-    TooManyAuthoritiesInSet: GenericPalletError<Rv>;
+    TooManyAuthoritiesInSet: GenericPalletError;
 
     /**
      * Error generated by the `OwnedBridgeModule` trait.
      **/
-    BridgeModule: GenericPalletError<Rv>;
+    BridgeModule: GenericPalletError;
 
     /**
      * The `current_set_id` argument of the `submit_finality_proof_ex` doesn't match
      * the id of the current set, known to the pallet.
      **/
-    InvalidAuthoritySetId: GenericPalletError<Rv>;
+    InvalidAuthoritySetId: GenericPalletError;
 
     /**
      * The submitter wanted free execution, but we can't fit more free transactions
      * to the block.
      **/
-    FreeHeadersLimitExceded: GenericPalletError<Rv>;
+    FreeHeadersLimitExceded: GenericPalletError;
 
     /**
      * The submitter wanted free execution, but the difference between best known and
      * bundled header numbers is below the `FreeHeadersInterval`.
      **/
-    BelowFreeHeaderInterval: GenericPalletError<Rv>;
+    BelowFreeHeaderInterval: GenericPalletError;
 
     /**
      * The header (and its finality) submission overflows hardcoded chain limits: size
      * and/or weight are larger than expected.
      **/
-    HeaderOverflowLimits: GenericPalletError<Rv>;
+    HeaderOverflowLimits: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `BridgeKusamaParachains`'s errors
@@ -1989,27 +1989,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Relay chain block hash is unknown to us.
      **/
-    UnknownRelayChainBlock: GenericPalletError<Rv>;
+    UnknownRelayChainBlock: GenericPalletError;
 
     /**
      * The number of stored relay block is different from what the relayer has provided.
      **/
-    InvalidRelayChainBlockNumber: GenericPalletError<Rv>;
+    InvalidRelayChainBlockNumber: GenericPalletError;
 
     /**
      * Parachain heads storage proof is invalid.
      **/
-    HeaderChainStorageProof: GenericPalletError<Rv>;
+    HeaderChainStorageProof: GenericPalletError;
 
     /**
      * Error generated by the `OwnedBridgeModule` trait.
      **/
-    BridgeModule: GenericPalletError<Rv>;
+    BridgeModule: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `BridgeKusamaMessages`'s errors
@@ -2018,59 +2018,59 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Pallet is not in Normal operating mode.
      **/
-    NotOperatingNormally: GenericPalletError<Rv>;
+    NotOperatingNormally: GenericPalletError;
 
     /**
      * Error that is reported by the lanes manager.
      **/
-    LanesManager: GenericPalletError<Rv>;
+    LanesManager: GenericPalletError;
 
     /**
      * Message has been treated as invalid by the pallet logic.
      **/
-    MessageRejectedByPallet: GenericPalletError<Rv>;
+    MessageRejectedByPallet: GenericPalletError;
 
     /**
      * The transaction brings too many messages.
      **/
-    TooManyMessagesInTheProof: GenericPalletError<Rv>;
+    TooManyMessagesInTheProof: GenericPalletError;
 
     /**
      * Invalid messages has been submitted.
      **/
-    InvalidMessagesProof: GenericPalletError<Rv>;
+    InvalidMessagesProof: GenericPalletError;
 
     /**
      * Invalid messages delivery proof has been submitted.
      **/
-    InvalidMessagesDeliveryProof: GenericPalletError<Rv>;
+    InvalidMessagesDeliveryProof: GenericPalletError;
 
     /**
      * The relayer has declared invalid unrewarded relayers state in the
      * `receive_messages_delivery_proof` call.
      **/
-    InvalidUnrewardedRelayersState: GenericPalletError<Rv>;
+    InvalidUnrewardedRelayersState: GenericPalletError;
 
     /**
      * The cumulative dispatch weight, passed by relayer is not enough to cover dispatch
      * of all bundled messages.
      **/
-    InsufficientDispatchWeight: GenericPalletError<Rv>;
+    InsufficientDispatchWeight: GenericPalletError;
 
     /**
      * Error confirming messages receival.
      **/
-    ReceptionConfirmation: GenericPalletError<Rv>;
+    ReceptionConfirmation: GenericPalletError;
 
     /**
      * Error generated by the `OwnedBridgeModule` trait.
      **/
-    BridgeModule: GenericPalletError<Rv>;
+    BridgeModule: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `BridgeXcmOverMoonriver`'s errors
@@ -2079,51 +2079,51 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Bridge locations error.
      **/
-    BridgeLocations: GenericPalletError<Rv>;
+    BridgeLocations: GenericPalletError;
 
     /**
      * Invalid local bridge origin account.
      **/
-    InvalidBridgeOriginAccount: GenericPalletError<Rv>;
+    InvalidBridgeOriginAccount: GenericPalletError;
 
     /**
      * The bridge is already registered in this pallet.
      **/
-    BridgeAlreadyExists: GenericPalletError<Rv>;
+    BridgeAlreadyExists: GenericPalletError;
 
     /**
      * The local origin already owns a maximal number of bridges.
      **/
-    TooManyBridgesForLocalOrigin: GenericPalletError<Rv>;
+    TooManyBridgesForLocalOrigin: GenericPalletError;
 
     /**
      * Trying to close already closed bridge.
      **/
-    BridgeAlreadyClosed: GenericPalletError<Rv>;
+    BridgeAlreadyClosed: GenericPalletError;
 
     /**
      * Lanes manager error.
      **/
-    LanesManager: GenericPalletError<Rv>;
+    LanesManager: GenericPalletError;
 
     /**
      * Trying to access unknown bridge.
      **/
-    UnknownBridge: GenericPalletError<Rv>;
+    UnknownBridge: GenericPalletError;
 
     /**
      * The bridge origin can't pay the required amount for opening the bridge.
      **/
-    FailedToReserveBridgeDeposit: GenericPalletError<Rv>;
+    FailedToReserveBridgeDeposit: GenericPalletError;
 
     /**
      * The version of XCM location argument is unsupported.
      **/
-    UnsupportedXcmVersion: GenericPalletError<Rv>;
+    UnsupportedXcmVersion: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
 }