@dedot/api 0.18.8 → 1.0.0

package/chaintypes/substrate/errors.d.ts

@@ -1,5 +1,5 @@
-import type { GenericChainErrors, GenericPalletError, RpcVersion } from '@dedot/types';
-export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+import type { GenericChainErrors, GenericPalletError } from '@dedot/types';
+export interface ChainErrors extends GenericChainErrors {
     /**
      * Pallet `System`'s errors
      **/
@@ -8,46 +8,46 @@ 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 `Utility`'s errors
@@ -56,11 +56,11 @@ 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 `Babe`'s errors
@@ -69,23 +69,23 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * An equivocation proof provided as part of an equivocation report is invalid.
          **/
-        InvalidEquivocationProof: GenericPalletError<Rv>;
+        InvalidEquivocationProof: GenericPalletError;
         /**
          * A key ownership proof provided as part of an equivocation report is invalid.
          **/
-        InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+        InvalidKeyOwnershipProof: GenericPalletError;
         /**
          * A given equivocation report is valid but already previously reported.
          **/
-        DuplicateOffenceReport: GenericPalletError<Rv>;
+        DuplicateOffenceReport: GenericPalletError;
         /**
          * Submitted configuration is invalid.
          **/
-        InvalidConfiguration: GenericPalletError<Rv>;
+        InvalidConfiguration: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Indices`'s errors
@@ -94,27 +94,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The index was not already assigned.
          **/
-        NotAssigned: GenericPalletError<Rv>;
+        NotAssigned: GenericPalletError;
         /**
          * The index is assigned to another account.
          **/
-        NotOwner: GenericPalletError<Rv>;
+        NotOwner: GenericPalletError;
         /**
          * The index was not available.
          **/
-        InUse: GenericPalletError<Rv>;
+        InUse: GenericPalletError;
         /**
          * The source and destination accounts are identical.
          **/
-        NotTransfer: GenericPalletError<Rv>;
+        NotTransfer: GenericPalletError;
         /**
          * The index is permanent and may not be freed/changed.
          **/
-        Permanent: GenericPalletError<Rv>;
+        Permanent: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Balances`'s errors
@@ -123,55 +123,55 @@ 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 `ElectionProviderMultiPhase`'s errors
@@ -180,67 +180,67 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Submission was too early.
          **/
-        PreDispatchEarlySubmission: GenericPalletError<Rv>;
+        PreDispatchEarlySubmission: GenericPalletError;
         /**
          * Wrong number of winners presented.
          **/
-        PreDispatchWrongWinnerCount: GenericPalletError<Rv>;
+        PreDispatchWrongWinnerCount: GenericPalletError;
         /**
          * Submission was too weak, score-wise.
          **/
-        PreDispatchWeakSubmission: GenericPalletError<Rv>;
+        PreDispatchWeakSubmission: GenericPalletError;
         /**
          * The queue was full, and the solution was not better than any of the existing ones.
          **/
-        SignedQueueFull: GenericPalletError<Rv>;
+        SignedQueueFull: GenericPalletError;
         /**
          * The origin failed to pay the deposit.
          **/
-        SignedCannotPayDeposit: GenericPalletError<Rv>;
+        SignedCannotPayDeposit: GenericPalletError;
         /**
          * Witness data to dispatchable is invalid.
          **/
-        SignedInvalidWitness: GenericPalletError<Rv>;
+        SignedInvalidWitness: GenericPalletError;
         /**
          * The signed submission consumes too much weight
          **/
-        SignedTooMuchWeight: GenericPalletError<Rv>;
+        SignedTooMuchWeight: GenericPalletError;
         /**
          * OCW submitted solution for wrong round
          **/
-        OcwCallWrongEra: GenericPalletError<Rv>;
+        OcwCallWrongEra: GenericPalletError;
         /**
          * Snapshot metadata should exist but didn't.
          **/
-        MissingSnapshotMetadata: GenericPalletError<Rv>;
+        MissingSnapshotMetadata: GenericPalletError;
         /**
          * `Self::insert_submission` returned an invalid index.
          **/
-        InvalidSubmissionIndex: GenericPalletError<Rv>;
+        InvalidSubmissionIndex: GenericPalletError;
         /**
          * The call is not allowed at this point.
          **/
-        CallNotAllowed: GenericPalletError<Rv>;
+        CallNotAllowed: GenericPalletError;
         /**
          * The fallback failed
          **/
-        FallbackFailed: GenericPalletError<Rv>;
+        FallbackFailed: GenericPalletError;
         /**
          * Some bound not met
          **/
-        BoundNotMet: GenericPalletError<Rv>;
+        BoundNotMet: GenericPalletError;
         /**
          * Submitted solution has too many winners
          **/
-        TooManyWinners: GenericPalletError<Rv>;
+        TooManyWinners: GenericPalletError;
         /**
          * Submission was prepared for a different round.
          **/
-        PreDispatchDifferentRound: GenericPalletError<Rv>;
+        PreDispatchDifferentRound: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Staking`'s errors
@@ -249,148 +249,148 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Not a controller account.
          **/
-        NotController: GenericPalletError<Rv>;
+        NotController: GenericPalletError;
         /**
          * Not a stash account.
          **/
-        NotStash: GenericPalletError<Rv>;
+        NotStash: GenericPalletError;
         /**
          * Stash is already bonded.
          **/
-        AlreadyBonded: GenericPalletError<Rv>;
+        AlreadyBonded: GenericPalletError;
         /**
          * Controller is already paired.
          **/
-        AlreadyPaired: GenericPalletError<Rv>;
+        AlreadyPaired: GenericPalletError;
         /**
          * Targets cannot be empty.
          **/
-        EmptyTargets: GenericPalletError<Rv>;
+        EmptyTargets: GenericPalletError;
         /**
          * Duplicate index.
          **/
-        DuplicateIndex: GenericPalletError<Rv>;
+        DuplicateIndex: GenericPalletError;
         /**
          * Slash record index out of bounds.
          **/
-        InvalidSlashIndex: GenericPalletError<Rv>;
+        InvalidSlashIndex: GenericPalletError;
         /**
          * Cannot have a validator or nominator role, with value less than the minimum defined by
          * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
          * intention, `chill` first to remove one's role as validator/nominator.
          **/
-        InsufficientBond: GenericPalletError<Rv>;
+        InsufficientBond: GenericPalletError;
         /**
          * Can not schedule more unlock chunks.
          **/
-        NoMoreChunks: GenericPalletError<Rv>;
+        NoMoreChunks: GenericPalletError;
         /**
          * Can not rebond without unlocking chunks.
          **/
-        NoUnlockChunk: GenericPalletError<Rv>;
+        NoUnlockChunk: GenericPalletError;
         /**
          * Attempting to target a stash that still has funds.
          **/
-        FundedTarget: GenericPalletError<Rv>;
+        FundedTarget: GenericPalletError;
         /**
          * Invalid era to reward.
          **/
-        InvalidEraToReward: GenericPalletError<Rv>;
+        InvalidEraToReward: GenericPalletError;
         /**
          * Invalid number of nominations.
          **/
-        InvalidNumberOfNominations: GenericPalletError<Rv>;
+        InvalidNumberOfNominations: GenericPalletError;
         /**
          * Items are not sorted and unique.
          **/
-        NotSortedAndUnique: GenericPalletError<Rv>;
+        NotSortedAndUnique: GenericPalletError;
         /**
          * Rewards for this era have already been claimed for this validator.
          **/
-        AlreadyClaimed: GenericPalletError<Rv>;
+        AlreadyClaimed: GenericPalletError;
         /**
          * No nominators exist on this page.
          **/
-        InvalidPage: GenericPalletError<Rv>;
+        InvalidPage: GenericPalletError;
         /**
          * Incorrect previous history depth input provided.
          **/
-        IncorrectHistoryDepth: GenericPalletError<Rv>;
+        IncorrectHistoryDepth: GenericPalletError;
         /**
          * Incorrect number of slashing spans provided.
          **/
-        IncorrectSlashingSpans: GenericPalletError<Rv>;
+        IncorrectSlashingSpans: GenericPalletError;
         /**
          * Internal state has become somehow corrupted and the operation cannot continue.
          **/
-        BadState: GenericPalletError<Rv>;
+        BadState: GenericPalletError;
         /**
          * Too many nomination targets supplied.
          **/
-        TooManyTargets: GenericPalletError<Rv>;
+        TooManyTargets: GenericPalletError;
         /**
          * A nomination target was supplied that was blocked or otherwise not a validator.
          **/
-        BadTarget: GenericPalletError<Rv>;
+        BadTarget: GenericPalletError;
         /**
          * The user has enough bond and thus cannot be chilled forcefully by an external person.
          **/
-        CannotChillOther: GenericPalletError<Rv>;
+        CannotChillOther: GenericPalletError;
         /**
          * There are too many nominators in the system. Governance needs to adjust the staking
          * settings to keep things safe for the runtime.
          **/
-        TooManyNominators: GenericPalletError<Rv>;
+        TooManyNominators: GenericPalletError;
         /**
          * There are too many validator candidates in the system. Governance needs to adjust the
          * staking settings to keep things safe for the runtime.
          **/
-        TooManyValidators: GenericPalletError<Rv>;
+        TooManyValidators: GenericPalletError;
         /**
          * Commission is too low. Must be at least `MinCommission`.
          **/
-        CommissionTooLow: GenericPalletError<Rv>;
+        CommissionTooLow: GenericPalletError;
         /**
          * Some bound is not met.
          **/
-        BoundNotMet: GenericPalletError<Rv>;
+        BoundNotMet: GenericPalletError;
         /**
          * Used when attempting to use deprecated controller account logic.
          **/
-        ControllerDeprecated: GenericPalletError<Rv>;
+        ControllerDeprecated: GenericPalletError;
         /**
          * Cannot reset a ledger.
          **/
-        CannotRestoreLedger: GenericPalletError<Rv>;
+        CannotRestoreLedger: GenericPalletError;
         /**
          * Provided reward destination is not allowed.
          **/
-        RewardDestinationRestricted: GenericPalletError<Rv>;
+        RewardDestinationRestricted: GenericPalletError;
         /**
          * Not enough funds available to withdraw.
          **/
-        NotEnoughFunds: GenericPalletError<Rv>;
+        NotEnoughFunds: GenericPalletError;
         /**
          * Operation not allowed for virtual stakers.
          **/
-        VirtualStakerNotAllowed: GenericPalletError<Rv>;
+        VirtualStakerNotAllowed: GenericPalletError;
         /**
          * Stash could not be reaped as other pallet might depend on it.
          **/
-        CannotReapStash: GenericPalletError<Rv>;
+        CannotReapStash: GenericPalletError;
         /**
          * The stake of this account is already migrated to `Fungible` holds.
          **/
-        AlreadyMigrated: GenericPalletError<Rv>;
+        AlreadyMigrated: GenericPalletError;
         /**
          * Account is restricted from participation in staking. This may happen if the account is
          * staking in another way already, such as via pool.
          **/
-        Restricted: GenericPalletError<Rv>;
+        Restricted: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Session`'s errors
@@ -399,27 +399,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Invalid ownership proof.
          **/
-        InvalidProof: GenericPalletError<Rv>;
+        InvalidProof: GenericPalletError;
         /**
          * No associated validator ID for account.
          **/
-        NoAssociatedValidatorId: GenericPalletError<Rv>;
+        NoAssociatedValidatorId: GenericPalletError;
         /**
          * Registered duplicate key.
          **/
-        DuplicatedKey: GenericPalletError<Rv>;
+        DuplicatedKey: GenericPalletError;
         /**
          * No keys are associated with this account.
          **/
-        NoKeys: GenericPalletError<Rv>;
+        NoKeys: GenericPalletError;
         /**
          * Key setting account is not live, so it's impossible to associate keys.
          **/
-        NoAccount: GenericPalletError<Rv>;
+        NoAccount: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Democracy`'s errors
@@ -428,104 +428,104 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Value too low
          **/
-        ValueLow: GenericPalletError<Rv>;
+        ValueLow: GenericPalletError;
         /**
          * Proposal does not exist
          **/
-        ProposalMissing: GenericPalletError<Rv>;
+        ProposalMissing: GenericPalletError;
         /**
          * Cannot cancel the same proposal twice
          **/
-        AlreadyCanceled: GenericPalletError<Rv>;
+        AlreadyCanceled: GenericPalletError;
         /**
          * Proposal already made
          **/
-        DuplicateProposal: GenericPalletError<Rv>;
+        DuplicateProposal: GenericPalletError;
         /**
          * Proposal still blacklisted
          **/
-        ProposalBlacklisted: GenericPalletError<Rv>;
+        ProposalBlacklisted: GenericPalletError;
         /**
          * Next external proposal not simple majority
          **/
-        NotSimpleMajority: GenericPalletError<Rv>;
+        NotSimpleMajority: GenericPalletError;
         /**
          * Invalid hash
          **/
-        InvalidHash: GenericPalletError<Rv>;
+        InvalidHash: GenericPalletError;
         /**
          * No external proposal
          **/
-        NoProposal: GenericPalletError<Rv>;
+        NoProposal: GenericPalletError;
         /**
          * Identity may not veto a proposal twice
          **/
-        AlreadyVetoed: GenericPalletError<Rv>;
+        AlreadyVetoed: GenericPalletError;
         /**
          * Vote given for invalid referendum
          **/
-        ReferendumInvalid: GenericPalletError<Rv>;
+        ReferendumInvalid: GenericPalletError;
         /**
          * No proposals waiting
          **/
-        NoneWaiting: GenericPalletError<Rv>;
+        NoneWaiting: GenericPalletError;
         /**
          * The given account did not vote on the referendum.
          **/
-        NotVoter: GenericPalletError<Rv>;
+        NotVoter: GenericPalletError;
         /**
          * The actor has no permission to conduct the action.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * The account is already delegating.
          **/
-        AlreadyDelegating: GenericPalletError<Rv>;
+        AlreadyDelegating: 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;
         /**
          * The account currently has votes attached to it and the operation cannot succeed until
          * these are removed, either through `unvote` or `reap_vote`.
          **/
-        VotesExist: GenericPalletError<Rv>;
+        VotesExist: GenericPalletError;
         /**
          * The instant referendum origin is currently disallowed.
          **/
-        InstantNotAllowed: GenericPalletError<Rv>;
+        InstantNotAllowed: GenericPalletError;
         /**
          * Delegation to oneself makes no sense.
          **/
-        Nonsense: GenericPalletError<Rv>;
+        Nonsense: GenericPalletError;
         /**
          * Invalid upper bound.
          **/
-        WrongUpperBound: GenericPalletError<Rv>;
+        WrongUpperBound: GenericPalletError;
         /**
          * Maximum number of votes reached.
          **/
-        MaxVotesReached: GenericPalletError<Rv>;
+        MaxVotesReached: GenericPalletError;
         /**
          * Maximum number of items reached.
          **/
-        TooMany: GenericPalletError<Rv>;
+        TooMany: GenericPalletError;
         /**
          * Voting period too low
          **/
-        VotingPeriodLow: GenericPalletError<Rv>;
+        VotingPeriodLow: GenericPalletError;
         /**
          * The preimage does not exist.
          **/
-        PreimageNotExist: GenericPalletError<Rv>;
+        PreimageNotExist: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Council`'s errors
@@ -534,55 +534,55 @@ 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 `TechnicalCommittee`'s errors
@@ -591,55 +591,55 @@ 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 `Elections`'s errors
@@ -648,75 +648,75 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Cannot vote when no candidates or members exist.
          **/
-        UnableToVote: GenericPalletError<Rv>;
+        UnableToVote: GenericPalletError;
         /**
          * Must vote for at least one candidate.
          **/
-        NoVotes: GenericPalletError<Rv>;
+        NoVotes: GenericPalletError;
         /**
          * Cannot vote more than candidates.
          **/
-        TooManyVotes: GenericPalletError<Rv>;
+        TooManyVotes: GenericPalletError;
         /**
          * Cannot vote more than maximum allowed.
          **/
-        MaximumVotesExceeded: GenericPalletError<Rv>;
+        MaximumVotesExceeded: GenericPalletError;
         /**
          * Cannot vote with stake less than minimum balance.
          **/
-        LowBalance: GenericPalletError<Rv>;
+        LowBalance: GenericPalletError;
         /**
          * Voter can not pay voting bond.
          **/
-        UnableToPayBond: GenericPalletError<Rv>;
+        UnableToPayBond: GenericPalletError;
         /**
          * Must be a voter.
          **/
-        MustBeVoter: GenericPalletError<Rv>;
+        MustBeVoter: GenericPalletError;
         /**
          * Duplicated candidate submission.
          **/
-        DuplicatedCandidate: GenericPalletError<Rv>;
+        DuplicatedCandidate: GenericPalletError;
         /**
          * Too many candidates have been created.
          **/
-        TooManyCandidates: GenericPalletError<Rv>;
+        TooManyCandidates: GenericPalletError;
         /**
          * Member cannot re-submit candidacy.
          **/
-        MemberSubmit: GenericPalletError<Rv>;
+        MemberSubmit: GenericPalletError;
         /**
          * Runner cannot re-submit candidacy.
          **/
-        RunnerUpSubmit: GenericPalletError<Rv>;
+        RunnerUpSubmit: GenericPalletError;
         /**
          * Candidate does not have enough funds.
          **/
-        InsufficientCandidateFunds: GenericPalletError<Rv>;
+        InsufficientCandidateFunds: GenericPalletError;
         /**
          * Not a member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * The provided count of number of candidates is incorrect.
          **/
-        InvalidWitnessData: GenericPalletError<Rv>;
+        InvalidWitnessData: GenericPalletError;
         /**
          * The provided count of number of votes is incorrect.
          **/
-        InvalidVoteCount: GenericPalletError<Rv>;
+        InvalidVoteCount: GenericPalletError;
         /**
          * The renouncing origin presented a wrong `Renouncing` parameter.
          **/
-        InvalidRenouncing: GenericPalletError<Rv>;
+        InvalidRenouncing: GenericPalletError;
         /**
          * Prediction regarding replacement after member removal is wrong.
          **/
-        InvalidReplacement: GenericPalletError<Rv>;
+        InvalidReplacement: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `TechnicalMembership`'s errors
@@ -725,19 +725,19 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Already a member.
          **/
-        AlreadyMember: GenericPalletError<Rv>;
+        AlreadyMember: GenericPalletError;
         /**
          * Not a member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * Too many members.
          **/
-        TooManyMembers: GenericPalletError<Rv>;
+        TooManyMembers: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Grandpa`'s errors
@@ -747,36 +747,36 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          * Attempt to signal GRANDPA pause when the authority set isn't live
          * (either paused or already pending pause).
          **/
-        PauseFailed: GenericPalletError<Rv>;
+        PauseFailed: GenericPalletError;
         /**
          * Attempt to signal GRANDPA resume when the authority set isn't paused
          * (either live or already pending resume).
          **/
-        ResumeFailed: GenericPalletError<Rv>;
+        ResumeFailed: GenericPalletError;
         /**
          * Attempt to signal GRANDPA change with one already pending.
          **/
-        ChangePending: GenericPalletError<Rv>;
+        ChangePending: GenericPalletError;
         /**
          * Cannot signal forced change so soon after last.
          **/
-        TooSoon: GenericPalletError<Rv>;
+        TooSoon: GenericPalletError;
         /**
          * A key ownership proof provided as part of an equivocation report is invalid.
          **/
-        InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+        InvalidKeyOwnershipProof: GenericPalletError;
         /**
          * An equivocation proof provided as part of an equivocation report is invalid.
          **/
-        InvalidEquivocationProof: GenericPalletError<Rv>;
+        InvalidEquivocationProof: GenericPalletError;
         /**
          * A given equivocation report is valid but already previously reported.
          **/
-        DuplicateOffenceReport: GenericPalletError<Rv>;
+        DuplicateOffenceReport: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Treasury`'s errors
@@ -785,52 +785,52 @@ 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 `AssetRate`'s errors
@@ -839,19 +839,19 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The given asset ID is unknown.
          **/
-        UnknownAssetKind: GenericPalletError<Rv>;
+        UnknownAssetKind: GenericPalletError;
         /**
          * The given asset ID already has an assigned conversion rate and cannot be re-created.
          **/
-        AlreadyExists: GenericPalletError<Rv>;
+        AlreadyExists: GenericPalletError;
         /**
          * Overflow ocurred when calculating the inverse rate.
          **/
-        Overflow: GenericPalletError<Rv>;
+        Overflow: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Contracts`'s errors
@@ -860,129 +860,129 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Invalid schedule supplied, e.g. with zero weight of a basic operation.
          **/
-        InvalidSchedule: GenericPalletError<Rv>;
+        InvalidSchedule: GenericPalletError;
         /**
          * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
          **/
-        InvalidCallFlags: GenericPalletError<Rv>;
+        InvalidCallFlags: GenericPalletError;
         /**
          * The executed contract exhausted its gas limit.
          **/
-        OutOfGas: GenericPalletError<Rv>;
+        OutOfGas: GenericPalletError;
         /**
          * The output buffer supplied to a contract API call was too small.
          **/
-        OutputBufferTooSmall: GenericPalletError<Rv>;
+        OutputBufferTooSmall: GenericPalletError;
         /**
          * Performing the requested transfer failed. Probably because there isn't enough
          * free balance in the sender's account.
          **/
-        TransferFailed: GenericPalletError<Rv>;
+        TransferFailed: GenericPalletError;
         /**
          * Performing a call was denied because the calling depth reached the limit
          * of what is specified in the schedule.
          **/
-        MaxCallDepthReached: GenericPalletError<Rv>;
+        MaxCallDepthReached: GenericPalletError;
         /**
          * No contract was found at the specified address.
          **/
-        ContractNotFound: GenericPalletError<Rv>;
+        ContractNotFound: GenericPalletError;
         /**
          * The code supplied to `instantiate_with_code` exceeds the limit specified in the
          * current schedule.
          **/
-        CodeTooLarge: GenericPalletError<Rv>;
+        CodeTooLarge: GenericPalletError;
         /**
          * No code could be found at the supplied code hash.
          **/
-        CodeNotFound: GenericPalletError<Rv>;
+        CodeNotFound: GenericPalletError;
         /**
          * No code info could be found at the supplied code hash.
          **/
-        CodeInfoNotFound: GenericPalletError<Rv>;
+        CodeInfoNotFound: GenericPalletError;
         /**
          * A buffer outside of sandbox memory was passed to a contract API function.
          **/
-        OutOfBounds: GenericPalletError<Rv>;
+        OutOfBounds: GenericPalletError;
         /**
          * Input passed to a contract API function failed to decode as expected type.
          **/
-        DecodingFailed: GenericPalletError<Rv>;
+        DecodingFailed: GenericPalletError;
         /**
          * Contract trapped during execution.
          **/
-        ContractTrapped: GenericPalletError<Rv>;
+        ContractTrapped: GenericPalletError;
         /**
          * The size defined in `T::MaxValueSize` was exceeded.
          **/
-        ValueTooLarge: GenericPalletError<Rv>;
+        ValueTooLarge: GenericPalletError;
         /**
          * Termination of a contract is not allowed while the contract is already
          * on the call stack. Can be triggered by `seal_terminate`.
          **/
-        TerminatedWhileReentrant: GenericPalletError<Rv>;
+        TerminatedWhileReentrant: GenericPalletError;
         /**
          * `seal_call` forwarded this contracts input. It therefore is no longer available.
          **/
-        InputForwarded: GenericPalletError<Rv>;
+        InputForwarded: GenericPalletError;
         /**
          * The subject passed to `seal_random` exceeds the limit.
          **/
-        RandomSubjectTooLong: GenericPalletError<Rv>;
+        RandomSubjectTooLong: GenericPalletError;
         /**
          * The amount of topics passed to `seal_deposit_events` exceeds the limit.
          **/
-        TooManyTopics: GenericPalletError<Rv>;
+        TooManyTopics: GenericPalletError;
         /**
          * The chain does not provide a chain extension. Calling the chain extension results
          * in this error. Note that this usually shouldn't happen as deploying such contracts
          * is rejected.
          **/
-        NoChainExtension: GenericPalletError<Rv>;
+        NoChainExtension: GenericPalletError;
         /**
          * Failed to decode the XCM program.
          **/
-        XcmDecodeFailed: GenericPalletError<Rv>;
+        XcmDecodeFailed: GenericPalletError;
         /**
          * A contract with the same AccountId already exists.
          **/
-        DuplicateContract: GenericPalletError<Rv>;
+        DuplicateContract: GenericPalletError;
         /**
          * A contract self destructed in its constructor.
          *
          * This can be triggered by a call to `seal_terminate`.
          **/
-        TerminatedInConstructor: GenericPalletError<Rv>;
+        TerminatedInConstructor: GenericPalletError;
         /**
          * A call tried to invoke a contract that is flagged as non-reentrant.
          * The only other cause is that a call from a contract into the runtime tried to call back
          * into `pallet-contracts`. This would make the whole pallet reentrant with regard to
          * contract code execution which is not supported.
          **/
-        ReentranceDenied: GenericPalletError<Rv>;
+        ReentranceDenied: GenericPalletError;
         /**
          * A contract attempted to invoke a state modifying API while being in read-only mode.
          **/
-        StateChangeDenied: GenericPalletError<Rv>;
+        StateChangeDenied: GenericPalletError;
         /**
          * Origin doesn't have enough balance to pay the required storage deposits.
          **/
-        StorageDepositNotEnoughFunds: GenericPalletError<Rv>;
+        StorageDepositNotEnoughFunds: GenericPalletError;
         /**
          * More storage was created than allowed by the storage deposit limit.
          **/
-        StorageDepositLimitExhausted: GenericPalletError<Rv>;
+        StorageDepositLimitExhausted: GenericPalletError;
         /**
          * Code removal was denied because the code is still in use by at least one contract.
          **/
-        CodeInUse: GenericPalletError<Rv>;
+        CodeInUse: GenericPalletError;
         /**
          * The contract ran to completion but decided to revert its storage changes.
          * Please note that this error is only returned from extrinsics. When called directly
          * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
          * to determine whether a reversion has taken place.
          **/
-        ContractReverted: GenericPalletError<Rv>;
+        ContractReverted: GenericPalletError;
         /**
          * The contract's code was found to be invalid during validation.
          *
@@ -993,43 +993,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          * A more detailed error can be found on the node console if debug messages are enabled
          * by supplying `-lruntime::contracts=debug`.
          **/
-        CodeRejected: GenericPalletError<Rv>;
+        CodeRejected: GenericPalletError;
         /**
          * An indeterministic code was used in a context where this is not permitted.
          **/
-        Indeterministic: GenericPalletError<Rv>;
+        Indeterministic: GenericPalletError;
         /**
          * A pending migration needs to complete before the extrinsic can be called.
          **/
-        MigrationInProgress: GenericPalletError<Rv>;
+        MigrationInProgress: GenericPalletError;
         /**
          * Migrate dispatch call was attempted but no migration was performed.
          **/
-        NoMigrationPerformed: GenericPalletError<Rv>;
+        NoMigrationPerformed: GenericPalletError;
         /**
          * The contract has reached its maximum number of delegate dependencies.
          **/
-        MaxDelegateDependenciesReached: GenericPalletError<Rv>;
+        MaxDelegateDependenciesReached: GenericPalletError;
         /**
          * The dependency was not found in the contract's delegate dependencies.
          **/
-        DelegateDependencyNotFound: GenericPalletError<Rv>;
+        DelegateDependencyNotFound: GenericPalletError;
         /**
          * The contract already depends on the given delegate dependency.
          **/
-        DelegateDependencyAlreadyExists: GenericPalletError<Rv>;
+        DelegateDependencyAlreadyExists: GenericPalletError;
         /**
          * Can not add a delegate dependency to the code hash of the contract itself.
          **/
-        CannotAddSelfAsDelegateDependency: GenericPalletError<Rv>;
+        CannotAddSelfAsDelegateDependency: GenericPalletError;
         /**
          * Can not add more data to transient storage.
          **/
-        OutOfTransientStorage: GenericPalletError<Rv>;
+        OutOfTransientStorage: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Sudo`'s errors
@@ -1038,11 +1038,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Sender must be the Sudo account.
          **/
-        RequireSudo: GenericPalletError<Rv>;
+        RequireSudo: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `ImOnline`'s errors
@@ -1051,15 +1051,15 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Non existent public key.
          **/
-        InvalidKey: GenericPalletError<Rv>;
+        InvalidKey: GenericPalletError;
         /**
          * Duplicated heartbeat.
          **/
-        DuplicatedHeartbeat: GenericPalletError<Rv>;
+        DuplicatedHeartbeat: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Identity`'s errors
@@ -1068,128 +1068,128 @@ 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 `Society`'s errors
@@ -1198,135 +1198,135 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * User is not a member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * User is already a member.
          **/
-        AlreadyMember: GenericPalletError<Rv>;
+        AlreadyMember: GenericPalletError;
         /**
          * User is suspended.
          **/
-        Suspended: GenericPalletError<Rv>;
+        Suspended: GenericPalletError;
         /**
          * User is not suspended.
          **/
-        NotSuspended: GenericPalletError<Rv>;
+        NotSuspended: GenericPalletError;
         /**
          * Nothing to payout.
          **/
-        NoPayout: GenericPalletError<Rv>;
+        NoPayout: GenericPalletError;
         /**
          * Society already founded.
          **/
-        AlreadyFounded: GenericPalletError<Rv>;
+        AlreadyFounded: GenericPalletError;
         /**
          * Not enough in pot to accept candidate.
          **/
-        InsufficientPot: GenericPalletError<Rv>;
+        InsufficientPot: GenericPalletError;
         /**
          * Member is already vouching or banned from vouching again.
          **/
-        AlreadyVouching: GenericPalletError<Rv>;
+        AlreadyVouching: GenericPalletError;
         /**
          * Member is not vouching.
          **/
-        NotVouchingOnBidder: GenericPalletError<Rv>;
+        NotVouchingOnBidder: GenericPalletError;
         /**
          * Cannot remove the head of the chain.
          **/
-        Head: GenericPalletError<Rv>;
+        Head: GenericPalletError;
         /**
          * Cannot remove the founder.
          **/
-        Founder: GenericPalletError<Rv>;
+        Founder: GenericPalletError;
         /**
          * User has already made a bid.
          **/
-        AlreadyBid: GenericPalletError<Rv>;
+        AlreadyBid: GenericPalletError;
         /**
          * User is already a candidate.
          **/
-        AlreadyCandidate: GenericPalletError<Rv>;
+        AlreadyCandidate: GenericPalletError;
         /**
          * User is not a candidate.
          **/
-        NotCandidate: GenericPalletError<Rv>;
+        NotCandidate: GenericPalletError;
         /**
          * Too many members in the society.
          **/
-        MaxMembers: GenericPalletError<Rv>;
+        MaxMembers: GenericPalletError;
         /**
          * The caller is not the founder.
          **/
-        NotFounder: GenericPalletError<Rv>;
+        NotFounder: GenericPalletError;
         /**
          * The caller is not the head.
          **/
-        NotHead: GenericPalletError<Rv>;
+        NotHead: GenericPalletError;
         /**
          * The membership cannot be claimed as the candidate was not clearly approved.
          **/
-        NotApproved: GenericPalletError<Rv>;
+        NotApproved: GenericPalletError;
         /**
          * The candidate cannot be kicked as the candidate was not clearly rejected.
          **/
-        NotRejected: GenericPalletError<Rv>;
+        NotRejected: GenericPalletError;
         /**
          * The candidacy cannot be dropped as the candidate was clearly approved.
          **/
-        Approved: GenericPalletError<Rv>;
+        Approved: GenericPalletError;
         /**
          * The candidacy cannot be bestowed as the candidate was clearly rejected.
          **/
-        Rejected: GenericPalletError<Rv>;
+        Rejected: GenericPalletError;
         /**
          * The candidacy cannot be concluded as the voting is still in progress.
          **/
-        InProgress: GenericPalletError<Rv>;
+        InProgress: GenericPalletError;
         /**
          * The candidacy cannot be pruned until a full additional intake period has passed.
          **/
-        TooEarly: GenericPalletError<Rv>;
+        TooEarly: GenericPalletError;
         /**
          * The skeptic already voted.
          **/
-        Voted: GenericPalletError<Rv>;
+        Voted: GenericPalletError;
         /**
          * The skeptic need not vote on candidates from expired rounds.
          **/
-        Expired: GenericPalletError<Rv>;
+        Expired: GenericPalletError;
         /**
          * User is not a bidder.
          **/
-        NotBidder: GenericPalletError<Rv>;
+        NotBidder: GenericPalletError;
         /**
          * There is no defender currently.
          **/
-        NoDefender: GenericPalletError<Rv>;
+        NoDefender: GenericPalletError;
         /**
          * Group doesn't exist.
          **/
-        NotGroup: GenericPalletError<Rv>;
+        NotGroup: GenericPalletError;
         /**
          * The member is already elevated to this rank.
          **/
-        AlreadyElevated: GenericPalletError<Rv>;
+        AlreadyElevated: GenericPalletError;
         /**
          * The skeptic has already been punished for this offence.
          **/
-        AlreadyPunished: GenericPalletError<Rv>;
+        AlreadyPunished: GenericPalletError;
         /**
          * Funds are insufficient to pay off society debts.
          **/
-        InsufficientFunds: GenericPalletError<Rv>;
+        InsufficientFunds: GenericPalletError;
         /**
          * The candidate/defender has no stale votes to remove.
          **/
-        NoVotes: GenericPalletError<Rv>;
+        NoVotes: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Recovery`'s errors
@@ -1335,71 +1335,71 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * User is not allowed to make a call on behalf of this account
          **/
-        NotAllowed: GenericPalletError<Rv>;
+        NotAllowed: GenericPalletError;
         /**
          * Threshold must be greater than zero
          **/
-        ZeroThreshold: GenericPalletError<Rv>;
+        ZeroThreshold: GenericPalletError;
         /**
          * Friends list must be greater than zero and threshold
          **/
-        NotEnoughFriends: GenericPalletError<Rv>;
+        NotEnoughFriends: GenericPalletError;
         /**
          * Friends list must be less than max friends
          **/
-        MaxFriends: GenericPalletError<Rv>;
+        MaxFriends: GenericPalletError;
         /**
          * Friends list must be sorted and free of duplicates
          **/
-        NotSorted: GenericPalletError<Rv>;
+        NotSorted: GenericPalletError;
         /**
          * This account is not set up for recovery
          **/
-        NotRecoverable: GenericPalletError<Rv>;
+        NotRecoverable: GenericPalletError;
         /**
          * This account is already set up for recovery
          **/
-        AlreadyRecoverable: GenericPalletError<Rv>;
+        AlreadyRecoverable: GenericPalletError;
         /**
          * A recovery process has already started for this account
          **/
-        AlreadyStarted: GenericPalletError<Rv>;
+        AlreadyStarted: GenericPalletError;
         /**
          * A recovery process has not started for this rescuer
          **/
-        NotStarted: GenericPalletError<Rv>;
+        NotStarted: GenericPalletError;
         /**
          * This account is not a friend who can vouch
          **/
-        NotFriend: GenericPalletError<Rv>;
+        NotFriend: GenericPalletError;
         /**
          * The friend must wait until the delay period to vouch for this recovery
          **/
-        DelayPeriod: GenericPalletError<Rv>;
+        DelayPeriod: GenericPalletError;
         /**
          * This user has already vouched for this recovery
          **/
-        AlreadyVouched: GenericPalletError<Rv>;
+        AlreadyVouched: GenericPalletError;
         /**
          * The threshold for recovering this account has not been met
          **/
-        Threshold: GenericPalletError<Rv>;
+        Threshold: GenericPalletError;
         /**
          * There are still active recovery attempts that need to be closed
          **/
-        StillActive: GenericPalletError<Rv>;
+        StillActive: GenericPalletError;
         /**
          * This account is already set up for recovery
          **/
-        AlreadyProxy: GenericPalletError<Rv>;
+        AlreadyProxy: GenericPalletError;
         /**
          * Some internal state is broken.
          **/
-        BadState: GenericPalletError<Rv>;
+        BadState: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Vesting`'s errors
@@ -1408,28 +1408,28 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The account given is not vesting.
          **/
-        NotVesting: GenericPalletError<Rv>;
+        NotVesting: GenericPalletError;
         /**
          * The account already has `MaxVestingSchedules` count of schedules and thus
          * cannot add another one. Consider merging existing schedules in order to add another.
          **/
-        AtMaxVestingSchedules: GenericPalletError<Rv>;
+        AtMaxVestingSchedules: GenericPalletError;
         /**
          * Amount being transferred is too low to create a vesting schedule.
          **/
-        AmountLow: GenericPalletError<Rv>;
+        AmountLow: GenericPalletError;
         /**
          * An index was out of bounds of the vesting schedules.
          **/
-        ScheduleIndexOutOfBounds: GenericPalletError<Rv>;
+        ScheduleIndexOutOfBounds: GenericPalletError;
         /**
          * Failed to create a new schedule because some parameter was invalid.
          **/
-        InvalidScheduleParams: GenericPalletError<Rv>;
+        InvalidScheduleParams: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Scheduler`'s errors
@@ -1438,27 +1438,27 @@ 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 `Glutton`'s errors
@@ -1469,15 +1469,15 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          *
          * Set `witness_count` to `Some` to bypass this error.
          **/
-        AlreadyInitialized: GenericPalletError<Rv>;
+        AlreadyInitialized: GenericPalletError;
         /**
          * The limit was over [`crate::RESOURCE_HARD_LIMIT`].
          **/
-        InsaneLimit: GenericPalletError<Rv>;
+        InsaneLimit: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Preimage`'s errors
@@ -1486,39 +1486,39 @@ 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 `Proxy`'s errors
@@ -1527,39 +1527,39 @@ 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 `Multisig`'s errors
@@ -1568,64 +1568,64 @@ 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 `Bounties`'s errors
@@ -1634,52 +1634,52 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Proposer's balance is too low.
          **/
-        InsufficientProposersBalance: GenericPalletError<Rv>;
+        InsufficientProposersBalance: GenericPalletError;
         /**
          * No proposal or bounty at that index.
          **/
-        InvalidIndex: GenericPalletError<Rv>;
+        InvalidIndex: GenericPalletError;
         /**
          * The reason given is just too big.
          **/
-        ReasonTooBig: GenericPalletError<Rv>;
+        ReasonTooBig: GenericPalletError;
         /**
          * The bounty status is unexpected.
          **/
-        UnexpectedStatus: GenericPalletError<Rv>;
+        UnexpectedStatus: GenericPalletError;
         /**
          * Require bounty curator.
          **/
-        RequireCurator: GenericPalletError<Rv>;
+        RequireCurator: GenericPalletError;
         /**
          * Invalid bounty value.
          **/
-        InvalidValue: GenericPalletError<Rv>;
+        InvalidValue: GenericPalletError;
         /**
          * Invalid bounty fee.
          **/
-        InvalidFee: GenericPalletError<Rv>;
+        InvalidFee: GenericPalletError;
         /**
          * A bounty payout is pending.
          * To cancel the bounty, you must unassign and slash the curator.
          **/
-        PendingPayout: GenericPalletError<Rv>;
+        PendingPayout: GenericPalletError;
         /**
          * The bounties cannot be claimed/closed because it's still in the countdown period.
          **/
-        Premature: GenericPalletError<Rv>;
+        Premature: GenericPalletError;
         /**
          * The bounty cannot be closed because it has active child bounties.
          **/
-        HasActiveChildBounty: GenericPalletError<Rv>;
+        HasActiveChildBounty: GenericPalletError;
         /**
          * Too many approvals are already queued.
          **/
-        TooManyQueued: GenericPalletError<Rv>;
+        TooManyQueued: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Tips`'s errors
@@ -1688,35 +1688,35 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The reason given is just too big.
          **/
-        ReasonTooBig: GenericPalletError<Rv>;
+        ReasonTooBig: GenericPalletError;
         /**
          * The tip was already found/started.
          **/
-        AlreadyKnown: GenericPalletError<Rv>;
+        AlreadyKnown: GenericPalletError;
         /**
          * The tip hash is unknown.
          **/
-        UnknownTip: GenericPalletError<Rv>;
+        UnknownTip: GenericPalletError;
         /**
          * The tip given was too generous.
          **/
-        MaxTipAmountExceeded: GenericPalletError<Rv>;
+        MaxTipAmountExceeded: GenericPalletError;
         /**
          * The account attempting to retract the tip is not the finder of the tip.
          **/
-        NotFinder: GenericPalletError<Rv>;
+        NotFinder: GenericPalletError;
         /**
          * The tip cannot be claimed/closed because there are not enough tippers yet.
          **/
-        StillOpen: GenericPalletError<Rv>;
+        StillOpen: GenericPalletError;
         /**
          * The tip cannot be claimed/closed because it's still in the countdown period.
          **/
-        Premature: GenericPalletError<Rv>;
+        Premature: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Assets`'s errors
@@ -1725,102 +1725,102 @@ 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 `PoolAssets`'s errors
@@ -1829,102 +1829,102 @@ 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 `Beefy`'s errors
@@ -1933,35 +1933,35 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * A key ownership proof provided as part of an equivocation report is invalid.
          **/
-        InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+        InvalidKeyOwnershipProof: GenericPalletError;
         /**
          * A double voting proof provided as part of an equivocation report is invalid.
          **/
-        InvalidDoubleVotingProof: GenericPalletError<Rv>;
+        InvalidDoubleVotingProof: GenericPalletError;
         /**
          * A fork voting proof provided as part of an equivocation report is invalid.
          **/
-        InvalidForkVotingProof: GenericPalletError<Rv>;
+        InvalidForkVotingProof: GenericPalletError;
         /**
          * A future block voting proof provided as part of an equivocation report is invalid.
          **/
-        InvalidFutureBlockVotingProof: GenericPalletError<Rv>;
+        InvalidFutureBlockVotingProof: GenericPalletError;
         /**
          * The session of the equivocation proof is invalid
          **/
-        InvalidEquivocationProofSession: GenericPalletError<Rv>;
+        InvalidEquivocationProofSession: GenericPalletError;
         /**
          * A given equivocation report is valid but already previously reported.
          **/
-        DuplicateOffenceReport: GenericPalletError<Rv>;
+        DuplicateOffenceReport: GenericPalletError;
         /**
          * Submitted configuration is invalid.
          **/
-        InvalidConfiguration: GenericPalletError<Rv>;
+        InvalidConfiguration: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Lottery`'s errors
@@ -1970,35 +1970,35 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * A lottery has not been configured.
          **/
-        NotConfigured: GenericPalletError<Rv>;
+        NotConfigured: GenericPalletError;
         /**
          * A lottery is already in progress.
          **/
-        InProgress: GenericPalletError<Rv>;
+        InProgress: GenericPalletError;
         /**
          * A lottery has already ended.
          **/
-        AlreadyEnded: GenericPalletError<Rv>;
+        AlreadyEnded: GenericPalletError;
         /**
          * The call is not valid for an open lottery.
          **/
-        InvalidCall: GenericPalletError<Rv>;
+        InvalidCall: GenericPalletError;
         /**
          * You are already participating in the lottery with this call.
          **/
-        AlreadyParticipating: GenericPalletError<Rv>;
+        AlreadyParticipating: GenericPalletError;
         /**
          * Too many calls for a single lottery.
          **/
-        TooManyCalls: GenericPalletError<Rv>;
+        TooManyCalls: GenericPalletError;
         /**
          * Failed to encode calls
          **/
-        EncodingFailed: GenericPalletError<Rv>;
+        EncodingFailed: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Nis`'s errors
@@ -2007,68 +2007,68 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The duration of the bid is less than one.
          **/
-        DurationTooSmall: GenericPalletError<Rv>;
+        DurationTooSmall: GenericPalletError;
         /**
          * The duration is the bid is greater than the number of queues.
          **/
-        DurationTooBig: GenericPalletError<Rv>;
+        DurationTooBig: GenericPalletError;
         /**
          * The amount of the bid is less than the minimum allowed.
          **/
-        AmountTooSmall: GenericPalletError<Rv>;
+        AmountTooSmall: GenericPalletError;
         /**
          * The queue for the bid's duration is full and the amount bid is too low to get in
          * through replacing an existing bid.
          **/
-        BidTooLow: GenericPalletError<Rv>;
+        BidTooLow: GenericPalletError;
         /**
          * Receipt index is unknown.
          **/
-        UnknownReceipt: GenericPalletError<Rv>;
+        UnknownReceipt: GenericPalletError;
         /**
          * Not the owner of the receipt.
          **/
-        NotOwner: GenericPalletError<Rv>;
+        NotOwner: GenericPalletError;
         /**
          * Bond not yet at expiry date.
          **/
-        NotExpired: GenericPalletError<Rv>;
+        NotExpired: GenericPalletError;
         /**
          * The given bid for retraction is not found.
          **/
-        UnknownBid: GenericPalletError<Rv>;
+        UnknownBid: GenericPalletError;
         /**
          * The portion supplied is beyond the value of the receipt.
          **/
-        PortionTooBig: GenericPalletError<Rv>;
+        PortionTooBig: GenericPalletError;
         /**
          * Not enough funds are held to pay out.
          **/
-        Unfunded: GenericPalletError<Rv>;
+        Unfunded: GenericPalletError;
         /**
          * There are enough funds for what is required.
          **/
-        AlreadyFunded: GenericPalletError<Rv>;
+        AlreadyFunded: GenericPalletError;
         /**
          * The thaw throttle has been reached for this period.
          **/
-        Throttled: GenericPalletError<Rv>;
+        Throttled: GenericPalletError;
         /**
          * The operation would result in a receipt worth an insignificant value.
          **/
-        MakesDust: GenericPalletError<Rv>;
+        MakesDust: GenericPalletError;
         /**
          * The receipt is already communal.
          **/
-        AlreadyCommunal: GenericPalletError<Rv>;
+        AlreadyCommunal: GenericPalletError;
         /**
          * The receipt is already private.
          **/
-        AlreadyPrivate: GenericPalletError<Rv>;
+        AlreadyPrivate: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Uniques`'s errors
@@ -2077,79 +2077,79 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The signing account has no permission to do the operation.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * The given item ID is unknown.
          **/
-        UnknownCollection: GenericPalletError<Rv>;
+        UnknownCollection: GenericPalletError;
         /**
          * The item ID has already been used for an item.
          **/
-        AlreadyExists: GenericPalletError<Rv>;
+        AlreadyExists: GenericPalletError;
         /**
          * The owner turned out to be different to what was expected.
          **/
-        WrongOwner: GenericPalletError<Rv>;
+        WrongOwner: GenericPalletError;
         /**
          * Invalid witness data given.
          **/
-        BadWitness: GenericPalletError<Rv>;
+        BadWitness: GenericPalletError;
         /**
          * The item ID is already taken.
          **/
-        InUse: GenericPalletError<Rv>;
+        InUse: GenericPalletError;
         /**
          * The item or collection is frozen.
          **/
-        Frozen: GenericPalletError<Rv>;
+        Frozen: GenericPalletError;
         /**
          * The delegate turned out to be different to what was expected.
          **/
-        WrongDelegate: GenericPalletError<Rv>;
+        WrongDelegate: GenericPalletError;
         /**
          * There is no delegate approved.
          **/
-        NoDelegate: GenericPalletError<Rv>;
+        NoDelegate: GenericPalletError;
         /**
          * No approval exists that would allow the transfer.
          **/
-        Unapproved: GenericPalletError<Rv>;
+        Unapproved: GenericPalletError;
         /**
          * The named owner has not signed ownership of the collection is acceptable.
          **/
-        Unaccepted: GenericPalletError<Rv>;
+        Unaccepted: GenericPalletError;
         /**
          * The item is locked.
          **/
-        Locked: GenericPalletError<Rv>;
+        Locked: GenericPalletError;
         /**
          * All items have been minted.
          **/
-        MaxSupplyReached: GenericPalletError<Rv>;
+        MaxSupplyReached: GenericPalletError;
         /**
          * The max supply has already been set.
          **/
-        MaxSupplyAlreadySet: GenericPalletError<Rv>;
+        MaxSupplyAlreadySet: GenericPalletError;
         /**
          * The provided max supply is less to the amount of items a collection already has.
          **/
-        MaxSupplyTooSmall: GenericPalletError<Rv>;
+        MaxSupplyTooSmall: GenericPalletError;
         /**
          * The given item ID is unknown.
          **/
-        UnknownItem: GenericPalletError<Rv>;
+        UnknownItem: GenericPalletError;
         /**
          * Item is not for sale.
          **/
-        NotForSale: GenericPalletError<Rv>;
+        NotForSale: GenericPalletError;
         /**
          * The provided bid is too low.
          **/
-        BidTooLow: GenericPalletError<Rv>;
+        BidTooLow: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Nfts`'s errors
@@ -2158,187 +2158,187 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The signing account has no permission to do the operation.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * The given item ID is unknown.
          **/
-        UnknownCollection: GenericPalletError<Rv>;
+        UnknownCollection: GenericPalletError;
         /**
          * The item ID has already been used for an item.
          **/
-        AlreadyExists: GenericPalletError<Rv>;
+        AlreadyExists: GenericPalletError;
         /**
          * The approval had a deadline that expired, so the approval isn't valid anymore.
          **/
-        ApprovalExpired: GenericPalletError<Rv>;
+        ApprovalExpired: GenericPalletError;
         /**
          * The owner turned out to be different to what was expected.
          **/
-        WrongOwner: GenericPalletError<Rv>;
+        WrongOwner: GenericPalletError;
         /**
          * The witness data given does not match the current state of the chain.
          **/
-        BadWitness: GenericPalletError<Rv>;
+        BadWitness: GenericPalletError;
         /**
          * Collection ID is already taken.
          **/
-        CollectionIdInUse: GenericPalletError<Rv>;
+        CollectionIdInUse: GenericPalletError;
         /**
          * Items within that collection are non-transferable.
          **/
-        ItemsNonTransferable: GenericPalletError<Rv>;
+        ItemsNonTransferable: GenericPalletError;
         /**
          * The provided account is not a delegate.
          **/
-        NotDelegate: GenericPalletError<Rv>;
+        NotDelegate: GenericPalletError;
         /**
          * The delegate turned out to be different to what was expected.
          **/
-        WrongDelegate: GenericPalletError<Rv>;
+        WrongDelegate: GenericPalletError;
         /**
          * No approval exists that would allow the transfer.
          **/
-        Unapproved: GenericPalletError<Rv>;
+        Unapproved: GenericPalletError;
         /**
          * The named owner has not signed ownership acceptance of the collection.
          **/
-        Unaccepted: GenericPalletError<Rv>;
+        Unaccepted: GenericPalletError;
         /**
          * The item is locked (non-transferable).
          **/
-        ItemLocked: GenericPalletError<Rv>;
+        ItemLocked: GenericPalletError;
         /**
          * Item's attributes are locked.
          **/
-        LockedItemAttributes: GenericPalletError<Rv>;
+        LockedItemAttributes: GenericPalletError;
         /**
          * Collection's attributes are locked.
          **/
-        LockedCollectionAttributes: GenericPalletError<Rv>;
+        LockedCollectionAttributes: GenericPalletError;
         /**
          * Item's metadata is locked.
          **/
-        LockedItemMetadata: GenericPalletError<Rv>;
+        LockedItemMetadata: GenericPalletError;
         /**
          * Collection's metadata is locked.
          **/
-        LockedCollectionMetadata: GenericPalletError<Rv>;
+        LockedCollectionMetadata: GenericPalletError;
         /**
          * All items have been minted.
          **/
-        MaxSupplyReached: GenericPalletError<Rv>;
+        MaxSupplyReached: GenericPalletError;
         /**
          * The max supply is locked and can't be changed.
          **/
-        MaxSupplyLocked: GenericPalletError<Rv>;
+        MaxSupplyLocked: GenericPalletError;
         /**
          * The provided max supply is less than the number of items a collection already has.
          **/
-        MaxSupplyTooSmall: GenericPalletError<Rv>;
+        MaxSupplyTooSmall: GenericPalletError;
         /**
          * The given item ID is unknown.
          **/
-        UnknownItem: GenericPalletError<Rv>;
+        UnknownItem: GenericPalletError;
         /**
          * Swap doesn't exist.
          **/
-        UnknownSwap: GenericPalletError<Rv>;
+        UnknownSwap: GenericPalletError;
         /**
          * The given item has no metadata set.
          **/
-        MetadataNotFound: GenericPalletError<Rv>;
+        MetadataNotFound: GenericPalletError;
         /**
          * The provided attribute can't be found.
          **/
-        AttributeNotFound: GenericPalletError<Rv>;
+        AttributeNotFound: GenericPalletError;
         /**
          * Item is not for sale.
          **/
-        NotForSale: GenericPalletError<Rv>;
+        NotForSale: GenericPalletError;
         /**
          * The provided bid is too low.
          **/
-        BidTooLow: GenericPalletError<Rv>;
+        BidTooLow: GenericPalletError;
         /**
          * The item has reached its approval limit.
          **/
-        ReachedApprovalLimit: GenericPalletError<Rv>;
+        ReachedApprovalLimit: GenericPalletError;
         /**
          * The deadline has already expired.
          **/
-        DeadlineExpired: GenericPalletError<Rv>;
+        DeadlineExpired: GenericPalletError;
         /**
          * The duration provided should be less than or equal to `MaxDeadlineDuration`.
          **/
-        WrongDuration: GenericPalletError<Rv>;
+        WrongDuration: GenericPalletError;
         /**
          * The method is disabled by system settings.
          **/
-        MethodDisabled: GenericPalletError<Rv>;
+        MethodDisabled: GenericPalletError;
         /**
          * The provided setting can't be set.
          **/
-        WrongSetting: GenericPalletError<Rv>;
+        WrongSetting: GenericPalletError;
         /**
          * Item's config already exists and should be equal to the provided one.
          **/
-        InconsistentItemConfig: GenericPalletError<Rv>;
+        InconsistentItemConfig: GenericPalletError;
         /**
          * Config for a collection or an item can't be found.
          **/
-        NoConfig: GenericPalletError<Rv>;
+        NoConfig: GenericPalletError;
         /**
          * Some roles were not cleared.
          **/
-        RolesNotCleared: GenericPalletError<Rv>;
+        RolesNotCleared: GenericPalletError;
         /**
          * Mint has not started yet.
          **/
-        MintNotStarted: GenericPalletError<Rv>;
+        MintNotStarted: GenericPalletError;
         /**
          * Mint has already ended.
          **/
-        MintEnded: GenericPalletError<Rv>;
+        MintEnded: GenericPalletError;
         /**
          * The provided Item was already used for claiming.
          **/
-        AlreadyClaimed: GenericPalletError<Rv>;
+        AlreadyClaimed: GenericPalletError;
         /**
          * The provided data is incorrect.
          **/
-        IncorrectData: GenericPalletError<Rv>;
+        IncorrectData: GenericPalletError;
         /**
          * The extrinsic was sent by the wrong origin.
          **/
-        WrongOrigin: GenericPalletError<Rv>;
+        WrongOrigin: GenericPalletError;
         /**
          * The provided signature is incorrect.
          **/
-        WrongSignature: GenericPalletError<Rv>;
+        WrongSignature: GenericPalletError;
         /**
          * The provided metadata might be too long.
          **/
-        IncorrectMetadata: GenericPalletError<Rv>;
+        IncorrectMetadata: GenericPalletError;
         /**
          * Can't set more attributes per one call.
          **/
-        MaxAttributesLimitReached: GenericPalletError<Rv>;
+        MaxAttributesLimitReached: GenericPalletError;
         /**
          * The provided namespace isn't supported in this call.
          **/
-        WrongNamespace: GenericPalletError<Rv>;
+        WrongNamespace: GenericPalletError;
         /**
          * Can't delete non-empty collections.
          **/
-        CollectionNotEmpty: GenericPalletError<Rv>;
+        CollectionNotEmpty: GenericPalletError;
         /**
          * The witness data should be provided.
          **/
-        WitnessRequired: GenericPalletError<Rv>;
+        WitnessRequired: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `NftFractionalization`'s errors
@@ -2347,23 +2347,23 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Asset ID does not correspond to locked NFT.
          **/
-        IncorrectAssetId: GenericPalletError<Rv>;
+        IncorrectAssetId: GenericPalletError;
         /**
          * The signing account has no permission to do the operation.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * NFT doesn't exist.
          **/
-        NftNotFound: GenericPalletError<Rv>;
+        NftNotFound: GenericPalletError;
         /**
          * NFT has not yet been fractionalised.
          **/
-        NftNotFractionalized: GenericPalletError<Rv>;
+        NftNotFractionalized: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Salary`'s errors
@@ -2372,60 +2372,60 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The salary system has already been started.
          **/
-        AlreadyStarted: GenericPalletError<Rv>;
+        AlreadyStarted: GenericPalletError;
         /**
          * The account is not a ranked member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * The account is already inducted.
          **/
-        AlreadyInducted: GenericPalletError<Rv>;
-        NotInducted: GenericPalletError<Rv>;
+        AlreadyInducted: GenericPalletError;
+        NotInducted: GenericPalletError;
         /**
          * The member does not have a current valid claim.
          **/
-        NoClaim: GenericPalletError<Rv>;
+        NoClaim: GenericPalletError;
         /**
          * The member's claim is zero.
          **/
-        ClaimZero: GenericPalletError<Rv>;
+        ClaimZero: GenericPalletError;
         /**
          * Current cycle's registration period is over.
          **/
-        TooLate: GenericPalletError<Rv>;
+        TooLate: GenericPalletError;
         /**
          * Current cycle's payment period is not yet begun.
          **/
-        TooEarly: GenericPalletError<Rv>;
+        TooEarly: GenericPalletError;
         /**
          * Cycle is not yet over.
          **/
-        NotYet: GenericPalletError<Rv>;
+        NotYet: GenericPalletError;
         /**
          * The payout cycles have not yet started.
          **/
-        NotStarted: GenericPalletError<Rv>;
+        NotStarted: GenericPalletError;
         /**
          * There is no budget left for the payout.
          **/
-        Bankrupt: GenericPalletError<Rv>;
+        Bankrupt: GenericPalletError;
         /**
          * There was some issue with the mechanism of payment.
          **/
-        PayError: GenericPalletError<Rv>;
+        PayError: GenericPalletError;
         /**
          * The payment has neither failed nor succeeded yet.
          **/
-        Inconclusive: GenericPalletError<Rv>;
+        Inconclusive: GenericPalletError;
         /**
          * The cycle is after that in which the payment was made.
          **/
-        NotCurrent: GenericPalletError<Rv>;
+        NotCurrent: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `CoreFellowship`'s errors
@@ -2434,45 +2434,45 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Member's rank is too low.
          **/
-        Unranked: GenericPalletError<Rv>;
+        Unranked: GenericPalletError;
         /**
          * Member's rank is not zero.
          **/
-        Ranked: GenericPalletError<Rv>;
+        Ranked: GenericPalletError;
         /**
          * Member's rank is not as expected - generally means that the rank provided to the call
          * does not agree with the state of the system.
          **/
-        UnexpectedRank: GenericPalletError<Rv>;
+        UnexpectedRank: GenericPalletError;
         /**
          * The given rank is invalid - this generally means it's not between 1 and `RANK_COUNT`.
          **/
-        InvalidRank: GenericPalletError<Rv>;
+        InvalidRank: GenericPalletError;
         /**
          * The origin does not have enough permission to do this operation.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * No work needs to be done at present for this member.
          **/
-        NothingDoing: GenericPalletError<Rv>;
+        NothingDoing: GenericPalletError;
         /**
          * The candidate has already been inducted. This should never happen since it would
          * require a candidate (rank 0) to already be tracked in the pallet.
          **/
-        AlreadyInducted: GenericPalletError<Rv>;
+        AlreadyInducted: GenericPalletError;
         /**
          * The candidate has not been inducted, so cannot be offboarded from this pallet.
          **/
-        NotTracked: GenericPalletError<Rv>;
+        NotTracked: GenericPalletError;
         /**
          * Operation cannot be done yet since not enough time has passed.
          **/
-        TooSoon: GenericPalletError<Rv>;
+        TooSoon: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `TransactionStorage`'s errors
@@ -2481,55 +2481,55 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Invalid configuration.
          **/
-        NotConfigured: GenericPalletError<Rv>;
+        NotConfigured: GenericPalletError;
         /**
          * Renewed extrinsic is not found.
          **/
-        RenewedNotFound: GenericPalletError<Rv>;
+        RenewedNotFound: GenericPalletError;
         /**
          * Attempting to store empty transaction
          **/
-        EmptyTransaction: GenericPalletError<Rv>;
+        EmptyTransaction: GenericPalletError;
         /**
          * Proof was not expected in this block.
          **/
-        UnexpectedProof: GenericPalletError<Rv>;
+        UnexpectedProof: GenericPalletError;
         /**
          * Proof failed verification.
          **/
-        InvalidProof: GenericPalletError<Rv>;
+        InvalidProof: GenericPalletError;
         /**
          * Missing storage proof.
          **/
-        MissingProof: GenericPalletError<Rv>;
+        MissingProof: GenericPalletError;
         /**
          * Unable to verify proof because state data is missing.
          **/
-        MissingStateData: GenericPalletError<Rv>;
+        MissingStateData: GenericPalletError;
         /**
          * Double proof check in the block.
          **/
-        DoubleCheck: GenericPalletError<Rv>;
+        DoubleCheck: GenericPalletError;
         /**
          * Storage proof was not checked in the block.
          **/
-        ProofNotChecked: GenericPalletError<Rv>;
+        ProofNotChecked: GenericPalletError;
         /**
          * Transaction is too large.
          **/
-        TransactionTooLarge: GenericPalletError<Rv>;
+        TransactionTooLarge: GenericPalletError;
         /**
          * Too many transactions in the block.
          **/
-        TooManyTransactions: GenericPalletError<Rv>;
+        TooManyTransactions: GenericPalletError;
         /**
          * Attempted to call `store` outside of block execution.
          **/
-        BadContext: GenericPalletError<Rv>;
+        BadContext: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `VoterList`'s errors
@@ -2538,11 +2538,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * A error in the list interface implementation.
          **/
-        List: GenericPalletError<Rv>;
+        List: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `StateTrieMigration`'s errors
@@ -2551,7 +2551,7 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Max signed limits not respected.
          **/
-        MaxSignedLimits: GenericPalletError<Rv>;
+        MaxSignedLimits: GenericPalletError;
         /**
          * A key was longer than the configured maximum.
          *
@@ -2561,27 +2561,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          * The value should only be increased to avoid a storage migration for the currently
          * stored [`crate::Progress::LastKey`].
          **/
-        KeyTooLong: GenericPalletError<Rv>;
+        KeyTooLong: GenericPalletError;
         /**
          * submitter does not have enough funds.
          **/
-        NotEnoughFunds: GenericPalletError<Rv>;
+        NotEnoughFunds: GenericPalletError;
         /**
          * Bad witness data provided.
          **/
-        BadWitness: GenericPalletError<Rv>;
+        BadWitness: GenericPalletError;
         /**
          * Signed migration is not allowed because the maximum limit is not set yet.
          **/
-        SignedMigrationNotAllowed: GenericPalletError<Rv>;
+        SignedMigrationNotAllowed: GenericPalletError;
         /**
          * Bad child root provided.
          **/
-        BadChildRoot: GenericPalletError<Rv>;
+        BadChildRoot: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `ChildBounties`'s errors
@@ -2590,19 +2590,19 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The parent bounty is not in active state.
          **/
-        ParentBountyNotActive: GenericPalletError<Rv>;
+        ParentBountyNotActive: GenericPalletError;
         /**
          * The bounty balance is not enough to add new child-bounty.
          **/
-        InsufficientBountyBalance: GenericPalletError<Rv>;
+        InsufficientBountyBalance: GenericPalletError;
         /**
          * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
          **/
-        TooManyChildBounties: GenericPalletError<Rv>;
+        TooManyChildBounties: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Referenda`'s errors
@@ -2611,63 +2611,63 @@ 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 `Remark`'s errors
@@ -2676,15 +2676,15 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Attempting to store empty data.
          **/
-        Empty: GenericPalletError<Rv>;
+        Empty: GenericPalletError;
         /**
          * Attempted to call `store` outside of block execution.
          **/
-        BadContext: GenericPalletError<Rv>;
+        BadContext: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `ConvictionVoting`'s errors
@@ -2693,56 +2693,56 @@ 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 `Whitelist`'s errors
@@ -2751,27 +2751,27 @@ 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 `AllianceMotion`'s errors
@@ -2780,55 +2780,55 @@ 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 `Alliance`'s errors
@@ -2837,104 +2837,104 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The Alliance has not been initialized yet, therefore accounts cannot join it.
          **/
-        AllianceNotYetInitialized: GenericPalletError<Rv>;
+        AllianceNotYetInitialized: GenericPalletError;
         /**
          * The Alliance has been initialized, therefore cannot be initialized again.
          **/
-        AllianceAlreadyInitialized: GenericPalletError<Rv>;
+        AllianceAlreadyInitialized: GenericPalletError;
         /**
          * Account is already a member.
          **/
-        AlreadyMember: GenericPalletError<Rv>;
+        AlreadyMember: GenericPalletError;
         /**
          * Account is not a member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * Account is not an ally.
          **/
-        NotAlly: GenericPalletError<Rv>;
+        NotAlly: GenericPalletError;
         /**
          * Account does not have voting rights.
          **/
-        NoVotingRights: GenericPalletError<Rv>;
+        NoVotingRights: GenericPalletError;
         /**
          * Account is already an elevated (fellow) member.
          **/
-        AlreadyElevated: GenericPalletError<Rv>;
+        AlreadyElevated: GenericPalletError;
         /**
          * Item is already listed as unscrupulous.
          **/
-        AlreadyUnscrupulous: GenericPalletError<Rv>;
+        AlreadyUnscrupulous: GenericPalletError;
         /**
          * Account has been deemed unscrupulous by the Alliance and is not welcome to join or be
          * nominated.
          **/
-        AccountNonGrata: GenericPalletError<Rv>;
+        AccountNonGrata: GenericPalletError;
         /**
          * Item has not been deemed unscrupulous.
          **/
-        NotListedAsUnscrupulous: GenericPalletError<Rv>;
+        NotListedAsUnscrupulous: GenericPalletError;
         /**
          * The number of unscrupulous items exceeds `MaxUnscrupulousItems`.
          **/
-        TooManyUnscrupulousItems: GenericPalletError<Rv>;
+        TooManyUnscrupulousItems: GenericPalletError;
         /**
          * Length of website URL exceeds `MaxWebsiteUrlLength`.
          **/
-        TooLongWebsiteUrl: GenericPalletError<Rv>;
+        TooLongWebsiteUrl: GenericPalletError;
         /**
          * Balance is insufficient for the required deposit.
          **/
-        InsufficientFunds: GenericPalletError<Rv>;
+        InsufficientFunds: GenericPalletError;
         /**
          * The account's identity does not have display field and website field.
          **/
-        WithoutRequiredIdentityFields: GenericPalletError<Rv>;
+        WithoutRequiredIdentityFields: GenericPalletError;
         /**
          * The account's identity has no good judgement.
          **/
-        WithoutGoodIdentityJudgement: GenericPalletError<Rv>;
+        WithoutGoodIdentityJudgement: GenericPalletError;
         /**
          * The proposal hash is not found.
          **/
-        MissingProposalHash: GenericPalletError<Rv>;
+        MissingProposalHash: GenericPalletError;
         /**
          * The announcement is not found.
          **/
-        MissingAnnouncement: GenericPalletError<Rv>;
+        MissingAnnouncement: GenericPalletError;
         /**
          * Number of members exceeds `MaxMembersCount`.
          **/
-        TooManyMembers: GenericPalletError<Rv>;
+        TooManyMembers: GenericPalletError;
         /**
          * Number of announcements exceeds `MaxAnnouncementsCount`.
          **/
-        TooManyAnnouncements: GenericPalletError<Rv>;
+        TooManyAnnouncements: GenericPalletError;
         /**
          * Invalid witness data given.
          **/
-        BadWitness: GenericPalletError<Rv>;
+        BadWitness: GenericPalletError;
         /**
          * Account already gave retirement notice
          **/
-        AlreadyRetiring: GenericPalletError<Rv>;
+        AlreadyRetiring: GenericPalletError;
         /**
          * Account did not give a retirement notice required to retire.
          **/
-        RetirementNoticeNotGiven: GenericPalletError<Rv>;
+        RetirementNoticeNotGiven: GenericPalletError;
         /**
          * Retirement period has not passed.
          **/
-        RetirementPeriodNotPassed: GenericPalletError<Rv>;
+        RetirementPeriodNotPassed: GenericPalletError;
         /**
          * Fellows must be provided to initialize the Alliance.
          **/
-        FellowsMissing: GenericPalletError<Rv>;
+        FellowsMissing: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `NominationPools`'s errors
@@ -2943,37 +2943,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * A (bonded) pool id does not exist.
          **/
-        PoolNotFound: GenericPalletError<Rv>;
+        PoolNotFound: GenericPalletError;
         /**
          * An account is not a member.
          **/
-        PoolMemberNotFound: GenericPalletError<Rv>;
+        PoolMemberNotFound: GenericPalletError;
         /**
          * A reward pool does not exist. In all cases this is a system logic error.
          **/
-        RewardPoolNotFound: GenericPalletError<Rv>;
+        RewardPoolNotFound: GenericPalletError;
         /**
          * A sub pool does not exist.
          **/
-        SubPoolsNotFound: GenericPalletError<Rv>;
+        SubPoolsNotFound: GenericPalletError;
         /**
          * An account is already delegating in another pool. An account may only belong to one
          * pool at a time.
          **/
-        AccountBelongsToOtherPool: GenericPalletError<Rv>;
+        AccountBelongsToOtherPool: GenericPalletError;
         /**
          * The member is fully unbonded (and thus cannot access the bonded and reward pool
          * anymore to, for example, collect rewards).
          **/
-        FullyUnbonding: GenericPalletError<Rv>;
+        FullyUnbonding: GenericPalletError;
         /**
          * The member cannot unbond further chunks due to reaching the limit.
          **/
-        MaxUnbondingLimit: GenericPalletError<Rv>;
+        MaxUnbondingLimit: GenericPalletError;
         /**
          * None of the funds can be withdrawn yet because the bonding duration has not passed.
          **/
-        CannotWithdrawAny: GenericPalletError<Rv>;
+        CannotWithdrawAny: GenericPalletError;
         /**
          * The amount does not meet the minimum bond to either join or create a pool.
          *
@@ -2981,130 +2981,130 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          * caller does not have nominating permissions for the pool. Members can never unbond to a
          * value below `MinJoinBond`.
          **/
-        MinimumBondNotMet: GenericPalletError<Rv>;
+        MinimumBondNotMet: GenericPalletError;
         /**
          * The transaction could not be executed due to overflow risk for the pool.
          **/
-        OverflowRisk: GenericPalletError<Rv>;
+        OverflowRisk: GenericPalletError;
         /**
          * A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for
          * other members to be permissionlessly unbonded.
          **/
-        NotDestroying: GenericPalletError<Rv>;
+        NotDestroying: GenericPalletError;
         /**
          * The caller does not have nominating permissions for the pool.
          **/
-        NotNominator: GenericPalletError<Rv>;
+        NotNominator: GenericPalletError;
         /**
          * Either a) the caller cannot make a valid kick or b) the pool is not destroying.
          **/
-        NotKickerOrDestroying: GenericPalletError<Rv>;
+        NotKickerOrDestroying: GenericPalletError;
         /**
          * The pool is not open to join
          **/
-        NotOpen: GenericPalletError<Rv>;
+        NotOpen: GenericPalletError;
         /**
          * The system is maxed out on pools.
          **/
-        MaxPools: GenericPalletError<Rv>;
+        MaxPools: GenericPalletError;
         /**
          * Too many members in the pool or system.
          **/
-        MaxPoolMembers: GenericPalletError<Rv>;
+        MaxPoolMembers: GenericPalletError;
         /**
          * The pools state cannot be changed.
          **/
-        CanNotChangeState: GenericPalletError<Rv>;
+        CanNotChangeState: GenericPalletError;
         /**
          * The caller does not have adequate permissions.
          **/
-        DoesNotHavePermission: GenericPalletError<Rv>;
+        DoesNotHavePermission: GenericPalletError;
         /**
          * Metadata exceeds [`Config::MaxMetadataLen`]
          **/
-        MetadataExceedsMaxLen: GenericPalletError<Rv>;
+        MetadataExceedsMaxLen: GenericPalletError;
         /**
          * Some error occurred that should never happen. This should be reported to the
          * maintainers.
          **/
-        Defensive: GenericPalletError<Rv>;
+        Defensive: GenericPalletError;
         /**
          * Partial unbonding now allowed permissionlessly.
          **/
-        PartialUnbondNotAllowedPermissionlessly: GenericPalletError<Rv>;
+        PartialUnbondNotAllowedPermissionlessly: GenericPalletError;
         /**
          * The pool's max commission cannot be set higher than the existing value.
          **/
-        MaxCommissionRestricted: GenericPalletError<Rv>;
+        MaxCommissionRestricted: GenericPalletError;
         /**
          * The supplied commission exceeds the max allowed commission.
          **/
-        CommissionExceedsMaximum: GenericPalletError<Rv>;
+        CommissionExceedsMaximum: GenericPalletError;
         /**
          * The supplied commission exceeds global maximum commission.
          **/
-        CommissionExceedsGlobalMaximum: GenericPalletError<Rv>;
+        CommissionExceedsGlobalMaximum: GenericPalletError;
         /**
          * Not enough blocks have surpassed since the last commission update.
          **/
-        CommissionChangeThrottled: GenericPalletError<Rv>;
+        CommissionChangeThrottled: GenericPalletError;
         /**
          * The submitted changes to commission change rate are not allowed.
          **/
-        CommissionChangeRateNotAllowed: GenericPalletError<Rv>;
+        CommissionChangeRateNotAllowed: GenericPalletError;
         /**
          * There is no pending commission to claim.
          **/
-        NoPendingCommission: GenericPalletError<Rv>;
+        NoPendingCommission: GenericPalletError;
         /**
          * No commission current has been set.
          **/
-        NoCommissionCurrentSet: GenericPalletError<Rv>;
+        NoCommissionCurrentSet: GenericPalletError;
         /**
          * Pool id currently in use.
          **/
-        PoolIdInUse: GenericPalletError<Rv>;
+        PoolIdInUse: GenericPalletError;
         /**
          * Pool id provided is not correct/usable.
          **/
-        InvalidPoolId: GenericPalletError<Rv>;
+        InvalidPoolId: GenericPalletError;
         /**
          * Bonding extra is restricted to the exact pending reward amount.
          **/
-        BondExtraRestricted: GenericPalletError<Rv>;
+        BondExtraRestricted: GenericPalletError;
         /**
          * No imbalance in the ED deposit for the pool.
          **/
-        NothingToAdjust: GenericPalletError<Rv>;
+        NothingToAdjust: GenericPalletError;
         /**
          * No slash pending that can be applied to the member.
          **/
-        NothingToSlash: GenericPalletError<Rv>;
+        NothingToSlash: GenericPalletError;
         /**
          * The slash amount is too low to be applied.
          **/
-        SlashTooLow: GenericPalletError<Rv>;
+        SlashTooLow: GenericPalletError;
         /**
          * The pool or member delegation has already migrated to delegate stake.
          **/
-        AlreadyMigrated: GenericPalletError<Rv>;
+        AlreadyMigrated: GenericPalletError;
         /**
          * The pool or member delegation has not migrated yet to delegate stake.
          **/
-        NotMigrated: GenericPalletError<Rv>;
+        NotMigrated: GenericPalletError;
         /**
          * This call is not allowed in the current state of the pallet.
          **/
-        NotSupported: GenericPalletError<Rv>;
+        NotSupported: GenericPalletError;
         /**
          * Account is restricted from participation in pools. This may happen if the account is
          * staking in another way already.
          **/
-        Restricted: GenericPalletError<Rv>;
+        Restricted: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `RankedPolls`'s errors
@@ -3113,63 +3113,63 @@ 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 `RankedCollective`'s errors
@@ -3178,51 +3178,51 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Account is already a member.
          **/
-        AlreadyMember: GenericPalletError<Rv>;
+        AlreadyMember: GenericPalletError;
         /**
          * Account is not a member.
          **/
-        NotMember: GenericPalletError<Rv>;
+        NotMember: GenericPalletError;
         /**
          * The given poll index is unknown or has closed.
          **/
-        NotPolling: GenericPalletError<Rv>;
+        NotPolling: GenericPalletError;
         /**
          * The given poll is still ongoing.
          **/
-        Ongoing: GenericPalletError<Rv>;
+        Ongoing: GenericPalletError;
         /**
          * There are no further records to be removed.
          **/
-        NoneRemaining: GenericPalletError<Rv>;
+        NoneRemaining: GenericPalletError;
         /**
          * Unexpected error in state.
          **/
-        Corruption: GenericPalletError<Rv>;
+        Corruption: GenericPalletError;
         /**
          * The member's rank is too low to vote.
          **/
-        RankTooLow: GenericPalletError<Rv>;
+        RankTooLow: GenericPalletError;
         /**
          * The information provided is incorrect.
          **/
-        InvalidWitness: GenericPalletError<Rv>;
+        InvalidWitness: GenericPalletError;
         /**
          * The origin is not sufficiently privileged to do the operation.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * The new member to exchange is the same as the old member
          **/
-        SameMember: GenericPalletError<Rv>;
+        SameMember: GenericPalletError;
         /**
          * The max member count for the rank has been reached.
          **/
-        TooManyMembers: GenericPalletError<Rv>;
+        TooManyMembers: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `AssetConversion`'s errors
@@ -3231,102 +3231,102 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Provided asset pair is not supported for pool.
          **/
-        InvalidAssetPair: GenericPalletError<Rv>;
+        InvalidAssetPair: GenericPalletError;
         /**
          * Pool already exists.
          **/
-        PoolExists: GenericPalletError<Rv>;
+        PoolExists: GenericPalletError;
         /**
          * Desired amount can't be zero.
          **/
-        WrongDesiredAmount: GenericPalletError<Rv>;
+        WrongDesiredAmount: GenericPalletError;
         /**
          * Provided amount should be greater than or equal to the existential deposit/asset's
          * minimal amount.
          **/
-        AmountOneLessThanMinimal: GenericPalletError<Rv>;
+        AmountOneLessThanMinimal: GenericPalletError;
         /**
          * Provided amount should be greater than or equal to the existential deposit/asset's
          * minimal amount.
          **/
-        AmountTwoLessThanMinimal: GenericPalletError<Rv>;
+        AmountTwoLessThanMinimal: GenericPalletError;
         /**
          * Reserve needs to always be greater than or equal to the existential deposit/asset's
          * minimal amount.
          **/
-        ReserveLeftLessThanMinimal: GenericPalletError<Rv>;
+        ReserveLeftLessThanMinimal: GenericPalletError;
         /**
          * Desired amount can't be equal to the pool reserve.
          **/
-        AmountOutTooHigh: GenericPalletError<Rv>;
+        AmountOutTooHigh: GenericPalletError;
         /**
          * The pool doesn't exist.
          **/
-        PoolNotFound: GenericPalletError<Rv>;
+        PoolNotFound: GenericPalletError;
         /**
          * An overflow happened.
          **/
-        Overflow: GenericPalletError<Rv>;
+        Overflow: GenericPalletError;
         /**
          * The minimal amount requirement for the first token in the pair wasn't met.
          **/
-        AssetOneDepositDidNotMeetMinimum: GenericPalletError<Rv>;
+        AssetOneDepositDidNotMeetMinimum: GenericPalletError;
         /**
          * The minimal amount requirement for the second token in the pair wasn't met.
          **/
-        AssetTwoDepositDidNotMeetMinimum: GenericPalletError<Rv>;
+        AssetTwoDepositDidNotMeetMinimum: GenericPalletError;
         /**
          * The minimal amount requirement for the first token in the pair wasn't met.
          **/
-        AssetOneWithdrawalDidNotMeetMinimum: GenericPalletError<Rv>;
+        AssetOneWithdrawalDidNotMeetMinimum: GenericPalletError;
         /**
          * The minimal amount requirement for the second token in the pair wasn't met.
          **/
-        AssetTwoWithdrawalDidNotMeetMinimum: GenericPalletError<Rv>;
+        AssetTwoWithdrawalDidNotMeetMinimum: GenericPalletError;
         /**
          * Optimal calculated amount is less than desired.
          **/
-        OptimalAmountLessThanDesired: GenericPalletError<Rv>;
+        OptimalAmountLessThanDesired: GenericPalletError;
         /**
          * Insufficient liquidity minted.
          **/
-        InsufficientLiquidityMinted: GenericPalletError<Rv>;
+        InsufficientLiquidityMinted: GenericPalletError;
         /**
          * Requested liquidity can't be zero.
          **/
-        ZeroLiquidity: GenericPalletError<Rv>;
+        ZeroLiquidity: GenericPalletError;
         /**
          * Amount can't be zero.
          **/
-        ZeroAmount: GenericPalletError<Rv>;
+        ZeroAmount: GenericPalletError;
         /**
          * Calculated amount out is less than provided minimum amount.
          **/
-        ProvidedMinimumNotSufficientForSwap: GenericPalletError<Rv>;
+        ProvidedMinimumNotSufficientForSwap: GenericPalletError;
         /**
          * Provided maximum amount is not sufficient for swap.
          **/
-        ProvidedMaximumNotSufficientForSwap: GenericPalletError<Rv>;
+        ProvidedMaximumNotSufficientForSwap: GenericPalletError;
         /**
          * The provided path must consists of 2 assets at least.
          **/
-        InvalidPath: GenericPalletError<Rv>;
+        InvalidPath: GenericPalletError;
         /**
          * The provided path must consists of unique assets.
          **/
-        NonUniquePath: GenericPalletError<Rv>;
+        NonUniquePath: GenericPalletError;
         /**
          * It was not possible to get or increment the Id of the pool.
          **/
-        IncorrectPoolAssetId: GenericPalletError<Rv>;
+        IncorrectPoolAssetId: GenericPalletError;
         /**
          * The destination account cannot exist with the swapped funds.
          **/
-        BelowMinimum: GenericPalletError<Rv>;
+        BelowMinimum: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `FastUnstake`'s errors
@@ -3337,31 +3337,31 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          *
          * This means that the given account is not bonded.
          **/
-        NotController: GenericPalletError<Rv>;
+        NotController: GenericPalletError;
         /**
          * The bonded account has already been queued.
          **/
-        AlreadyQueued: GenericPalletError<Rv>;
+        AlreadyQueued: GenericPalletError;
         /**
          * The bonded account has active unlocking chunks.
          **/
-        NotFullyBonded: GenericPalletError<Rv>;
+        NotFullyBonded: GenericPalletError;
         /**
          * The provided un-staker is not in the `Queue`.
          **/
-        NotQueued: GenericPalletError<Rv>;
+        NotQueued: GenericPalletError;
         /**
          * The provided un-staker is already in Head, and cannot deregister.
          **/
-        AlreadyHead: GenericPalletError<Rv>;
+        AlreadyHead: GenericPalletError;
         /**
          * The call is not allowed at this point because the pallet is not active.
          **/
-        CallNotAllowed: GenericPalletError<Rv>;
+        CallNotAllowed: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `MessageQueue`'s errors
@@ -3371,48 +3371,48 @@ 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.
          *
          * 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 `TxPause`'s errors
@@ -3421,20 +3421,20 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The call is paused.
          **/
-        IsPaused: GenericPalletError<Rv>;
+        IsPaused: GenericPalletError;
         /**
          * The call is unpaused.
          **/
-        IsUnpaused: GenericPalletError<Rv>;
+        IsUnpaused: GenericPalletError;
         /**
          * The call is whitelisted and cannot be paused.
          **/
-        Unpausable: GenericPalletError<Rv>;
-        NotFound: GenericPalletError<Rv>;
+        Unpausable: GenericPalletError;
+        NotFound: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `SafeMode`'s errors
@@ -3443,35 +3443,35 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The safe-mode is (already or still) entered.
          **/
-        Entered: GenericPalletError<Rv>;
+        Entered: GenericPalletError;
         /**
          * The safe-mode is (already or still) exited.
          **/
-        Exited: GenericPalletError<Rv>;
+        Exited: GenericPalletError;
         /**
          * This functionality of the pallet is disabled by the configuration.
          **/
-        NotConfigured: GenericPalletError<Rv>;
+        NotConfigured: GenericPalletError;
         /**
          * There is no balance reserved.
          **/
-        NoDeposit: GenericPalletError<Rv>;
+        NoDeposit: GenericPalletError;
         /**
          * The account already has a deposit reserved and can therefore not enter or extend again.
          **/
-        AlreadyDeposited: GenericPalletError<Rv>;
+        AlreadyDeposited: GenericPalletError;
         /**
          * This deposit cannot be released yet.
          **/
-        CannotReleaseYet: GenericPalletError<Rv>;
+        CannotReleaseYet: GenericPalletError;
         /**
          * An error from the underlying `Currency`.
          **/
-        CurrencyError: GenericPalletError<Rv>;
+        CurrencyError: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `MultiBlockMigrations`'s errors
@@ -3480,11 +3480,11 @@ 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 `Broker`'s errors
@@ -3493,159 +3493,159 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The given region identity is not known.
          **/
-        UnknownRegion: GenericPalletError<Rv>;
+        UnknownRegion: GenericPalletError;
         /**
          * The owner of the region is not the origin.
          **/
-        NotOwner: GenericPalletError<Rv>;
+        NotOwner: GenericPalletError;
         /**
          * The pivot point of the partition at or after the end of the region.
          **/
-        PivotTooLate: GenericPalletError<Rv>;
+        PivotTooLate: GenericPalletError;
         /**
          * The pivot point of the partition at the beginning of the region.
          **/
-        PivotTooEarly: GenericPalletError<Rv>;
+        PivotTooEarly: GenericPalletError;
         /**
          * The pivot mask for the interlacing is not contained within the region's interlace mask.
          **/
-        ExteriorPivot: GenericPalletError<Rv>;
+        ExteriorPivot: GenericPalletError;
         /**
          * The pivot mask for the interlacing is void (and therefore unschedulable).
          **/
-        VoidPivot: GenericPalletError<Rv>;
+        VoidPivot: GenericPalletError;
         /**
          * The pivot mask for the interlacing is complete (and therefore not a strict subset).
          **/
-        CompletePivot: GenericPalletError<Rv>;
+        CompletePivot: GenericPalletError;
         /**
          * The workplan of the pallet's state is invalid. This indicates a state corruption.
          **/
-        CorruptWorkplan: GenericPalletError<Rv>;
+        CorruptWorkplan: GenericPalletError;
         /**
          * There is no sale happening currently.
          **/
-        NoSales: GenericPalletError<Rv>;
+        NoSales: GenericPalletError;
         /**
          * The price limit is exceeded.
          **/
-        Overpriced: GenericPalletError<Rv>;
+        Overpriced: GenericPalletError;
         /**
          * There are no cores available.
          **/
-        Unavailable: GenericPalletError<Rv>;
+        Unavailable: GenericPalletError;
         /**
          * The sale limit has been reached.
          **/
-        SoldOut: GenericPalletError<Rv>;
+        SoldOut: GenericPalletError;
         /**
          * The renewal operation is not valid at the current time (it may become valid in the next
          * sale).
          **/
-        WrongTime: GenericPalletError<Rv>;
+        WrongTime: GenericPalletError;
         /**
          * Invalid attempt to renew.
          **/
-        NotAllowed: GenericPalletError<Rv>;
+        NotAllowed: GenericPalletError;
         /**
          * This pallet has not yet been initialized.
          **/
-        Uninitialized: GenericPalletError<Rv>;
+        Uninitialized: GenericPalletError;
         /**
          * The purchase cannot happen yet as the sale period is yet to begin.
          **/
-        TooEarly: GenericPalletError<Rv>;
+        TooEarly: GenericPalletError;
         /**
          * There is no work to be done.
          **/
-        NothingToDo: GenericPalletError<Rv>;
+        NothingToDo: GenericPalletError;
         /**
          * The maximum amount of reservations has already been reached.
          **/
-        TooManyReservations: GenericPalletError<Rv>;
+        TooManyReservations: GenericPalletError;
         /**
          * The maximum amount of leases has already been reached.
          **/
-        TooManyLeases: GenericPalletError<Rv>;
+        TooManyLeases: GenericPalletError;
         /**
          * The lease does not exist.
          **/
-        LeaseNotFound: GenericPalletError<Rv>;
+        LeaseNotFound: GenericPalletError;
         /**
          * The revenue for the Instantaneous Core Sales of this period is not (yet) known and thus
          * this operation cannot proceed.
          **/
-        UnknownRevenue: GenericPalletError<Rv>;
+        UnknownRevenue: GenericPalletError;
         /**
          * The identified contribution to the Instantaneous Core Pool is unknown.
          **/
-        UnknownContribution: GenericPalletError<Rv>;
+        UnknownContribution: GenericPalletError;
         /**
          * The workload assigned for renewal is incomplete. This is unexpected and indicates a
          * logic error.
          **/
-        IncompleteAssignment: GenericPalletError<Rv>;
+        IncompleteAssignment: GenericPalletError;
         /**
          * An item cannot be dropped because it is still valid.
          **/
-        StillValid: GenericPalletError<Rv>;
+        StillValid: GenericPalletError;
         /**
          * The history item does not exist.
          **/
-        NoHistory: GenericPalletError<Rv>;
+        NoHistory: GenericPalletError;
         /**
          * No reservation of the given index exists.
          **/
-        UnknownReservation: GenericPalletError<Rv>;
+        UnknownReservation: GenericPalletError;
         /**
          * The renewal record cannot be found.
          **/
-        UnknownRenewal: GenericPalletError<Rv>;
+        UnknownRenewal: GenericPalletError;
         /**
          * The lease expiry time has already passed.
          **/
-        AlreadyExpired: GenericPalletError<Rv>;
+        AlreadyExpired: GenericPalletError;
         /**
          * The configuration could not be applied because it is invalid.
          **/
-        InvalidConfig: GenericPalletError<Rv>;
+        InvalidConfig: GenericPalletError;
         /**
          * The revenue must be claimed for 1 or more timeslices.
          **/
-        NoClaimTimeslices: GenericPalletError<Rv>;
+        NoClaimTimeslices: GenericPalletError;
         /**
          * The caller doesn't have the permission to enable or disable auto-renewal.
          **/
-        NoPermission: GenericPalletError<Rv>;
+        NoPermission: GenericPalletError;
         /**
          * We reached the limit for auto-renewals.
          **/
-        TooManyAutoRenewals: GenericPalletError<Rv>;
+        TooManyAutoRenewals: GenericPalletError;
         /**
          * Only cores which are assigned to a task can be auto-renewed.
          **/
-        NonTaskAutoRenewal: GenericPalletError<Rv>;
+        NonTaskAutoRenewal: GenericPalletError;
         /**
          * Failed to get the sovereign account of a task.
          **/
-        SovereignAccountNotFound: GenericPalletError<Rv>;
+        SovereignAccountNotFound: GenericPalletError;
         /**
          * Attempted to disable auto-renewal for a core that didn't have it enabled.
          **/
-        AutoRenewalNotEnabled: GenericPalletError<Rv>;
+        AutoRenewalNotEnabled: GenericPalletError;
         /**
          * Attempted to force remove an assignment that doesn't exist.
          **/
-        AssignmentNotFound: GenericPalletError<Rv>;
+        AssignmentNotFound: GenericPalletError;
         /**
          * Needed to prevent spam attacks.The amount of credits the user attempted to purchase is
          * below `T::MinimumCreditPurchase`.
          **/
-        CreditPurchaseTooSmall: GenericPalletError<Rv>;
+        CreditPurchaseTooSmall: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `TasksExample`'s errors
@@ -3654,11 +3654,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The referenced task was not found.
          **/
-        NotFound: GenericPalletError<Rv>;
+        NotFound: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `AssetConversionMigration`'s errors
@@ -3667,23 +3667,23 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Provided asset pair is not supported for pool.
          **/
-        InvalidAssetPair: GenericPalletError<Rv>;
+        InvalidAssetPair: GenericPalletError;
         /**
          * The pool doesn't exist.
          **/
-        PoolNotFound: GenericPalletError<Rv>;
+        PoolNotFound: GenericPalletError;
         /**
          * Pool's balance cannot be zero.
          **/
-        ZeroBalance: GenericPalletError<Rv>;
+        ZeroBalance: GenericPalletError;
         /**
          * Indicates a partial transfer of balance to the new account during a migration.
          **/
-        PartialTransfer: GenericPalletError<Rv>;
+        PartialTransfer: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `Revive`'s errors
@@ -3692,216 +3692,216 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Invalid schedule supplied, e.g. with zero weight of a basic operation.
          **/
-        InvalidSchedule: GenericPalletError<Rv>;
+        InvalidSchedule: GenericPalletError;
         /**
          * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
          **/
-        InvalidCallFlags: GenericPalletError<Rv>;
+        InvalidCallFlags: GenericPalletError;
         /**
          * The executed contract exhausted its gas limit.
          **/
-        OutOfGas: GenericPalletError<Rv>;
+        OutOfGas: GenericPalletError;
         /**
          * Performing the requested transfer failed. Probably because there isn't enough
          * free balance in the sender's account.
          **/
-        TransferFailed: GenericPalletError<Rv>;
+        TransferFailed: GenericPalletError;
         /**
          * Performing a call was denied because the calling depth reached the limit
          * of what is specified in the schedule.
          **/
-        MaxCallDepthReached: GenericPalletError<Rv>;
+        MaxCallDepthReached: GenericPalletError;
         /**
          * No contract was found at the specified address.
          **/
-        ContractNotFound: GenericPalletError<Rv>;
+        ContractNotFound: GenericPalletError;
         /**
          * No code could be found at the supplied code hash.
          **/
-        CodeNotFound: GenericPalletError<Rv>;
+        CodeNotFound: GenericPalletError;
         /**
          * No code info could be found at the supplied code hash.
          **/
-        CodeInfoNotFound: GenericPalletError<Rv>;
+        CodeInfoNotFound: GenericPalletError;
         /**
          * A buffer outside of sandbox memory was passed to a contract API function.
          **/
-        OutOfBounds: GenericPalletError<Rv>;
+        OutOfBounds: GenericPalletError;
         /**
          * Input passed to a contract API function failed to decode as expected type.
          **/
-        DecodingFailed: GenericPalletError<Rv>;
+        DecodingFailed: GenericPalletError;
         /**
          * Contract trapped during execution.
          **/
-        ContractTrapped: GenericPalletError<Rv>;
+        ContractTrapped: GenericPalletError;
         /**
          * The size defined in `T::MaxValueSize` was exceeded.
          **/
-        ValueTooLarge: GenericPalletError<Rv>;
+        ValueTooLarge: GenericPalletError;
         /**
          * Termination of a contract is not allowed while the contract is already
          * on the call stack. Can be triggered by `seal_terminate`.
          **/
-        TerminatedWhileReentrant: GenericPalletError<Rv>;
+        TerminatedWhileReentrant: GenericPalletError;
         /**
          * `seal_call` forwarded this contracts input. It therefore is no longer available.
          **/
-        InputForwarded: GenericPalletError<Rv>;
+        InputForwarded: GenericPalletError;
         /**
          * The amount of topics passed to `seal_deposit_events` exceeds the limit.
          **/
-        TooManyTopics: GenericPalletError<Rv>;
+        TooManyTopics: GenericPalletError;
         /**
          * The chain does not provide a chain extension. Calling the chain extension results
          * in this error. Note that this usually shouldn't happen as deploying such contracts
          * is rejected.
          **/
-        NoChainExtension: GenericPalletError<Rv>;
+        NoChainExtension: GenericPalletError;
         /**
          * Failed to decode the XCM program.
          **/
-        XcmDecodeFailed: GenericPalletError<Rv>;
+        XcmDecodeFailed: GenericPalletError;
         /**
          * A contract with the same AccountId already exists.
          **/
-        DuplicateContract: GenericPalletError<Rv>;
+        DuplicateContract: GenericPalletError;
         /**
          * A contract self destructed in its constructor.
          *
          * This can be triggered by a call to `seal_terminate`.
          **/
-        TerminatedInConstructor: GenericPalletError<Rv>;
+        TerminatedInConstructor: GenericPalletError;
         /**
          * A call tried to invoke a contract that is flagged as non-reentrant.
          **/
-        ReentranceDenied: GenericPalletError<Rv>;
+        ReentranceDenied: GenericPalletError;
         /**
          * A contract called into the runtime which then called back into this pallet.
          **/
-        ReenteredPallet: GenericPalletError<Rv>;
+        ReenteredPallet: GenericPalletError;
         /**
          * A contract attempted to invoke a state modifying API while being in read-only mode.
          **/
-        StateChangeDenied: GenericPalletError<Rv>;
+        StateChangeDenied: GenericPalletError;
         /**
          * Origin doesn't have enough balance to pay the required storage deposits.
          **/
-        StorageDepositNotEnoughFunds: GenericPalletError<Rv>;
+        StorageDepositNotEnoughFunds: GenericPalletError;
         /**
          * More storage was created than allowed by the storage deposit limit.
          **/
-        StorageDepositLimitExhausted: GenericPalletError<Rv>;
+        StorageDepositLimitExhausted: GenericPalletError;
         /**
          * Code removal was denied because the code is still in use by at least one contract.
          **/
-        CodeInUse: GenericPalletError<Rv>;
+        CodeInUse: GenericPalletError;
         /**
          * The contract ran to completion but decided to revert its storage changes.
          * Please note that this error is only returned from extrinsics. When called directly
          * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
          * to determine whether a reversion has taken place.
          **/
-        ContractReverted: GenericPalletError<Rv>;
+        ContractReverted: GenericPalletError;
         /**
          * The contract failed to compile or is missing the correct entry points.
          *
          * A more detailed error can be found on the node console if debug messages are enabled
          * by supplying `-lruntime::revive=debug`.
          **/
-        CodeRejected: GenericPalletError<Rv>;
+        CodeRejected: GenericPalletError;
         /**
          * The code blob supplied is larger than [`limits::code::BLOB_BYTES`].
          **/
-        BlobTooLarge: GenericPalletError<Rv>;
+        BlobTooLarge: GenericPalletError;
         /**
          * The static memory consumption of the blob will be larger than
          * [`limits::code::STATIC_MEMORY_BYTES`].
          **/
-        StaticMemoryTooLarge: GenericPalletError<Rv>;
+        StaticMemoryTooLarge: GenericPalletError;
         /**
          * The program contains a basic block that is larger than allowed.
          **/
-        BasicBlockTooLarge: GenericPalletError<Rv>;
+        BasicBlockTooLarge: GenericPalletError;
         /**
          * The program contains an invalid instruction.
          **/
-        InvalidInstruction: GenericPalletError<Rv>;
+        InvalidInstruction: GenericPalletError;
         /**
          * The contract has reached its maximum number of delegate dependencies.
          **/
-        MaxDelegateDependenciesReached: GenericPalletError<Rv>;
+        MaxDelegateDependenciesReached: GenericPalletError;
         /**
          * The dependency was not found in the contract's delegate dependencies.
          **/
-        DelegateDependencyNotFound: GenericPalletError<Rv>;
+        DelegateDependencyNotFound: GenericPalletError;
         /**
          * The contract already depends on the given delegate dependency.
          **/
-        DelegateDependencyAlreadyExists: GenericPalletError<Rv>;
+        DelegateDependencyAlreadyExists: GenericPalletError;
         /**
          * Can not add a delegate dependency to the code hash of the contract itself.
          **/
-        CannotAddSelfAsDelegateDependency: GenericPalletError<Rv>;
+        CannotAddSelfAsDelegateDependency: GenericPalletError;
         /**
          * Can not add more data to transient storage.
          **/
-        OutOfTransientStorage: GenericPalletError<Rv>;
+        OutOfTransientStorage: GenericPalletError;
         /**
          * The contract tried to call a syscall which does not exist (at its current api level).
          **/
-        InvalidSyscall: GenericPalletError<Rv>;
+        InvalidSyscall: GenericPalletError;
         /**
          * Invalid storage flags were passed to one of the storage syscalls.
          **/
-        InvalidStorageFlags: GenericPalletError<Rv>;
+        InvalidStorageFlags: GenericPalletError;
         /**
          * PolkaVM failed during code execution. Probably due to a malformed program.
          **/
-        ExecutionFailed: GenericPalletError<Rv>;
+        ExecutionFailed: GenericPalletError;
         /**
          * Failed to convert a U256 to a Balance.
          **/
-        BalanceConversionFailed: GenericPalletError<Rv>;
+        BalanceConversionFailed: GenericPalletError;
         /**
          * Failed to convert an EVM balance to a native balance.
          **/
-        DecimalPrecisionLoss: GenericPalletError<Rv>;
+        DecimalPrecisionLoss: GenericPalletError;
         /**
          * Immutable data can only be set during deploys and only be read during calls.
          * Additionally, it is only valid to set the data once and it must not be empty.
          **/
-        InvalidImmutableAccess: GenericPalletError<Rv>;
+        InvalidImmutableAccess: GenericPalletError;
         /**
          * An `AccountID32` account tried to interact with the pallet without having a mapping.
          *
          * Call [`Pallet::map_account`] in order to create a mapping for the account.
          **/
-        AccountUnmapped: GenericPalletError<Rv>;
+        AccountUnmapped: GenericPalletError;
         /**
          * Tried to map an account that is already mapped.
          **/
-        AccountAlreadyMapped: GenericPalletError<Rv>;
+        AccountAlreadyMapped: GenericPalletError;
         /**
          * The transaction used to dry-run a contract is invalid.
          **/
-        InvalidGenericTransaction: GenericPalletError<Rv>;
+        InvalidGenericTransaction: GenericPalletError;
         /**
          * The refcount of a code either over or underflowed.
          **/
-        RefcountOverOrUnderflow: GenericPalletError<Rv>;
+        RefcountOverOrUnderflow: GenericPalletError;
         /**
          * Unsupported precompile address
          **/
-        UnsupportedPrecompileAddress: GenericPalletError<Rv>;
+        UnsupportedPrecompileAddress: GenericPalletError;
         /**
          * Precompile Error
          **/
-        PrecompileFailure: GenericPalletError<Rv>;
+        PrecompileFailure: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `DelegatedStaking`'s errors
@@ -3910,15 +3910,15 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The account cannot perform this operation.
          **/
-        NotAllowed: GenericPalletError<Rv>;
+        NotAllowed: GenericPalletError;
         /**
          * An existing staker cannot perform this action.
          **/
-        AlreadyStaking: GenericPalletError<Rv>;
+        AlreadyStaking: GenericPalletError;
         /**
          * Reward Destination cannot be same as `Agent` account.
          **/
-        InvalidRewardDestination: GenericPalletError<Rv>;
+        InvalidRewardDestination: GenericPalletError;
         /**
          * Delegation conditions are not met.
          *
@@ -3926,43 +3926,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
          * 1) Cannot delegate to self,
          * 2) Cannot delegate to multiple delegates.
          **/
-        InvalidDelegation: GenericPalletError<Rv>;
+        InvalidDelegation: GenericPalletError;
         /**
          * The account does not have enough funds to perform the operation.
          **/
-        NotEnoughFunds: GenericPalletError<Rv>;
+        NotEnoughFunds: GenericPalletError;
         /**
          * Not an existing `Agent` account.
          **/
-        NotAgent: GenericPalletError<Rv>;
+        NotAgent: GenericPalletError;
         /**
          * Not a Delegator account.
          **/
-        NotDelegator: GenericPalletError<Rv>;
+        NotDelegator: GenericPalletError;
         /**
          * Some corruption in internal state.
          **/
-        BadState: GenericPalletError<Rv>;
+        BadState: GenericPalletError;
         /**
          * Unapplied pending slash restricts operation on `Agent`.
          **/
-        UnappliedSlash: GenericPalletError<Rv>;
+        UnappliedSlash: GenericPalletError;
         /**
          * `Agent` has no pending slash to be applied.
          **/
-        NothingToSlash: GenericPalletError<Rv>;
+        NothingToSlash: GenericPalletError;
         /**
          * Failed to withdraw amount from Core Staking.
          **/
-        WithdrawFailed: GenericPalletError<Rv>;
+        WithdrawFailed: GenericPalletError;
         /**
          * Operation not supported by this pallet.
          **/
-        NotSupported: GenericPalletError<Rv>;
+        NotSupported: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `AssetRewards`'s errors
@@ -3971,47 +3971,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * The staker does not have enough tokens to perform the operation.
          **/
-        NotEnoughTokens: GenericPalletError<Rv>;
+        NotEnoughTokens: GenericPalletError;
         /**
          * An operation was attempted on a non-existent pool.
          **/
-        NonExistentPool: GenericPalletError<Rv>;
+        NonExistentPool: GenericPalletError;
         /**
          * An operation was attempted for a non-existent staker.
          **/
-        NonExistentStaker: GenericPalletError<Rv>;
+        NonExistentStaker: GenericPalletError;
         /**
          * An operation was attempted with a non-existent asset.
          **/
-        NonExistentAsset: GenericPalletError<Rv>;
+        NonExistentAsset: GenericPalletError;
         /**
          * There was an error converting a block number.
          **/
-        BlockNumberConversionError: GenericPalletError<Rv>;
+        BlockNumberConversionError: GenericPalletError;
         /**
          * The expiry block must be in the future.
          **/
-        ExpiryBlockMustBeInTheFuture: GenericPalletError<Rv>;
+        ExpiryBlockMustBeInTheFuture: GenericPalletError;
         /**
          * Insufficient funds to create the freeze.
          **/
-        InsufficientFunds: GenericPalletError<Rv>;
+        InsufficientFunds: GenericPalletError;
         /**
          * The expiry block can be only extended.
          **/
-        ExpiryCut: GenericPalletError<Rv>;
+        ExpiryCut: GenericPalletError;
         /**
          * The reward rate per block can be only increased.
          **/
-        RewardRateCut: GenericPalletError<Rv>;
+        RewardRateCut: GenericPalletError;
         /**
          * The pool still has staked tokens or rewards.
          **/
-        NonEmptyPool: GenericPalletError<Rv>;
+        NonEmptyPool: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `AssetsFreezer`'s errors
@@ -4020,11 +4020,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Number of freezes on an account would exceed `MaxFreezes`.
          **/
-        TooManyFreezes: GenericPalletError<Rv>;
+        TooManyFreezes: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
     /**
      * Pallet `MetaTx`'s errors
@@ -4033,30 +4033,30 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
         /**
          * Invalid proof (e.g. signature).
          **/
-        BadProof: GenericPalletError<Rv>;
+        BadProof: GenericPalletError;
         /**
          * The meta transaction is not yet valid (e.g. nonce too high).
          **/
-        Future: GenericPalletError<Rv>;
+        Future: GenericPalletError;
         /**
          * The meta transaction is outdated (e.g. nonce too low).
          **/
-        Stale: GenericPalletError<Rv>;
+        Stale: GenericPalletError;
         /**
          * The meta transactions's birth block is ancient.
          **/
-        AncientBirthBlock: GenericPalletError<Rv>;
+        AncientBirthBlock: GenericPalletError;
         /**
          * The transaction extension did not authorize any origin.
          **/
-        UnknownOrigin: GenericPalletError<Rv>;
+        UnknownOrigin: GenericPalletError;
         /**
          * The meta transaction is invalid.
          **/
-        Invalid: GenericPalletError<Rv>;
+        Invalid: GenericPalletError;
         /**
          * Generic pallet error
          **/
-        [error: string]: GenericPalletError<Rv>;
+        [error: string]: GenericPalletError;
     };
 }