@dedot/chaintypes 0.194.0 → 0.196.0

package/hydration/errors.d.ts

@@ -1,8 +1,8 @@
 // Generated by dedot cli
 
-import type { GenericChainErrors, GenericPalletError, RpcVersion } from 'dedot/types';
+import type { GenericChainErrors, GenericPalletError } from 'dedot/types';
 
-export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+export interface ChainErrors extends GenericChainErrors {
   /**
    * Pallet `System`'s errors
    **/
@@ -11,55 +11,55 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The name of specification does not match between the current runtime
      * and the new runtime.
      **/
-    InvalidSpecName: GenericPalletError<Rv>;
+    InvalidSpecName: GenericPalletError;
 
     /**
      * The specification version is not allowed to decrease between the current runtime
      * and the new runtime.
      **/
-    SpecVersionNeedsToIncrease: GenericPalletError<Rv>;
+    SpecVersionNeedsToIncrease: GenericPalletError;
 
     /**
      * Failed to extract the runtime version from the new runtime.
      *
      * Either calling `Core_version` or decoding `RuntimeVersion` failed.
      **/
-    FailedToExtractRuntimeVersion: GenericPalletError<Rv>;
+    FailedToExtractRuntimeVersion: GenericPalletError;
 
     /**
      * Suicide called when the account has non-default composite data.
      **/
-    NonDefaultComposite: GenericPalletError<Rv>;
+    NonDefaultComposite: GenericPalletError;
 
     /**
      * There is a non-zero reference count preventing the account from being purged.
      **/
-    NonZeroRefCount: GenericPalletError<Rv>;
+    NonZeroRefCount: GenericPalletError;
 
     /**
      * The origin filter prevent the call to be dispatched.
      **/
-    CallFiltered: GenericPalletError<Rv>;
+    CallFiltered: GenericPalletError;
 
     /**
      * A multi-block migration is ongoing and prevents the current code from being replaced.
      **/
-    MultiBlockMigrationsOngoing: GenericPalletError<Rv>;
+    MultiBlockMigrationsOngoing: GenericPalletError;
 
     /**
      * No upgrade authorized.
      **/
-    NothingAuthorized: GenericPalletError<Rv>;
+    NothingAuthorized: GenericPalletError;
 
     /**
      * The submitted code is not authorized.
      **/
-    Unauthorized: GenericPalletError<Rv>;
+    Unauthorized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Balances`'s errors
@@ -68,67 +68,67 @@ 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 `MultiTransactionPayment`'s errors
@@ -137,67 +137,67 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Selected currency is not supported.
      **/
-    UnsupportedCurrency: GenericPalletError<Rv>;
+    UnsupportedCurrency: GenericPalletError;
 
     /**
      * Account balance should be non-zero.
      **/
-    ZeroBalance: GenericPalletError<Rv>;
+    ZeroBalance: GenericPalletError;
 
     /**
      * Currency is already in the list of accepted currencies.
      **/
-    AlreadyAccepted: GenericPalletError<Rv>;
+    AlreadyAccepted: GenericPalletError;
 
     /**
      * It is not allowed to add Core Asset as accepted currency. Core asset is accepted by design.
      **/
-    CoreAssetNotAllowed: GenericPalletError<Rv>;
+    CoreAssetNotAllowed: GenericPalletError;
 
     /**
      * Fallback price cannot be zero.
      **/
-    ZeroPrice: GenericPalletError<Rv>;
+    ZeroPrice: GenericPalletError;
 
     /**
      * Fallback price was not found.
      **/
-    FallbackPriceNotFound: GenericPalletError<Rv>;
+    FallbackPriceNotFound: GenericPalletError;
 
     /**
      * Math overflow
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * It is not allowed to change payment currency of an EVM account.
      **/
-    EvmAccountNotAllowed: GenericPalletError<Rv>;
+    EvmAccountNotAllowed: GenericPalletError;
 
     /**
      * EVM permit expired.
      **/
-    EvmPermitExpired: GenericPalletError<Rv>;
+    EvmPermitExpired: GenericPalletError;
 
     /**
      * EVM permit is invalid.
      **/
-    EvmPermitInvalid: GenericPalletError<Rv>;
+    EvmPermitInvalid: GenericPalletError;
 
     /**
      * EVM permit call failed.
      **/
-    EvmPermitCallExecutionError: GenericPalletError<Rv>;
+    EvmPermitCallExecutionError: GenericPalletError;
 
     /**
      * EVM permit call failed.
      **/
-    EvmPermitRunnerError: GenericPalletError<Rv>;
+    EvmPermitRunnerError: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Treasury`'s errors
@@ -206,63 +206,63 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * No proposal, bounty or spend at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * Too many approvals in the queue.
      **/
-    TooManyApprovals: GenericPalletError<Rv>;
+    TooManyApprovals: GenericPalletError;
 
     /**
      * The spend origin is valid but the amount it is allowed to spend is lower than the
      * amount to be spent.
      **/
-    InsufficientPermission: GenericPalletError<Rv>;
+    InsufficientPermission: GenericPalletError;
 
     /**
      * Proposal has not been approved.
      **/
-    ProposalNotApproved: GenericPalletError<Rv>;
+    ProposalNotApproved: GenericPalletError;
 
     /**
      * The balance of the asset kind is not convertible to the balance of the native asset.
      **/
-    FailedToConvertBalance: GenericPalletError<Rv>;
+    FailedToConvertBalance: GenericPalletError;
 
     /**
      * The spend has expired and cannot be claimed.
      **/
-    SpendExpired: GenericPalletError<Rv>;
+    SpendExpired: GenericPalletError;
 
     /**
      * The spend is not yet eligible for payout.
      **/
-    EarlyPayout: GenericPalletError<Rv>;
+    EarlyPayout: GenericPalletError;
 
     /**
      * The payment has already been attempted.
      **/
-    AlreadyAttempted: GenericPalletError<Rv>;
+    AlreadyAttempted: GenericPalletError;
 
     /**
      * There was some issue with the mechanism of payment.
      **/
-    PayoutError: GenericPalletError<Rv>;
+    PayoutError: GenericPalletError;
 
     /**
      * The payout was not yet attempted/claimed.
      **/
-    NotAttempted: GenericPalletError<Rv>;
+    NotAttempted: GenericPalletError;
 
     /**
      * The payment has neither failed nor succeeded yet.
      **/
-    Inconclusive: GenericPalletError<Rv>;
+    Inconclusive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Utility`'s errors
@@ -271,12 +271,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Too many calls batched.
      **/
-    TooManyCalls: GenericPalletError<Rv>;
+    TooManyCalls: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Preimage`'s errors
@@ -285,47 +285,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Preimage is too large to store on-chain.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Preimage has already been noted on-chain.
      **/
-    AlreadyNoted: GenericPalletError<Rv>;
+    AlreadyNoted: GenericPalletError;
 
     /**
      * The user is not authorized to perform this action.
      **/
-    NotAuthorized: GenericPalletError<Rv>;
+    NotAuthorized: GenericPalletError;
 
     /**
      * The preimage cannot be removed since it has not yet been noted.
      **/
-    NotNoted: GenericPalletError<Rv>;
+    NotNoted: GenericPalletError;
 
     /**
      * A preimage may not be removed when there are outstanding requests.
      **/
-    Requested: GenericPalletError<Rv>;
+    Requested: GenericPalletError;
 
     /**
      * The preimage request cannot be removed since no outstanding requests exist.
      **/
-    NotRequested: GenericPalletError<Rv>;
+    NotRequested: GenericPalletError;
 
     /**
      * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Too few hashes were requested to be upgraded (i.e. zero).
      **/
-    TooFew: GenericPalletError<Rv>;
+    TooFew: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Identity`'s errors
@@ -334,137 +334,137 @@ 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Democracy`'s errors
@@ -473,128 +473,128 @@ 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 `TechnicalCommittee`'s errors
@@ -603,62 +603,62 @@ 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -667,47 +667,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * There are too many proxies registered or too many announcements pending.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Proxy registration not found.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Sender is not a proxy of the account to be proxied.
      **/
-    NotProxy: GenericPalletError<Rv>;
+    NotProxy: GenericPalletError;
 
     /**
      * A call which is incompatible with the proxy type's filter was attempted.
      **/
-    Unproxyable: GenericPalletError<Rv>;
+    Unproxyable: GenericPalletError;
 
     /**
      * Account is already a proxy.
      **/
-    Duplicate: GenericPalletError<Rv>;
+    Duplicate: GenericPalletError;
 
     /**
      * Call may not be made by proxy because it may escalate its privileges.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError<Rv>;
+    Unannounced: GenericPalletError;
 
     /**
      * Cannot add self as proxy.
      **/
-    NoSelfProxy: GenericPalletError<Rv>;
+    NoSelfProxy: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Multisig`'s errors
@@ -716,77 +716,77 @@ 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 when attempting to cancel.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Only the account that originally created the multisig is able to cancel it.
      **/
-    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 `Uniques`'s errors
@@ -795,97 +795,97 @@ 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 `StateTrieMigration`'s errors
@@ -894,7 +894,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.
@@ -905,32 +905,32 @@ 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 `ConvictionVoting`'s errors
@@ -939,68 +939,68 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Poll is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * The given account did not vote on the poll.
      **/
-    NotVoter: GenericPalletError<Rv>;
+    NotVoter: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action right now but will do in the future.
      **/
-    NoPermissionYet: GenericPalletError<Rv>;
+    NoPermissionYet: GenericPalletError;
 
     /**
      * The account is already delegating.
      **/
-    AlreadyDelegating: GenericPalletError<Rv>;
+    AlreadyDelegating: GenericPalletError;
 
     /**
      * The account currently has votes attached to it and the operation cannot succeed until
      * these are removed through `remove_vote`.
      **/
-    AlreadyVoting: GenericPalletError<Rv>;
+    AlreadyVoting: GenericPalletError;
 
     /**
      * Too high a balance was provided that the account cannot afford.
      **/
-    InsufficientFunds: GenericPalletError<Rv>;
+    InsufficientFunds: GenericPalletError;
 
     /**
      * The account is not currently delegating.
      **/
-    NotDelegating: GenericPalletError<Rv>;
+    NotDelegating: GenericPalletError;
 
     /**
      * Delegation to oneself makes no sense.
      **/
-    Nonsense: GenericPalletError<Rv>;
+    Nonsense: GenericPalletError;
 
     /**
      * Maximum number of votes reached.
      **/
-    MaxVotesReached: GenericPalletError<Rv>;
+    MaxVotesReached: GenericPalletError;
 
     /**
      * The class must be supplied since it is not easily determinable from the state.
      **/
-    ClassNeeded: GenericPalletError<Rv>;
+    ClassNeeded: GenericPalletError;
 
     /**
      * The class ID supplied is invalid.
      **/
-    BadClass: GenericPalletError<Rv>;
+    BadClass: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Referenda`'s errors
@@ -1009,77 +1009,77 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Referendum is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * Referendum's decision deposit is already paid.
      **/
-    HasDeposit: GenericPalletError<Rv>;
+    HasDeposit: GenericPalletError;
 
     /**
      * The track identifier given was invalid.
      **/
-    BadTrack: GenericPalletError<Rv>;
+    BadTrack: GenericPalletError;
 
     /**
      * There are already a full complement of referenda in progress for this track.
      **/
-    Full: GenericPalletError<Rv>;
+    Full: GenericPalletError;
 
     /**
      * The queue of the track is empty.
      **/
-    QueueEmpty: GenericPalletError<Rv>;
+    QueueEmpty: GenericPalletError;
 
     /**
      * The referendum index provided is invalid in this context.
      **/
-    BadReferendum: GenericPalletError<Rv>;
+    BadReferendum: GenericPalletError;
 
     /**
      * There was nothing to do in the advancement.
      **/
-    NothingToDo: GenericPalletError<Rv>;
+    NothingToDo: GenericPalletError;
 
     /**
      * No track exists for the proposal origin.
      **/
-    NoTrack: GenericPalletError<Rv>;
+    NoTrack: GenericPalletError;
 
     /**
      * Any deposit cannot be refunded until after the decision is over.
      **/
-    Unfinished: GenericPalletError<Rv>;
+    Unfinished: GenericPalletError;
 
     /**
      * The deposit refunder is not the depositor.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The deposit cannot be refunded since none was made.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The referendum status is invalid for this operation.
      **/
-    BadStatus: GenericPalletError<Rv>;
+    BadStatus: GenericPalletError;
 
     /**
      * The preimage does not exist.
      **/
-    PreimageNotExist: GenericPalletError<Rv>;
+    PreimageNotExist: GenericPalletError;
 
     /**
      * The preimage is stored with a different length than the one provided.
      **/
-    PreimageStoredWithDifferentLength: GenericPalletError<Rv>;
+    PreimageStoredWithDifferentLength: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Whitelist`'s errors
@@ -1088,32 +1088,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The preimage of the call hash could not be loaded.
      **/
-    UnavailablePreImage: GenericPalletError<Rv>;
+    UnavailablePreImage: GenericPalletError;
 
     /**
      * The call could not be decoded.
      **/
-    UndecodableCall: GenericPalletError<Rv>;
+    UndecodableCall: GenericPalletError;
 
     /**
      * The weight of the decoded call was higher than the witness.
      **/
-    InvalidCallWeightWitness: GenericPalletError<Rv>;
+    InvalidCallWeightWitness: GenericPalletError;
 
     /**
      * The call was not whitelisted.
      **/
-    CallIsNotWhitelisted: GenericPalletError<Rv>;
+    CallIsNotWhitelisted: GenericPalletError;
 
     /**
      * The call was already whitelisted; No-Op.
      **/
-    CallAlreadyWhitelisted: GenericPalletError<Rv>;
+    CallAlreadyWhitelisted: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Dispatcher`'s errors
@@ -1123,17 +1123,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The EVM call execution failed. This happens when the EVM returns an exit reason
      * other than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`.
      **/
-    EvmCallFailed: GenericPalletError<Rv>;
+    EvmCallFailed: GenericPalletError;
 
     /**
      * The provided call is not an EVM call. This extrinsic only accepts `pallet_evm::Call::call`.
      **/
-    NotEvmCall: GenericPalletError<Rv>;
+    NotEvmCall: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AssetRegistry`'s errors
@@ -1142,82 +1142,82 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Asset ID is not available. This only happens when it reaches the MAX value of given id type.
      **/
-    NoIdAvailable: GenericPalletError<Rv>;
+    NoIdAvailable: GenericPalletError;
 
     /**
      * Invalid asset name or symbol.
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * Length of name or symbol is less than min. length.
      **/
-    TooShort: GenericPalletError<Rv>;
+    TooShort: GenericPalletError;
 
     /**
      * Asset's symbol can't contain whitespace characters .
      **/
-    InvalidSymbol: GenericPalletError<Rv>;
+    InvalidSymbol: GenericPalletError;
 
     /**
      * Asset ID is not registered in the asset-registry.
      **/
-    AssetNotRegistered: GenericPalletError<Rv>;
+    AssetNotRegistered: GenericPalletError;
 
     /**
      * Asset is already registered.
      **/
-    AssetAlreadyRegistered: GenericPalletError<Rv>;
+    AssetAlreadyRegistered: GenericPalletError;
 
     /**
      * Incorrect number of assets provided to create shared asset.
      **/
-    InvalidSharedAssetLen: GenericPalletError<Rv>;
+    InvalidSharedAssetLen: GenericPalletError;
 
     /**
      * Cannot update asset location.
      **/
-    CannotUpdateLocation: GenericPalletError<Rv>;
+    CannotUpdateLocation: GenericPalletError;
 
     /**
      * Selected asset id is out of reserved range.
      **/
-    NotInReservedRange: GenericPalletError<Rv>;
+    NotInReservedRange: GenericPalletError;
 
     /**
      * Location already registered with different asset.
      **/
-    LocationAlreadyRegistered: GenericPalletError<Rv>;
+    LocationAlreadyRegistered: GenericPalletError;
 
     /**
      * Origin is forbidden to set/update value.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Balance too low.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Sufficient assets can't be changed to insufficient.
      **/
-    ForbiddenSufficiencyChange: GenericPalletError<Rv>;
+    ForbiddenSufficiencyChange: GenericPalletError;
 
     /**
      * Asset is already banned.
      **/
-    AssetAlreadyBanned: GenericPalletError<Rv>;
+    AssetAlreadyBanned: GenericPalletError;
 
     /**
      * Asset is not banned.
      **/
-    AssetNotBanned: GenericPalletError<Rv>;
+    AssetNotBanned: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Claims`'s errors
@@ -1226,22 +1226,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Ethereum signature is not valid
      **/
-    InvalidEthereumSignature: GenericPalletError<Rv>;
+    InvalidEthereumSignature: GenericPalletError;
 
     /**
      * Claim is not valid
      **/
-    NoClaimOrAlreadyClaimed: GenericPalletError<Rv>;
+    NoClaimOrAlreadyClaimed: GenericPalletError;
 
     /**
      * Value reached maximum and cannot be incremented further
      **/
-    BalanceOverflow: GenericPalletError<Rv>;
+    BalanceOverflow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CollatorRewards`'s errors
@@ -1250,7 +1250,7 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Omnipool`'s errors
@@ -1259,167 +1259,167 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Balance too low
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Asset is already in omnipool
      **/
-    AssetAlreadyAdded: GenericPalletError<Rv>;
+    AssetAlreadyAdded: GenericPalletError;
 
     /**
      * Asset is not in omnipool
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * Failed to add token to Omnipool due to insufficient initial liquidity.
      **/
-    MissingBalance: GenericPalletError<Rv>;
+    MissingBalance: GenericPalletError;
 
     /**
      * Invalid initial asset price.
      **/
-    InvalidInitialAssetPrice: GenericPalletError<Rv>;
+    InvalidInitialAssetPrice: GenericPalletError;
 
     /**
      * Slippage protection - minimum limit has not been reached.
      **/
-    BuyLimitNotReached: GenericPalletError<Rv>;
+    BuyLimitNotReached: GenericPalletError;
 
     /**
      * Slippage protection - maximum limit has been exceeded.
      **/
-    SellLimitExceeded: GenericPalletError<Rv>;
+    SellLimitExceeded: GenericPalletError;
 
     /**
      * Position has not been found.
      **/
-    PositionNotFound: GenericPalletError<Rv>;
+    PositionNotFound: GenericPalletError;
 
     /**
      * Insufficient shares in position
      **/
-    InsufficientShares: GenericPalletError<Rv>;
+    InsufficientShares: GenericPalletError;
 
     /**
      * Asset is not allowed to be traded.
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * Signed account is not owner of position instance.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Asset weight cap has been exceeded.
      **/
-    AssetWeightCapExceeded: GenericPalletError<Rv>;
+    AssetWeightCapExceeded: GenericPalletError;
 
     /**
      * Asset is not registered in asset registry
      **/
-    AssetNotRegistered: GenericPalletError<Rv>;
+    AssetNotRegistered: GenericPalletError;
 
     /**
      * Provided liquidity is below minimum allowed limit
      **/
-    InsufficientLiquidity: GenericPalletError<Rv>;
+    InsufficientLiquidity: GenericPalletError;
 
     /**
      * Traded amount is below minimum allowed limit
      **/
-    InsufficientTradingAmount: GenericPalletError<Rv>;
+    InsufficientTradingAmount: GenericPalletError;
 
     /**
      * Sell or buy with same asset ids is not allowed.
      **/
-    SameAssetTradeNotAllowed: GenericPalletError<Rv>;
+    SameAssetTradeNotAllowed: GenericPalletError;
 
     /**
      * LRNA update after trade results in positive value.
      **/
-    HubAssetUpdateError: GenericPalletError<Rv>;
+    HubAssetUpdateError: GenericPalletError;
 
     /**
      * Amount of shares provided cannot be 0.
      **/
-    InvalidSharesAmount: GenericPalletError<Rv>;
+    InvalidSharesAmount: GenericPalletError;
 
     /**
      * Hub asset is only allowed to be sold.
      **/
-    InvalidHubAssetTradableState: GenericPalletError<Rv>;
+    InvalidHubAssetTradableState: GenericPalletError;
 
     /**
      * Asset is not allowed to be refunded.
      **/
-    AssetRefundNotAllowed: GenericPalletError<Rv>;
+    AssetRefundNotAllowed: GenericPalletError;
 
     /**
      * Max fraction of asset to buy has been exceeded.
      **/
-    MaxOutRatioExceeded: GenericPalletError<Rv>;
+    MaxOutRatioExceeded: GenericPalletError;
 
     /**
      * Max fraction of asset to sell has been exceeded.
      **/
-    MaxInRatioExceeded: GenericPalletError<Rv>;
+    MaxInRatioExceeded: GenericPalletError;
 
     /**
      * Max allowed price difference has been exceeded.
      **/
-    PriceDifferenceTooHigh: GenericPalletError<Rv>;
+    PriceDifferenceTooHigh: GenericPalletError;
 
     /**
      * Invalid oracle price - division by zero.
      **/
-    InvalidOraclePrice: GenericPalletError<Rv>;
+    InvalidOraclePrice: GenericPalletError;
 
     /**
      * Failed to calculate withdrawal fee.
      **/
-    InvalidWithdrawalFee: GenericPalletError<Rv>;
+    InvalidWithdrawalFee: GenericPalletError;
 
     /**
      * More than allowed amount of fee has been transferred.
      **/
-    FeeOverdraft: GenericPalletError<Rv>;
+    FeeOverdraft: GenericPalletError;
 
     /**
      * Token cannot be removed from Omnipool due to shares still owned by other users.
      **/
-    SharesRemaining: GenericPalletError<Rv>;
+    SharesRemaining: GenericPalletError;
 
     /**
      * Token cannot be removed from Omnipool because asset is not frozen.
      **/
-    AssetNotFrozen: GenericPalletError<Rv>;
+    AssetNotFrozen: GenericPalletError;
 
     /**
      * Calculated amount out from sell trade is zero.
      **/
-    ZeroAmountOut: GenericPalletError<Rv>;
+    ZeroAmountOut: GenericPalletError;
 
     /**
      * Existential deposit of asset is not available.
      **/
-    ExistentialDepositNotAvailable: GenericPalletError<Rv>;
+    ExistentialDepositNotAvailable: GenericPalletError;
 
     /**
      * Slippage protection
      **/
-    SlippageLimit: GenericPalletError<Rv>;
+    SlippageLimit: GenericPalletError;
 
     /**
      * Extra protocol fee has not been consumed.
      **/
-    ProtocolFeeNotConsumed: GenericPalletError<Rv>;
+    ProtocolFeeNotConsumed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `TransactionPause`'s errors
@@ -1428,22 +1428,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * can not pause
      **/
-    CannotPause: GenericPalletError<Rv>;
+    CannotPause: GenericPalletError;
 
     /**
      * invalid character encoding
      **/
-    InvalidCharacter: GenericPalletError<Rv>;
+    InvalidCharacter: GenericPalletError;
 
     /**
      * pallet name or function name is too long
      **/
-    NameTooLong: GenericPalletError<Rv>;
+    NameTooLong: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Duster`'s errors
@@ -1452,37 +1452,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account is excluded from dusting.
      **/
-    AccountBlacklisted: GenericPalletError<Rv>;
+    AccountWhitelisted: GenericPalletError;
 
     /**
      * Account is not present in the non-dustable list.
      **/
-    AccountNotBlacklisted: GenericPalletError<Rv>;
+    AccountNotWhitelisted: GenericPalletError;
 
     /**
      * The balance is zero.
      **/
-    ZeroBalance: GenericPalletError<Rv>;
+    ZeroBalance: GenericPalletError;
 
     /**
-     * The balance is sufficient to keep account open.
+     * The balance was not fully dusted, there is some leftover on the account. Normally, it should never happen.
      **/
-    BalanceSufficient: GenericPalletError<Rv>;
+    NonZeroBalance: GenericPalletError;
 
     /**
-     * Dust account is not set.
+     * The balance is sufficient to keep account open.
      **/
-    DustAccountNotSet: GenericPalletError<Rv>;
+    BalanceSufficient: GenericPalletError;
 
     /**
      * Reserve account is not set.
      **/
-    ReserveAccountNotSet: GenericPalletError<Rv>;
+    ReserveAccountNotSet: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OmnipoolWarehouseLM`'s errors
@@ -1491,154 +1491,154 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Global farm does not exist.
      **/
-    GlobalFarmNotFound: GenericPalletError<Rv>;
+    GlobalFarmNotFound: GenericPalletError;
 
     /**
      * Yield farm does not exist.
      **/
-    YieldFarmNotFound: GenericPalletError<Rv>;
+    YieldFarmNotFound: GenericPalletError;
 
     /**
      * Multiple claims in the same period is not allowed.
      **/
-    DoubleClaimInPeriod: GenericPalletError<Rv>;
+    DoubleClaimInPeriod: GenericPalletError;
 
     /**
      * Liquidity mining is canceled.
      **/
-    LiquidityMiningCanceled: GenericPalletError<Rv>;
+    LiquidityMiningCanceled: GenericPalletError;
 
     /**
      * Liquidity mining is not canceled.
      **/
-    LiquidityMiningIsActive: GenericPalletError<Rv>;
+    LiquidityMiningIsActive: GenericPalletError;
 
     /**
      * Liquidity mining is in `active` or `terminated` state and action cannot be completed.
      **/
-    LiquidityMiningIsNotStopped: GenericPalletError<Rv>;
+    LiquidityMiningIsNotStopped: GenericPalletError;
 
     /**
      * Account is not allowed to perform action.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Yield farm multiplier can't be 0.
      **/
-    InvalidMultiplier: GenericPalletError<Rv>;
+    InvalidMultiplier: GenericPalletError;
 
     /**
      * Yield farm with given `amm_pool_id` already exists in global farm.
      **/
-    YieldFarmAlreadyExists: GenericPalletError<Rv>;
+    YieldFarmAlreadyExists: GenericPalletError;
 
     /**
      * Loyalty curve's initial reward percentage is not valid. Valid range is: [0, 1).
      **/
-    InvalidInitialRewardPercentage: GenericPalletError<Rv>;
+    InvalidInitialRewardPercentage: GenericPalletError;
 
     /**
      * One or more yield farms exist in global farm.
      **/
-    GlobalFarmIsNotEmpty: GenericPalletError<Rv>;
+    GlobalFarmIsNotEmpty: GenericPalletError;
 
     /**
      * Farm's `incentivized_asset` is missing in provided asset pair.
      **/
-    MissingIncentivizedAsset: GenericPalletError<Rv>;
+    MissingIncentivizedAsset: GenericPalletError;
 
     /**
      * Reward currency balance is not sufficient.
      **/
-    InsufficientRewardCurrencyBalance: GenericPalletError<Rv>;
+    InsufficientRewardCurrencyBalance: GenericPalletError;
 
     /**
      * Blocks per period can't be 0.
      **/
-    InvalidBlocksPerPeriod: GenericPalletError<Rv>;
+    InvalidBlocksPerPeriod: GenericPalletError;
 
     /**
      * Yield per period can't be 0.
      **/
-    InvalidYieldPerPeriod: GenericPalletError<Rv>;
+    InvalidYieldPerPeriod: GenericPalletError;
 
     /**
      * Total rewards is less than `MinTotalFarmRewards`.
      **/
-    InvalidTotalRewards: GenericPalletError<Rv>;
+    InvalidTotalRewards: GenericPalletError;
 
     /**
      * Planned yielding periods is less than `MinPlannedYieldingPeriods`.
      **/
-    InvalidPlannedYieldingPeriods: GenericPalletError<Rv>;
+    InvalidPlannedYieldingPeriods: GenericPalletError;
 
     /**
      * Maximum number of locks reached for deposit.
      **/
-    MaxEntriesPerDeposit: GenericPalletError<Rv>;
+    MaxEntriesPerDeposit: GenericPalletError;
 
     /**
      * Trying to lock LP shares into already locked yield farm.
      **/
-    DoubleLock: GenericPalletError<Rv>;
+    DoubleLock: GenericPalletError;
 
     /**
      * Yield farm entry doesn't exist for given deposit.
      **/
-    YieldFarmEntryNotFound: GenericPalletError<Rv>;
+    YieldFarmEntryNotFound: GenericPalletError;
 
     /**
      * Max number of yield farms in global farm was reached. Global farm can't accept new
      * yield farms until some yield farm is not removed from storage.
      **/
-    GlobalFarmIsFull: GenericPalletError<Rv>;
+    GlobalFarmIsFull: GenericPalletError;
 
     /**
      * Invalid min. deposit was set for global farm.
      **/
-    InvalidMinDeposit: GenericPalletError<Rv>;
+    InvalidMinDeposit: GenericPalletError;
 
     /**
      * Price adjustment multiplier can't be 0.
      **/
-    InvalidPriceAdjustment: GenericPalletError<Rv>;
+    InvalidPriceAdjustment: GenericPalletError;
 
     /**
      * Account creation from id failed.
      **/
-    ErrorGetAccountId: GenericPalletError<Rv>;
+    ErrorGetAccountId: GenericPalletError;
 
     /**
      * Value of deposited shares amount in reward currency is bellow min. limit.
      **/
-    IncorrectValuedShares: GenericPalletError<Rv>;
+    IncorrectValuedShares: GenericPalletError;
 
     /**
      * `reward_currency` is not registered in asset registry.
      **/
-    RewardCurrencyNotRegistered: GenericPalletError<Rv>;
+    RewardCurrencyNotRegistered: GenericPalletError;
 
     /**
      * `incentivized_asset` is not registered in asset registry.
      **/
-    IncentivizedAssetNotRegistered: GenericPalletError<Rv>;
+    IncentivizedAssetNotRegistered: GenericPalletError;
 
     /**
      * Provided `amm_pool_id` doesn't match deposit's `amm_pool_id`.
      **/
-    AmmPoolIdMismatch: GenericPalletError<Rv>;
+    AmmPoolIdMismatch: GenericPalletError;
 
     /**
      * Action cannot be completed because unexpected error has occurred. This should be reported
      * to protocol maintainers.
      **/
-    InconsistentState: GenericPalletError<Rv>;
+    InconsistentState: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OmnipoolLiquidityMining`'s errors
@@ -1647,43 +1647,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Asset is not in the omnipool.
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * Signed account is not owner of the deposit.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Rewards to claim are 0.
      **/
-    ZeroClaimedRewards: GenericPalletError<Rv>;
+    ZeroClaimedRewards: GenericPalletError;
 
     /**
      * Action cannot be completed because unexpected error has occurred. This should be reported
      * to protocol maintainers.
      **/
-    InconsistentState: GenericPalletError<Rv>;
+    InconsistentState: GenericPalletError;
 
     /**
      * Oracle could not be found for requested assets.
      **/
-    OracleNotAvailable: GenericPalletError<Rv>;
+    OracleNotAvailable: GenericPalletError;
 
     /**
      * Oracle providing `price_adjustment` could not be found for requested assets.
      **/
-    PriceAdjustmentNotAvailable: GenericPalletError<Rv>;
+    PriceAdjustmentNotAvailable: GenericPalletError;
 
     /**
      * No farms specified to join
      **/
-    NoFarmEntriesSpecified: GenericPalletError<Rv>;
+    NoFarmEntriesSpecified: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OTC`'s errors
@@ -1692,49 +1692,49 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Asset does not exist in registry
      **/
-    AssetNotRegistered: GenericPalletError<Rv>;
+    AssetNotRegistered: GenericPalletError;
 
     /**
      * Order cannot be found
      **/
-    OrderNotFound: GenericPalletError<Rv>;
+    OrderNotFound: GenericPalletError;
 
     /**
      * Size of order ID exceeds the bound
      **/
-    OrderIdOutOfBound: GenericPalletError<Rv>;
+    OrderIdOutOfBound: GenericPalletError;
 
     /**
      * Cannot partially fill an order which is not partially fillable
      **/
-    OrderNotPartiallyFillable: GenericPalletError<Rv>;
+    OrderNotPartiallyFillable: GenericPalletError;
 
     /**
      * Order amount_in and amount_out must at all times be greater than the existential deposit
      * for the asset multiplied by the ExistentialDepositMultiplier.
      * A fill order may not leave behind amounts smaller than this.
      **/
-    OrderAmountTooSmall: GenericPalletError<Rv>;
+    OrderAmountTooSmall: GenericPalletError;
 
     /**
      * Error with math calculations
      **/
-    MathError: GenericPalletError<Rv>;
+    MathError: GenericPalletError;
 
     /**
      * The caller does not have permission to complete the action
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Reserved amount not sufficient.
      **/
-    InsufficientReservedAmount: GenericPalletError<Rv>;
+    InsufficientReservedAmount: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CircuitBreaker`'s errors
@@ -1743,54 +1743,54 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid value for a limit. Limit must be non-zero.
      **/
-    InvalidLimitValue: GenericPalletError<Rv>;
+    InvalidLimitValue: GenericPalletError;
 
     /**
      * Allowed liquidity limit is not stored for asset
      **/
-    LiquidityLimitNotStoredForAsset: GenericPalletError<Rv>;
+    LiquidityLimitNotStoredForAsset: GenericPalletError;
 
     /**
      * Token trade outflow per block has been reached
      **/
-    TokenOutflowLimitReached: GenericPalletError<Rv>;
+    TokenOutflowLimitReached: GenericPalletError;
 
     /**
      * Token trade influx per block has been reached
      **/
-    TokenInfluxLimitReached: GenericPalletError<Rv>;
+    TokenInfluxLimitReached: GenericPalletError;
 
     /**
      * Maximum pool's liquidity limit per block has been reached
      **/
-    MaxLiquidityLimitPerBlockReached: GenericPalletError<Rv>;
+    MaxLiquidityLimitPerBlockReached: GenericPalletError;
 
     /**
      * Asset is not allowed to have a limit
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * Asset still in lockdown as it reached the allowed deposit limit for the period
      * Query the `asset_lockdown_state` storage to determine until which block the asset is locked,
      * so that the deposit can be released afterward.
      **/
-    AssetInLockdown: GenericPalletError<Rv>;
+    AssetInLockdown: GenericPalletError;
 
     /**
      * Asset is not in a lockdown
      **/
-    AssetNotInLockdown: GenericPalletError<Rv>;
+    AssetNotInLockdown: GenericPalletError;
 
     /**
      * Invalid amount to save deposit
      **/
-    InvalidAmount: GenericPalletError<Rv>;
+    InvalidAmount: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Router`'s errors
@@ -1799,57 +1799,57 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The trading limit has been reached
      **/
-    TradingLimitReached: GenericPalletError<Rv>;
+    TradingLimitReached: GenericPalletError;
 
     /**
      * The the max number of trades limit is reached
      **/
-    MaxTradesExceeded: GenericPalletError<Rv>;
+    MaxTradesExceeded: GenericPalletError;
 
     /**
      * The AMM pool is not supported for executing trades
      **/
-    PoolNotSupported: GenericPalletError<Rv>;
+    PoolNotSupported: GenericPalletError;
 
     /**
      * The user has not enough balance to execute the trade
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * The calculation of route trade amounts failed in the underlying AMM
      **/
-    RouteCalculationFailed: GenericPalletError<Rv>;
+    RouteCalculationFailed: GenericPalletError;
 
     /**
      * The route is invalid
      **/
-    InvalidRoute: GenericPalletError<Rv>;
+    InvalidRoute: GenericPalletError;
 
     /**
      * The route update was not successful
      **/
-    RouteUpdateIsNotSuccessful: GenericPalletError<Rv>;
+    RouteUpdateIsNotSuccessful: GenericPalletError;
 
     /**
      * Route contains assets that has no oracle data
      **/
-    RouteHasNoOracle: GenericPalletError<Rv>;
+    RouteHasNoOracle: GenericPalletError;
 
     /**
      * The route execution failed in the underlying AMM
      **/
-    InvalidRouteExecution: GenericPalletError<Rv>;
+    InvalidRouteExecution: GenericPalletError;
 
     /**
      * Trading same assets is not allowed.
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `DynamicFees`'s errors
@@ -1858,12 +1858,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid fee parameters provided
      **/
-    InvalidFeeParameters: GenericPalletError<Rv>;
+    InvalidFeeParameters: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Staking`'s errors
@@ -1872,73 +1872,73 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Balance is too low.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Staked amount is too low.
      **/
-    InsufficientStake: GenericPalletError<Rv>;
+    InsufficientStake: GenericPalletError;
 
     /**
      * Staking position has not been found.
      **/
-    PositionNotFound: GenericPalletError<Rv>;
+    PositionNotFound: GenericPalletError;
 
     /**
      * Maximum amount of votes were reached for staking position.
      **/
-    MaxVotesReached: GenericPalletError<Rv>;
+    MaxVotesReached: GenericPalletError;
 
     /**
      * Staking is not initialized.
      **/
-    NotInitialized: GenericPalletError<Rv>;
+    NotInitialized: GenericPalletError;
 
     /**
      * Staking is already initialized.
      **/
-    AlreadyInitialized: GenericPalletError<Rv>;
+    AlreadyInitialized: GenericPalletError;
 
     /**
      * Arithmetic error.
      **/
-    Arithmetic: GenericPalletError<Rv>;
+    Arithmetic: GenericPalletError;
 
     /**
      * Pot's balance is zero.
      **/
-    MissingPotBalance: GenericPalletError<Rv>;
+    MissingPotBalance: GenericPalletError;
 
     /**
      * Account's position already exists.
      **/
-    PositionAlreadyExists: GenericPalletError<Rv>;
+    PositionAlreadyExists: GenericPalletError;
 
     /**
      * Signer is not an owner of the staking position.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Position contains registered votes.
      **/
-    ExistingVotes: GenericPalletError<Rv>;
+    ExistingVotes: GenericPalletError;
 
     /**
      * Position contains processed votes. Removed these votes first before increasing stake or claiming.
      **/
-    ExistingProcessedVotes: GenericPalletError<Rv>;
+    ExistingProcessedVotes: GenericPalletError;
 
     /**
      * Action cannot be completed because unexpected error has occurred. This should be reported
      * to protocol maintainers.
      **/
-    InconsistentState: GenericPalletError<Rv>;
+    InconsistentState: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Stableswap`'s errors
@@ -1947,147 +1947,147 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Creating a pool with same assets or less than 2 assets is not allowed.
      **/
-    IncorrectAssets: GenericPalletError<Rv>;
+    IncorrectAssets: GenericPalletError;
 
     /**
      * Maximum number of assets has been exceeded.
      **/
-    MaxAssetsExceeded: GenericPalletError<Rv>;
+    MaxAssetsExceeded: GenericPalletError;
 
     /**
      * A pool with given assets does not exist.
      **/
-    PoolNotFound: GenericPalletError<Rv>;
+    PoolNotFound: GenericPalletError;
 
     /**
      * A pool with given assets already exists.
      **/
-    PoolExists: GenericPalletError<Rv>;
+    PoolExists: GenericPalletError;
 
     /**
      * Asset is not in the pool.
      **/
-    AssetNotInPool: GenericPalletError<Rv>;
+    AssetNotInPool: GenericPalletError;
 
     /**
      * Share asset is not registered in Registry.
      **/
-    ShareAssetNotRegistered: GenericPalletError<Rv>;
+    ShareAssetNotRegistered: GenericPalletError;
 
     /**
      * Share asset is amount assets when creating a pool.
      **/
-    ShareAssetInPoolAssets: GenericPalletError<Rv>;
+    ShareAssetInPoolAssets: GenericPalletError;
 
     /**
      * One or more assets are not registered in AssetRegistry
      **/
-    AssetNotRegistered: GenericPalletError<Rv>;
+    AssetNotRegistered: GenericPalletError;
 
     /**
      * Invalid asset amount provided. Amount must be greater than zero.
      **/
-    InvalidAssetAmount: GenericPalletError<Rv>;
+    InvalidAssetAmount: GenericPalletError;
 
     /**
      * Balance of an asset is not sufficient to perform a trade.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Balance of a share asset is not sufficient to withdraw liquidity.
      **/
-    InsufficientShares: GenericPalletError<Rv>;
+    InsufficientShares: GenericPalletError;
 
     /**
      * Liquidity has not reached the required minimum.
      **/
-    InsufficientLiquidity: GenericPalletError<Rv>;
+    InsufficientLiquidity: GenericPalletError;
 
     /**
      * Insufficient liquidity left in the pool after withdrawal.
      **/
-    InsufficientLiquidityRemaining: GenericPalletError<Rv>;
+    InsufficientLiquidityRemaining: GenericPalletError;
 
     /**
      * Amount is less than the minimum trading amount configured.
      **/
-    InsufficientTradingAmount: GenericPalletError<Rv>;
+    InsufficientTradingAmount: GenericPalletError;
 
     /**
      * Minimum limit has not been reached during trade.
      **/
-    BuyLimitNotReached: GenericPalletError<Rv>;
+    BuyLimitNotReached: GenericPalletError;
 
     /**
      * Maximum limit has been exceeded during trade.
      **/
-    SellLimitExceeded: GenericPalletError<Rv>;
+    SellLimitExceeded: GenericPalletError;
 
     /**
      * Initial liquidity of asset must be > 0.
      **/
-    InvalidInitialLiquidity: GenericPalletError<Rv>;
+    InvalidInitialLiquidity: GenericPalletError;
 
     /**
      * Amplification is outside configured range.
      **/
-    InvalidAmplification: GenericPalletError<Rv>;
+    InvalidAmplification: GenericPalletError;
 
     /**
      * Remaining balance of share asset is below asset's existential deposit.
      **/
-    InsufficientShareBalance: GenericPalletError<Rv>;
+    InsufficientShareBalance: GenericPalletError;
 
     /**
      * Not allowed to perform an operation on given asset.
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * Future block number is in the past.
      **/
-    PastBlock: GenericPalletError<Rv>;
+    PastBlock: GenericPalletError;
 
     /**
      * New amplification is equal to the previous value.
      **/
-    SameAmplification: GenericPalletError<Rv>;
+    SameAmplification: GenericPalletError;
 
     /**
      * Slippage protection.
      **/
-    SlippageLimit: GenericPalletError<Rv>;
+    SlippageLimit: GenericPalletError;
 
     /**
      * Failed to retrieve asset decimals.
      **/
-    UnknownDecimals: GenericPalletError<Rv>;
+    UnknownDecimals: GenericPalletError;
 
     /**
      * List of provided pegs is incorrect.
      **/
-    IncorrectInitialPegs: GenericPalletError<Rv>;
+    IncorrectInitialPegs: GenericPalletError;
 
     /**
      * Failed to retrieve oracle entry.
      **/
-    MissingTargetPegOracle: GenericPalletError<Rv>;
+    MissingTargetPegOracle: GenericPalletError;
 
     /**
      * Creating pool with pegs is not allowed for asset with different decimals.
      **/
-    IncorrectAssetDecimals: GenericPalletError<Rv>;
+    IncorrectAssetDecimals: GenericPalletError;
 
     /**
      * Pool does not have pegs configured.
      **/
-    NoPegSource: GenericPalletError<Rv>;
+    NoPegSource: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Bonds`'s errors
@@ -2096,42 +2096,42 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Bond not registered
      **/
-    NotRegistered: GenericPalletError<Rv>;
+    NotRegistered: GenericPalletError;
 
     /**
      * Bond is not mature
      **/
-    NotMature: GenericPalletError<Rv>;
+    NotMature: GenericPalletError;
 
     /**
      * Maturity not long enough
      **/
-    InvalidMaturity: GenericPalletError<Rv>;
+    InvalidMaturity: GenericPalletError;
 
     /**
      * Asset type not allowed for underlying asset
      **/
-    DisallowedAsset: GenericPalletError<Rv>;
+    DisallowedAsset: GenericPalletError;
 
     /**
      * Asset is not registered in `AssetRegistry`
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * Generated name is not valid.
      **/
-    InvalidBondName: GenericPalletError<Rv>;
+    InvalidBondName: GenericPalletError;
 
     /**
      * Bond's name parsing was now successful
      **/
-    FailToParseName: GenericPalletError<Rv>;
+    FailToParseName: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OtcSettlements`'s errors
@@ -2140,42 +2140,42 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Otc order not found
      **/
-    OrderNotFound: GenericPalletError<Rv>;
+    OrderNotFound: GenericPalletError;
 
     /**
      * OTC order is not partially fillable
      **/
-    NotPartiallyFillable: GenericPalletError<Rv>;
+    NotPartiallyFillable: GenericPalletError;
 
     /**
      * Provided route doesn't match the existing route
      **/
-    InvalidRoute: GenericPalletError<Rv>;
+    InvalidRoute: GenericPalletError;
 
     /**
      * Initial and final balance are different
      **/
-    BalanceInconsistency: GenericPalletError<Rv>;
+    BalanceInconsistency: GenericPalletError;
 
     /**
      * Trade amount higher than necessary
      **/
-    TradeAmountTooHigh: GenericPalletError<Rv>;
+    TradeAmountTooHigh: GenericPalletError;
 
     /**
      * Trade amount lower than necessary
      **/
-    TradeAmountTooLow: GenericPalletError<Rv>;
+    TradeAmountTooLow: GenericPalletError;
 
     /**
      * Price for a route is not available
      **/
-    PriceNotAvailable: GenericPalletError<Rv>;
+    PriceNotAvailable: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `LBP`'s errors
@@ -2184,122 +2184,122 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Pool assets can not be the same
      **/
-    CannotCreatePoolWithSameAssets: GenericPalletError<Rv>;
+    CannotCreatePoolWithSameAssets: GenericPalletError;
 
     /**
      * Account is not a pool owner
      **/
-    NotOwner: GenericPalletError<Rv>;
+    NotOwner: GenericPalletError;
 
     /**
      * Sale already started
      **/
-    SaleStarted: GenericPalletError<Rv>;
+    SaleStarted: GenericPalletError;
 
     /**
      * Sale is still in progress
      **/
-    SaleNotEnded: GenericPalletError<Rv>;
+    SaleNotEnded: GenericPalletError;
 
     /**
      * Sale is not running
      **/
-    SaleIsNotRunning: GenericPalletError<Rv>;
+    SaleIsNotRunning: GenericPalletError;
 
     /**
      * Sale duration is too long
      **/
-    MaxSaleDurationExceeded: GenericPalletError<Rv>;
+    MaxSaleDurationExceeded: GenericPalletError;
 
     /**
      * Liquidity being added should not be zero
      **/
-    CannotAddZeroLiquidity: GenericPalletError<Rv>;
+    CannotAddZeroLiquidity: GenericPalletError;
 
     /**
      * Asset balance too low
      **/
-    InsufficientAssetBalance: GenericPalletError<Rv>;
+    InsufficientAssetBalance: GenericPalletError;
 
     /**
      * Pool does not exist
      **/
-    PoolNotFound: GenericPalletError<Rv>;
+    PoolNotFound: GenericPalletError;
 
     /**
      * Pool has been already created
      **/
-    PoolAlreadyExists: GenericPalletError<Rv>;
+    PoolAlreadyExists: GenericPalletError;
 
     /**
      * Invalid block range
      **/
-    InvalidBlockRange: GenericPalletError<Rv>;
+    InvalidBlockRange: GenericPalletError;
 
     /**
      * Calculation error
      **/
-    WeightCalculationError: GenericPalletError<Rv>;
+    WeightCalculationError: GenericPalletError;
 
     /**
      * Weight set is out of range
      **/
-    InvalidWeight: GenericPalletError<Rv>;
+    InvalidWeight: GenericPalletError;
 
     /**
      * Can not perform a trade with zero amount
      **/
-    ZeroAmount: GenericPalletError<Rv>;
+    ZeroAmount: GenericPalletError;
 
     /**
      * Trade amount is too high
      **/
-    MaxInRatioExceeded: GenericPalletError<Rv>;
+    MaxInRatioExceeded: GenericPalletError;
 
     /**
      * Trade amount is too high
      **/
-    MaxOutRatioExceeded: GenericPalletError<Rv>;
+    MaxOutRatioExceeded: GenericPalletError;
 
     /**
      * Invalid fee amount
      **/
-    FeeAmountInvalid: GenericPalletError<Rv>;
+    FeeAmountInvalid: GenericPalletError;
 
     /**
      * Trading limit reached
      **/
-    TradingLimitReached: GenericPalletError<Rv>;
+    TradingLimitReached: GenericPalletError;
 
     /**
      * An unexpected integer overflow occurred
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * Nothing to update
      **/
-    NothingToUpdate: GenericPalletError<Rv>;
+    NothingToUpdate: GenericPalletError;
 
     /**
      * Liquidity has not reached the required minimum.
      **/
-    InsufficientLiquidity: GenericPalletError<Rv>;
+    InsufficientLiquidity: GenericPalletError;
 
     /**
      * Amount is less than minimum trading limit.
      **/
-    InsufficientTradingAmount: GenericPalletError<Rv>;
+    InsufficientTradingAmount: GenericPalletError;
 
     /**
      * Not more than one fee collector per asset id
      **/
-    FeeCollectorWithAssetAlreadyUsed: GenericPalletError<Rv>;
+    FeeCollectorWithAssetAlreadyUsed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XYK`'s errors
@@ -2308,139 +2308,139 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * It is not allowed to create a pool between same assets.
      **/
-    CannotCreatePoolWithSameAssets: GenericPalletError<Rv>;
+    CannotCreatePoolWithSameAssets: GenericPalletError;
 
     /**
      * Liquidity has not reached the required minimum.
      **/
-    InsufficientLiquidity: GenericPalletError<Rv>;
+    InsufficientLiquidity: GenericPalletError;
 
     /**
      * Amount is less than min trading limit.
      **/
-    InsufficientTradingAmount: GenericPalletError<Rv>;
+    InsufficientTradingAmount: GenericPalletError;
 
     /**
      * Liquidity is zero.
      **/
-    ZeroLiquidity: GenericPalletError<Rv>;
+    ZeroLiquidity: GenericPalletError;
 
     /**
      * It is not allowed to create a pool with zero initial price.
      * Not used, kept for backward compatibility
      **/
-    ZeroInitialPrice: GenericPalletError<Rv>;
+    ZeroInitialPrice: GenericPalletError;
 
     /**
      * Overflow
      * Not used, kept for backward compatibility
      **/
-    CreatePoolAssetAmountInvalid: GenericPalletError<Rv>;
+    CreatePoolAssetAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    InvalidMintedLiquidity: GenericPalletError<Rv>;
+    InvalidMintedLiquidity: GenericPalletError;
 
     /**
      * Overflow
      **/
-    InvalidLiquidityAmount: GenericPalletError<Rv>;
+    InvalidLiquidityAmount: GenericPalletError;
 
     /**
      * Asset amount has exceeded given limit.
      **/
-    AssetAmountExceededLimit: GenericPalletError<Rv>;
+    AssetAmountExceededLimit: GenericPalletError;
 
     /**
      * Asset amount has not reached given limit.
      **/
-    AssetAmountNotReachedLimit: GenericPalletError<Rv>;
+    AssetAmountNotReachedLimit: GenericPalletError;
 
     /**
      * Asset balance is not sufficient.
      **/
-    InsufficientAssetBalance: GenericPalletError<Rv>;
+    InsufficientAssetBalance: GenericPalletError;
 
     /**
      * Not enough asset liquidity in the pool.
      **/
-    InsufficientPoolAssetBalance: GenericPalletError<Rv>;
+    InsufficientPoolAssetBalance: GenericPalletError;
 
     /**
      * Not enough core asset liquidity in the pool.
      **/
-    InsufficientNativeCurrencyBalance: GenericPalletError<Rv>;
+    InsufficientNativeCurrencyBalance: GenericPalletError;
 
     /**
      * Liquidity pool for given assets does not exist.
      **/
-    TokenPoolNotFound: GenericPalletError<Rv>;
+    TokenPoolNotFound: GenericPalletError;
 
     /**
      * Liquidity pool for given assets already exists.
      **/
-    TokenPoolAlreadyExists: GenericPalletError<Rv>;
+    TokenPoolAlreadyExists: GenericPalletError;
 
     /**
      * Overflow
      **/
-    AddAssetAmountInvalid: GenericPalletError<Rv>;
+    AddAssetAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    RemoveAssetAmountInvalid: GenericPalletError<Rv>;
+    RemoveAssetAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    SellAssetAmountInvalid: GenericPalletError<Rv>;
+    SellAssetAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    BuyAssetAmountInvalid: GenericPalletError<Rv>;
+    BuyAssetAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    FeeAmountInvalid: GenericPalletError<Rv>;
+    FeeAmountInvalid: GenericPalletError;
 
     /**
      * Overflow
      **/
-    CannotApplyDiscount: GenericPalletError<Rv>;
+    CannotApplyDiscount: GenericPalletError;
 
     /**
      * Max fraction of pool to buy in single transaction has been exceeded.
      **/
-    MaxOutRatioExceeded: GenericPalletError<Rv>;
+    MaxOutRatioExceeded: GenericPalletError;
 
     /**
      * Max fraction of pool to sell in single transaction has been exceeded.
      **/
-    MaxInRatioExceeded: GenericPalletError<Rv>;
+    MaxInRatioExceeded: GenericPalletError;
 
     /**
      * Overflow
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * Pool cannot be created due to outside factors.
      **/
-    CannotCreatePool: GenericPalletError<Rv>;
+    CannotCreatePool: GenericPalletError;
 
     /**
      * Slippage protection.
      **/
-    SlippageLimit: GenericPalletError<Rv>;
+    SlippageLimit: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Referrals`'s errors
@@ -2449,77 +2449,77 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Referral code is too long.
      **/
-    TooLong: GenericPalletError<Rv>;
+    TooLong: GenericPalletError;
 
     /**
      * Referral code is too short.
      **/
-    TooShort: GenericPalletError<Rv>;
+    TooShort: GenericPalletError;
 
     /**
      * Referral code contains invalid character. Only alphanumeric characters are allowed.
      **/
-    InvalidCharacter: GenericPalletError<Rv>;
+    InvalidCharacter: GenericPalletError;
 
     /**
      * Referral code already exists.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * Provided referral code is invalid. Either does not exist or is too long.
      **/
-    InvalidCode: GenericPalletError<Rv>;
+    InvalidCode: GenericPalletError;
 
     /**
      * Account is already linked to another referral account.
      **/
-    AlreadyLinked: GenericPalletError<Rv>;
+    AlreadyLinked: GenericPalletError;
 
     /**
      * Nothing in the referral pot account for the asset.
      **/
-    ZeroAmount: GenericPalletError<Rv>;
+    ZeroAmount: GenericPalletError;
 
     /**
      * Linking an account to the same referral account is not allowed.
      **/
-    LinkNotAllowed: GenericPalletError<Rv>;
+    LinkNotAllowed: GenericPalletError;
 
     /**
      * Calculated rewards are more than the fee amount. This can happen if percentages are incorrectly set.
      **/
-    IncorrectRewardCalculation: GenericPalletError<Rv>;
+    IncorrectRewardCalculation: GenericPalletError;
 
     /**
      * Given referrer and trader percentages exceeds 100% percent.
      **/
-    IncorrectRewardPercentage: GenericPalletError<Rv>;
+    IncorrectRewardPercentage: GenericPalletError;
 
     /**
      * The account has already a code registered.
      **/
-    AlreadyRegistered: GenericPalletError<Rv>;
+    AlreadyRegistered: GenericPalletError;
 
     /**
      * Price for given asset pair not found.
      **/
-    PriceNotFound: GenericPalletError<Rv>;
+    PriceNotFound: GenericPalletError;
 
     /**
      * Minimum trading amount for conversion has not been reached.
      **/
-    ConversionMinTradingAmountNotReached: GenericPalletError<Rv>;
+    ConversionMinTradingAmountNotReached: GenericPalletError;
 
     /**
      * Zero amount received from conversion.
      **/
-    ConversionZeroAmountReceived: GenericPalletError<Rv>;
+    ConversionZeroAmountReceived: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Liquidation`'s errors
@@ -2528,37 +2528,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * AssetId to EVM address conversion failed
      **/
-    AssetConversionFailed: GenericPalletError<Rv>;
+    AssetConversionFailed: GenericPalletError;
 
     /**
      * Liquidation call failed
      **/
-    LiquidationCallFailed: GenericPalletError<Rv>;
+    LiquidationCallFailed: GenericPalletError;
 
     /**
      * Provided route doesn't match the existing route
      **/
-    InvalidRoute: GenericPalletError<Rv>;
+    InvalidRoute: GenericPalletError;
 
     /**
      * Liquidation was not profitable enough to repay flash loan
      **/
-    NotProfitable: GenericPalletError<Rv>;
+    NotProfitable: GenericPalletError;
 
     /**
      * Flash minter contract address not set. It is required for Hollar liquidations.
      **/
-    FlashMinterNotSet: GenericPalletError<Rv>;
+    FlashMinterNotSet: GenericPalletError;
 
     /**
      * Invalid liquidation data provided
      **/
-    InvalidLiquidationData: GenericPalletError<Rv>;
+    InvalidLiquidationData: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `HSM`'s errors
@@ -2569,153 +2569,146 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      *
      * The operation attempted to use an asset that is not registered as an approved collateral.
      **/
-    AssetNotApproved: GenericPalletError<Rv>;
+    AssetNotApproved: GenericPalletError;
 
     /**
      * Asset is already approved as collateral
      *
      * Attempted to add an asset that is already registered as a collateral.
      **/
-    AssetAlreadyApproved: GenericPalletError<Rv>;
+    AssetAlreadyApproved: GenericPalletError;
 
     /**
      * Another asset from the same pool is already approved
      *
      * Only one asset from each StableSwap pool can be used as collateral.
      **/
-    PoolAlreadyHasCollateral: GenericPalletError<Rv>;
+    PoolAlreadyHasCollateral: GenericPalletError;
 
     /**
      * Invalid asset pair, must be Hollar and approved collateral
      *
      * The asset pair for buy/sell operations must include Hollar as one side and an approved collateral as the other.
      **/
-    InvalidAssetPair: GenericPalletError<Rv>;
+    InvalidAssetPair: GenericPalletError;
 
     /**
      * Max buy price exceeded
      *
      * The calculated buy price exceeds the maximum allowed buy price for the collateral.
      **/
-    MaxBuyPriceExceeded: GenericPalletError<Rv>;
+    MaxBuyPriceExceeded: GenericPalletError;
 
     /**
      * Max buy back amount in single block exceeded
      *
      * The amount of Hollar being sold to HSM exceeds the maximum allowed in a single block for this collateral.
      **/
-    MaxBuyBackExceeded: GenericPalletError<Rv>;
+    MaxBuyBackExceeded: GenericPalletError;
 
     /**
      * Max holding amount for collateral exceeded
      *
      * The operation would cause the HSM to hold more of the collateral than the configured maximum.
      **/
-    MaxHoldingExceeded: GenericPalletError<Rv>;
+    MaxHoldingExceeded: GenericPalletError;
 
     /**
      * Slippage limit exceeded
      *
      * The calculated amount is worse than the provided slippage limit.
      **/
-    SlippageLimitExceeded: GenericPalletError<Rv>;
+    SlippageLimitExceeded: GenericPalletError;
 
     /**
      * Invalid EVM contract interaction
      *
      * The call to the EVM contract (GHO Hollar token) failed.
      **/
-    InvalidEVMInteraction: GenericPalletError<Rv>;
+    InvalidEVMInteraction: GenericPalletError;
 
     /**
      * Decimal retrieval failed
      *
      * Failed to retrieve the decimal information for an asset.
      **/
-    DecimalRetrievalFailed: GenericPalletError<Rv>;
+    DecimalRetrievalFailed: GenericPalletError;
 
     /**
      * No arbitrage opportunity
      *
      * There is no profitable arbitrage opportunity for the specified collateral.
      **/
-    NoArbitrageOpportunity: GenericPalletError<Rv>;
-
-    /**
-     * Offchain lock error
-     *
-     * Failed to acquire the lock for offchain workers, likely because another operation is in progress.
-     **/
-    OffchainLockError: GenericPalletError<Rv>;
+    NoArbitrageOpportunity: GenericPalletError;
 
     /**
      * Asset not in the pool
      *
      * The specified asset was not found in the pool.
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * Provided pool state is invalid
      *
      * The retrieved pool state has inconsistent or invalid data.
      **/
-    InvalidPoolState: GenericPalletError<Rv>;
+    InvalidPoolState: GenericPalletError;
 
     /**
      * Collateral is not empty
      *
      * Cannot remove a collateral asset that still has a non-zero balance in the HSM account.
      **/
-    CollateralNotEmpty: GenericPalletError<Rv>;
+    CollateralNotEmpty: GenericPalletError;
 
     /**
      * Asset not in the pool
      *
      * The collateral asset is not present in the specified pool.
      **/
-    AssetNotInPool: GenericPalletError<Rv>;
+    AssetNotInPool: GenericPalletError;
 
     /**
      * Hollar is not in the pool
      *
      * The Hollar asset is not present in the specified pool.
      **/
-    HollarNotInPool: GenericPalletError<Rv>;
+    HollarNotInPool: GenericPalletError;
 
     /**
      * Insufficient collateral balance
      *
      * The HSM does not have enough of the collateral asset to complete the operation.
      **/
-    InsufficientCollateralBalance: GenericPalletError<Rv>;
+    InsufficientCollateralBalance: GenericPalletError;
 
     /**
      * GHO Contract address not found
      *
      * The EVM address for the GHO (Hollar) token contract was not found.
      **/
-    HollarContractAddressNotFound: GenericPalletError<Rv>;
+    HollarContractAddressNotFound: GenericPalletError;
 
     /**
      * HSM contains maximum number of allowed collateral assets.
      **/
-    MaxNumberOfCollateralsReached: GenericPalletError<Rv>;
+    MaxNumberOfCollateralsReached: GenericPalletError;
 
     /**
      * Flash minter address not set
      **/
-    FlashMinterNotSet: GenericPalletError<Rv>;
+    FlashMinterNotSet: GenericPalletError;
 
     /**
      * Provided arbitrage data is invalid
      **/
-    InvalidArbitrageData: GenericPalletError<Rv>;
+    InvalidArbitrageData: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Tokens`'s errors
@@ -2724,43 +2717,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The balance is too low
      **/
-    BalanceTooLow: GenericPalletError<Rv>;
+    BalanceTooLow: GenericPalletError;
 
     /**
      * Cannot convert Amount into Balance type
      **/
-    AmountIntoBalanceFailed: GenericPalletError<Rv>;
+    AmountIntoBalanceFailed: GenericPalletError;
 
     /**
      * Failed because liquidity restrictions due to locking
      **/
-    LiquidityRestrictions: GenericPalletError<Rv>;
+    LiquidityRestrictions: GenericPalletError;
 
     /**
      * Failed because the maximum locks was exceeded
      **/
-    MaxLocksExceeded: GenericPalletError<Rv>;
+    MaxLocksExceeded: GenericPalletError;
 
     /**
      * Transfer/payment would kill account
      **/
-    KeepAlive: GenericPalletError<Rv>;
+    KeepAlive: GenericPalletError;
 
     /**
      * Value too low to create account due to existential deposit
      **/
-    ExistentialDeposit: GenericPalletError<Rv>;
+    ExistentialDeposit: GenericPalletError;
 
     /**
      * Beneficiary account must pre-exist
      **/
-    DeadAccount: GenericPalletError<Rv>;
-    TooManyReserves: GenericPalletError<Rv>;
+    DeadAccount: GenericPalletError;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Currencies`'s errors
@@ -2769,27 +2762,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Unable to convert the Amount type into Balance.
      **/
-    AmountIntoBalanceFailed: GenericPalletError<Rv>;
+    AmountIntoBalanceFailed: GenericPalletError;
 
     /**
      * Balance is too low.
      **/
-    BalanceTooLow: GenericPalletError<Rv>;
+    BalanceTooLow: GenericPalletError;
 
     /**
      * Deposit result is not expected
      **/
-    DepositFailed: GenericPalletError<Rv>;
+    DepositFailed: GenericPalletError;
 
     /**
      * Operation is not supported for this currency
      **/
-    NotSupported: GenericPalletError<Rv>;
+    NotSupported: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Vesting`'s errors
@@ -2798,37 +2791,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Vesting period is zero
      **/
-    ZeroVestingPeriod: GenericPalletError<Rv>;
+    ZeroVestingPeriod: GenericPalletError;
 
     /**
      * Number of vests is zero
      **/
-    ZeroVestingPeriodCount: GenericPalletError<Rv>;
+    ZeroVestingPeriodCount: GenericPalletError;
 
     /**
      * Insufficient amount of balance to lock
      **/
-    InsufficientBalanceToLock: GenericPalletError<Rv>;
+    InsufficientBalanceToLock: GenericPalletError;
 
     /**
      * This account have too many vesting schedules
      **/
-    TooManyVestingSchedules: GenericPalletError<Rv>;
+    TooManyVestingSchedules: GenericPalletError;
 
     /**
      * The vested transfer amount is too low
      **/
-    AmountLow: GenericPalletError<Rv>;
+    AmountLow: GenericPalletError;
 
     /**
      * Failed because the maximum vesting schedules was exceeded
      **/
-    MaxVestingSchedulesExceeded: GenericPalletError<Rv>;
+    MaxVestingSchedulesExceeded: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EVM`'s errors
@@ -2837,72 +2830,72 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Not enough balance to perform action
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * Calculating total fee overflowed
      **/
-    FeeOverflow: GenericPalletError<Rv>;
+    FeeOverflow: GenericPalletError;
 
     /**
      * Calculating total payment overflowed
      **/
-    PaymentOverflow: GenericPalletError<Rv>;
+    PaymentOverflow: GenericPalletError;
 
     /**
      * Withdraw fee failed
      **/
-    WithdrawFailed: GenericPalletError<Rv>;
+    WithdrawFailed: GenericPalletError;
 
     /**
      * Gas price is too low.
      **/
-    GasPriceTooLow: GenericPalletError<Rv>;
+    GasPriceTooLow: GenericPalletError;
 
     /**
      * Nonce is invalid
      **/
-    InvalidNonce: GenericPalletError<Rv>;
+    InvalidNonce: GenericPalletError;
 
     /**
      * Gas limit is too low.
      **/
-    GasLimitTooLow: GenericPalletError<Rv>;
+    GasLimitTooLow: GenericPalletError;
 
     /**
      * Gas limit is too high.
      **/
-    GasLimitTooHigh: GenericPalletError<Rv>;
+    GasLimitTooHigh: GenericPalletError;
 
     /**
      * The chain id is invalid.
      **/
-    InvalidChainId: GenericPalletError<Rv>;
+    InvalidChainId: GenericPalletError;
 
     /**
      * the signature is invalid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * EVM reentrancy
      **/
-    Reentrancy: GenericPalletError<Rv>;
+    Reentrancy: GenericPalletError;
 
     /**
      * EIP-3607,
      **/
-    TransactionMustComeFromEOA: GenericPalletError<Rv>;
+    TransactionMustComeFromEOA: GenericPalletError;
 
     /**
      * Undefined error.
      **/
-    Undefined: GenericPalletError<Rv>;
+    Undefined: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Ethereum`'s errors
@@ -2911,17 +2904,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Signature is invalid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * Pre-log is present, therefore transact is not allowed.
      **/
-    PreLogExists: GenericPalletError<Rv>;
+    PreLogExists: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EVMAccounts`'s errors
@@ -2930,27 +2923,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Active EVM account cannot be bound
      **/
-    TruncatedAccountAlreadyUsed: GenericPalletError<Rv>;
+    TruncatedAccountAlreadyUsed: GenericPalletError;
 
     /**
      * Address is already bound
      **/
-    AddressAlreadyBound: GenericPalletError<Rv>;
+    AddressAlreadyBound: GenericPalletError;
 
     /**
      * Bound address cannot be used
      **/
-    BoundAddressCannotBeUsed: GenericPalletError<Rv>;
+    BoundAddressCannotBeUsed: GenericPalletError;
 
     /**
      * Address not whitelisted
      **/
-    AddressNotWhitelisted: GenericPalletError<Rv>;
+    AddressNotWhitelisted: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XYKLiquidityMining`'s errors
@@ -2959,72 +2952,72 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Nft pallet didn't return an owner.
      **/
-    CantFindDepositOwner: GenericPalletError<Rv>;
+    CantFindDepositOwner: GenericPalletError;
 
     /**
      * Account balance of XYK pool shares is not sufficient.
      **/
-    InsufficientXykSharesBalance: GenericPalletError<Rv>;
+    InsufficientXykSharesBalance: GenericPalletError;
 
     /**
      * XYK pool does not exist
      **/
-    XykPoolDoesntExist: GenericPalletError<Rv>;
+    XykPoolDoesntExist: GenericPalletError;
 
     /**
      * Account is not deposit owner.
      **/
-    NotDepositOwner: GenericPalletError<Rv>;
+    NotDepositOwner: GenericPalletError;
 
     /**
      * XYK did not return assets for given pool id
      **/
-    CantGetXykAssets: GenericPalletError<Rv>;
+    CantGetXykAssets: GenericPalletError;
 
     /**
      * Deposit data not found
      **/
-    DepositDataNotFound: GenericPalletError<Rv>;
+    DepositDataNotFound: GenericPalletError;
 
     /**
      * Calculated reward to claim is 0.
      **/
-    ZeroClaimedRewards: GenericPalletError<Rv>;
+    ZeroClaimedRewards: GenericPalletError;
 
     /**
      * Asset is not in the `AssetPair`.
      **/
-    AssetNotInAssetPair: GenericPalletError<Rv>;
+    AssetNotInAssetPair: GenericPalletError;
 
     /**
      * Provided `AssetPair` is not used by the deposit.
      **/
-    InvalidAssetPair: GenericPalletError<Rv>;
+    InvalidAssetPair: GenericPalletError;
 
     /**
      * Asset is not registered in asset registry.
      **/
-    AssetNotRegistered: GenericPalletError<Rv>;
+    AssetNotRegistered: GenericPalletError;
 
     /**
      * Failed to calculate `pot`'s account.
      **/
-    FailToGetPotId: GenericPalletError<Rv>;
+    FailToGetPotId: GenericPalletError;
 
     /**
      * No global farm - yield farm pairs specified to join
      **/
-    NoFarmsSpecified: GenericPalletError<Rv>;
+    NoFarmsSpecified: GenericPalletError;
 
     /**
      * Failed to calculate value of xyk shares
      **/
-    FailedToValueShares: GenericPalletError<Rv>;
+    FailedToValueShares: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XYKWarehouseLM`'s errors
@@ -3033,154 +3026,154 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Global farm does not exist.
      **/
-    GlobalFarmNotFound: GenericPalletError<Rv>;
+    GlobalFarmNotFound: GenericPalletError;
 
     /**
      * Yield farm does not exist.
      **/
-    YieldFarmNotFound: GenericPalletError<Rv>;
+    YieldFarmNotFound: GenericPalletError;
 
     /**
      * Multiple claims in the same period is not allowed.
      **/
-    DoubleClaimInPeriod: GenericPalletError<Rv>;
+    DoubleClaimInPeriod: GenericPalletError;
 
     /**
      * Liquidity mining is canceled.
      **/
-    LiquidityMiningCanceled: GenericPalletError<Rv>;
+    LiquidityMiningCanceled: GenericPalletError;
 
     /**
      * Liquidity mining is not canceled.
      **/
-    LiquidityMiningIsActive: GenericPalletError<Rv>;
+    LiquidityMiningIsActive: GenericPalletError;
 
     /**
      * Liquidity mining is in `active` or `terminated` state and action cannot be completed.
      **/
-    LiquidityMiningIsNotStopped: GenericPalletError<Rv>;
+    LiquidityMiningIsNotStopped: GenericPalletError;
 
     /**
      * Account is not allowed to perform action.
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * Yield farm multiplier can't be 0.
      **/
-    InvalidMultiplier: GenericPalletError<Rv>;
+    InvalidMultiplier: GenericPalletError;
 
     /**
      * Yield farm with given `amm_pool_id` already exists in global farm.
      **/
-    YieldFarmAlreadyExists: GenericPalletError<Rv>;
+    YieldFarmAlreadyExists: GenericPalletError;
 
     /**
      * Loyalty curve's initial reward percentage is not valid. Valid range is: [0, 1).
      **/
-    InvalidInitialRewardPercentage: GenericPalletError<Rv>;
+    InvalidInitialRewardPercentage: GenericPalletError;
 
     /**
      * One or more yield farms exist in global farm.
      **/
-    GlobalFarmIsNotEmpty: GenericPalletError<Rv>;
+    GlobalFarmIsNotEmpty: GenericPalletError;
 
     /**
      * Farm's `incentivized_asset` is missing in provided asset pair.
      **/
-    MissingIncentivizedAsset: GenericPalletError<Rv>;
+    MissingIncentivizedAsset: GenericPalletError;
 
     /**
      * Reward currency balance is not sufficient.
      **/
-    InsufficientRewardCurrencyBalance: GenericPalletError<Rv>;
+    InsufficientRewardCurrencyBalance: GenericPalletError;
 
     /**
      * Blocks per period can't be 0.
      **/
-    InvalidBlocksPerPeriod: GenericPalletError<Rv>;
+    InvalidBlocksPerPeriod: GenericPalletError;
 
     /**
      * Yield per period can't be 0.
      **/
-    InvalidYieldPerPeriod: GenericPalletError<Rv>;
+    InvalidYieldPerPeriod: GenericPalletError;
 
     /**
      * Total rewards is less than `MinTotalFarmRewards`.
      **/
-    InvalidTotalRewards: GenericPalletError<Rv>;
+    InvalidTotalRewards: GenericPalletError;
 
     /**
      * Planned yielding periods is less than `MinPlannedYieldingPeriods`.
      **/
-    InvalidPlannedYieldingPeriods: GenericPalletError<Rv>;
+    InvalidPlannedYieldingPeriods: GenericPalletError;
 
     /**
      * Maximum number of locks reached for deposit.
      **/
-    MaxEntriesPerDeposit: GenericPalletError<Rv>;
+    MaxEntriesPerDeposit: GenericPalletError;
 
     /**
      * Trying to lock LP shares into already locked yield farm.
      **/
-    DoubleLock: GenericPalletError<Rv>;
+    DoubleLock: GenericPalletError;
 
     /**
      * Yield farm entry doesn't exist for given deposit.
      **/
-    YieldFarmEntryNotFound: GenericPalletError<Rv>;
+    YieldFarmEntryNotFound: GenericPalletError;
 
     /**
      * Max number of yield farms in global farm was reached. Global farm can't accept new
      * yield farms until some yield farm is not removed from storage.
      **/
-    GlobalFarmIsFull: GenericPalletError<Rv>;
+    GlobalFarmIsFull: GenericPalletError;
 
     /**
      * Invalid min. deposit was set for global farm.
      **/
-    InvalidMinDeposit: GenericPalletError<Rv>;
+    InvalidMinDeposit: GenericPalletError;
 
     /**
      * Price adjustment multiplier can't be 0.
      **/
-    InvalidPriceAdjustment: GenericPalletError<Rv>;
+    InvalidPriceAdjustment: GenericPalletError;
 
     /**
      * Account creation from id failed.
      **/
-    ErrorGetAccountId: GenericPalletError<Rv>;
+    ErrorGetAccountId: GenericPalletError;
 
     /**
      * Value of deposited shares amount in reward currency is bellow min. limit.
      **/
-    IncorrectValuedShares: GenericPalletError<Rv>;
+    IncorrectValuedShares: GenericPalletError;
 
     /**
      * `reward_currency` is not registered in asset registry.
      **/
-    RewardCurrencyNotRegistered: GenericPalletError<Rv>;
+    RewardCurrencyNotRegistered: GenericPalletError;
 
     /**
      * `incentivized_asset` is not registered in asset registry.
      **/
-    IncentivizedAssetNotRegistered: GenericPalletError<Rv>;
+    IncentivizedAssetNotRegistered: GenericPalletError;
 
     /**
      * Provided `amm_pool_id` doesn't match deposit's `amm_pool_id`.
      **/
-    AmmPoolIdMismatch: GenericPalletError<Rv>;
+    AmmPoolIdMismatch: GenericPalletError;
 
     /**
      * Action cannot be completed because unexpected error has occurred. This should be reported
      * to protocol maintainers.
      **/
-    InconsistentState: GenericPalletError<Rv>;
+    InconsistentState: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `RelayChainInfo`'s errors
@@ -3189,7 +3182,7 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `DCA`'s errors
@@ -3198,107 +3191,107 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Schedule not exist
      **/
-    ScheduleNotFound: GenericPalletError<Rv>;
+    ScheduleNotFound: GenericPalletError;
 
     /**
      * The min trade amount is not reached
      **/
-    MinTradeAmountNotReached: GenericPalletError<Rv>;
+    MinTradeAmountNotReached: GenericPalletError;
 
     /**
      * Forbidden as the user is not the owner of the schedule
      **/
-    Forbidden: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
 
     /**
      * The next execution block number is not in the future
      **/
-    BlockNumberIsNotInFuture: GenericPalletError<Rv>;
+    BlockNumberIsNotInFuture: GenericPalletError;
 
     /**
      * Price is unstable as price change from oracle data is bigger than max allowed
      **/
-    PriceUnstable: GenericPalletError<Rv>;
+    PriceUnstable: GenericPalletError;
 
     /**
      * Order was randomly rescheduled to next block
      **/
-    Bumped: GenericPalletError<Rv>;
+    Bumped: GenericPalletError;
 
     /**
      * Error occurred when calculating price
      **/
-    CalculatingPriceError: GenericPalletError<Rv>;
+    CalculatingPriceError: GenericPalletError;
 
     /**
      * The total amount to be reserved is smaller than min budget
      **/
-    TotalAmountIsSmallerThanMinBudget: GenericPalletError<Rv>;
+    TotalAmountIsSmallerThanMinBudget: GenericPalletError;
 
     /**
      * The budget is too low for executing at least two orders
      **/
-    BudgetTooLow: GenericPalletError<Rv>;
+    BudgetTooLow: GenericPalletError;
 
     /**
      * There is no free block found to plan DCA execution
      **/
-    NoFreeBlockFound: GenericPalletError<Rv>;
+    NoFreeBlockFound: GenericPalletError;
 
     /**
      * The DCA schedule has been manually terminated
      **/
-    ManuallyTerminated: GenericPalletError<Rv>;
+    ManuallyTerminated: GenericPalletError;
 
     /**
      * Max number of retries reached for schedule
      **/
-    MaxRetryReached: GenericPalletError<Rv>;
+    MaxRetryReached: GenericPalletError;
 
     /**
      * Absolutely trade limit reached, leading to retry
      **/
-    TradeLimitReached: GenericPalletError<Rv>;
+    TradeLimitReached: GenericPalletError;
 
     /**
      * Slippage limit calculated from oracle is reached, leading to retry
      **/
-    SlippageLimitReached: GenericPalletError<Rv>;
+    SlippageLimitReached: GenericPalletError;
 
     /**
      * No parent hash has been found from relay chain
      **/
-    NoParentHashFound: GenericPalletError<Rv>;
+    NoParentHashFound: GenericPalletError;
 
     /**
      * Error that should not really happen only in case of invalid state of the schedule storage entries
      **/
-    InvalidState: GenericPalletError<Rv>;
+    InvalidState: GenericPalletError;
 
     /**
      * Period should be longer than 5 blocks
      **/
-    PeriodTooShort: GenericPalletError<Rv>;
+    PeriodTooShort: GenericPalletError;
 
     /**
      * Stability threshold cannot be higher than `MaxConfigurablePriceDifferenceBetweenBlock`
      **/
-    StabilityThresholdTooHigh: GenericPalletError<Rv>;
+    StabilityThresholdTooHigh: GenericPalletError;
 
     /**
      * User still has active DCA schedules and cannot unlock reserves
      **/
-    HasActiveSchedules: GenericPalletError<Rv>;
+    HasActiveSchedules: GenericPalletError;
 
     /**
      * No reserves are locked for the user for the given asset
      **/
-    NoReservesLocked: GenericPalletError<Rv>;
+    NoReservesLocked: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Scheduler`'s errors
@@ -3307,32 +3300,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Failed to schedule a call
      **/
-    FailedToSchedule: GenericPalletError<Rv>;
+    FailedToSchedule: GenericPalletError;
 
     /**
      * Cannot find the scheduled call.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Given target block number is in the past.
      **/
-    TargetBlockNumberInPast: GenericPalletError<Rv>;
+    TargetBlockNumberInPast: GenericPalletError;
 
     /**
      * Reschedule failed because it does not change scheduled time.
      **/
-    RescheduleNoChange: GenericPalletError<Rv>;
+    RescheduleNoChange: GenericPalletError;
 
     /**
      * Attempt to use a non-named function on a named task.
      **/
-    Named: GenericPalletError<Rv>;
+    Named: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParachainSystem`'s errors
@@ -3341,48 +3334,48 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Attempt to upgrade validation function while existing upgrade pending.
      **/
-    OverlappingUpgrades: GenericPalletError<Rv>;
+    OverlappingUpgrades: GenericPalletError;
 
     /**
      * Polkadot currently prohibits this parachain from upgrading its validation function.
      **/
-    ProhibitedByPolkadot: GenericPalletError<Rv>;
+    ProhibitedByPolkadot: GenericPalletError;
 
     /**
      * The supplied validation function has compiled into a blob larger than Polkadot is
      * willing to run.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * The inherent which supplies the validation data did not run this block.
      **/
-    ValidationDataNotAvailable: GenericPalletError<Rv>;
+    ValidationDataNotAvailable: GenericPalletError;
 
     /**
      * The inherent which supplies the host configuration did not run this block.
      **/
-    HostConfigurationNotAvailable: GenericPalletError<Rv>;
+    HostConfigurationNotAvailable: GenericPalletError;
 
     /**
      * No validation function upgrade is currently scheduled.
      **/
-    NotScheduled: GenericPalletError<Rv>;
+    NotScheduled: GenericPalletError;
 
     /**
      * No code upgrade has been authorized.
      **/
-    NothingAuthorized: GenericPalletError<Rv>;
+    NothingAuthorized: GenericPalletError;
 
     /**
      * The given code upgrade has not been authorized.
      **/
-    Unauthorized: GenericPalletError<Rv>;
+    Unauthorized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `PolkadotXcm`'s errors
@@ -3392,129 +3385,129 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The desired destination was unreachable, generally because there is a no way of routing
      * to it.
      **/
-    Unreachable: GenericPalletError<Rv>;
+    Unreachable: GenericPalletError;
 
     /**
      * There was some other issue (i.e. not to do with routing) in sending the message.
      * Perhaps a lack of space for buffering the message.
      **/
-    SendFailure: GenericPalletError<Rv>;
+    SendFailure: GenericPalletError;
 
     /**
      * The message execution fails the filter.
      **/
-    Filtered: GenericPalletError<Rv>;
+    Filtered: GenericPalletError;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError<Rv>;
+    UnweighableMessage: GenericPalletError;
 
     /**
      * The destination `Location` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError<Rv>;
+    DestinationNotInvertible: GenericPalletError;
 
     /**
      * The assets to be sent are empty.
      **/
-    Empty: GenericPalletError<Rv>;
+    Empty: GenericPalletError;
 
     /**
      * Could not re-anchor the assets to declare the fees for the destination chain.
      **/
-    CannotReanchor: GenericPalletError<Rv>;
+    CannotReanchor: GenericPalletError;
 
     /**
      * Too many assets have been attempted for transfer.
      **/
-    TooManyAssets: GenericPalletError<Rv>;
+    TooManyAssets: GenericPalletError;
 
     /**
      * Origin is invalid for sending.
      **/
-    InvalidOrigin: GenericPalletError<Rv>;
+    InvalidOrigin: GenericPalletError;
 
     /**
      * The version of the `Versioned` value used is not able to be interpreted.
      **/
-    BadVersion: GenericPalletError<Rv>;
+    BadVersion: GenericPalletError;
 
     /**
      * The given location could not be used (e.g. because it cannot be expressed in the
      * desired version of XCM).
      **/
-    BadLocation: GenericPalletError<Rv>;
+    BadLocation: GenericPalletError;
 
     /**
      * The referenced subscription could not be found.
      **/
-    NoSubscription: GenericPalletError<Rv>;
+    NoSubscription: GenericPalletError;
 
     /**
      * The location is invalid since it already has a subscription from us.
      **/
-    AlreadySubscribed: GenericPalletError<Rv>;
+    AlreadySubscribed: GenericPalletError;
 
     /**
      * Could not check-out the assets for teleportation to the destination chain.
      **/
-    CannotCheckOutTeleport: GenericPalletError<Rv>;
+    CannotCheckOutTeleport: GenericPalletError;
 
     /**
      * The owner does not own (all) of the asset that they wish to do the operation on.
      **/
-    LowBalance: GenericPalletError<Rv>;
+    LowBalance: GenericPalletError;
 
     /**
      * The asset owner has too many locks on the asset.
      **/
-    TooManyLocks: GenericPalletError<Rv>;
+    TooManyLocks: GenericPalletError;
 
     /**
      * The given account is not an identifiable sovereign account for any location.
      **/
-    AccountNotSovereign: GenericPalletError<Rv>;
+    AccountNotSovereign: GenericPalletError;
 
     /**
      * The operation required fees to be paid which the initiator could not meet.
      **/
-    FeesNotMet: GenericPalletError<Rv>;
+    FeesNotMet: GenericPalletError;
 
     /**
      * A remote lock with the corresponding data could not be found.
      **/
-    LockNotFound: GenericPalletError<Rv>;
+    LockNotFound: GenericPalletError;
 
     /**
      * The unlock operation cannot succeed because there are still consumers of the lock.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid asset, reserve chain could not be determined for it.
      **/
-    InvalidAssetUnknownReserve: GenericPalletError<Rv>;
+    InvalidAssetUnknownReserve: GenericPalletError;
 
     /**
      * Invalid asset, do not support remote asset reserves with different fees reserves.
      **/
-    InvalidAssetUnsupportedReserve: GenericPalletError<Rv>;
+    InvalidAssetUnsupportedReserve: GenericPalletError;
 
     /**
      * Too many assets with different reserve locations have been attempted for transfer.
      **/
-    TooManyReserves: GenericPalletError<Rv>;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Local XCM execution incomplete.
      **/
-    LocalExecutionIncomplete: GenericPalletError<Rv>;
+    LocalExecutionIncomplete: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XcmpQueue`'s errors
@@ -3523,32 +3516,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Setting the queue config failed since one of its values was invalid.
      **/
-    BadQueueConfig: GenericPalletError<Rv>;
+    BadQueueConfig: GenericPalletError;
 
     /**
      * The execution is already suspended.
      **/
-    AlreadySuspended: GenericPalletError<Rv>;
+    AlreadySuspended: GenericPalletError;
 
     /**
      * The execution is already resumed.
      **/
-    AlreadyResumed: GenericPalletError<Rv>;
+    AlreadyResumed: GenericPalletError;
 
     /**
      * There are too many active outbound channels.
      **/
-    TooManyActiveOutboundChannels: GenericPalletError<Rv>;
+    TooManyActiveOutboundChannels: GenericPalletError;
 
     /**
      * The message is too big.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MessageQueue`'s errors
@@ -3558,32 +3551,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Page is not reapable because it has items remaining to be processed and is not old
      * enough.
      **/
-    NotReapable: GenericPalletError<Rv>;
+    NotReapable: GenericPalletError;
 
     /**
      * Page to be reaped does not exist.
      **/
-    NoPage: GenericPalletError<Rv>;
+    NoPage: GenericPalletError;
 
     /**
      * The referenced message could not be found.
      **/
-    NoMessage: GenericPalletError<Rv>;
+    NoMessage: GenericPalletError;
 
     /**
      * The message was already processed and cannot be processed again.
      **/
-    AlreadyProcessed: GenericPalletError<Rv>;
+    AlreadyProcessed: GenericPalletError;
 
     /**
      * The message is queued for future execution.
      **/
-    Queued: GenericPalletError<Rv>;
+    Queued: GenericPalletError;
 
     /**
      * There is temporarily not enough weight to continue servicing messages.
      **/
-    InsufficientWeight: GenericPalletError<Rv>;
+    InsufficientWeight: GenericPalletError;
 
     /**
      * This message is temporarily unprocessable.
@@ -3591,24 +3584,24 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Such errors are expected, but not guaranteed, to resolve themselves eventually through
      * retrying.
      **/
-    TemporarilyUnprocessable: GenericPalletError<Rv>;
+    TemporarilyUnprocessable: GenericPalletError;
 
     /**
      * The queue is paused and no message can be executed from it.
      *
      * This can change at any time and may resolve in the future by re-trying.
      **/
-    QueuePaused: GenericPalletError<Rv>;
+    QueuePaused: GenericPalletError;
 
     /**
      * Another call is in progress and needs to finish before this call can happen.
      **/
-    RecursiveDisallowed: GenericPalletError<Rv>;
+    RecursiveDisallowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OrmlXcm`'s errors
@@ -3618,24 +3611,24 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The message and destination combination was not recognized as being
      * reachable.
      **/
-    Unreachable: GenericPalletError<Rv>;
+    Unreachable: GenericPalletError;
 
     /**
      * The message and destination was recognized as being reachable but
      * the operation could not be completed.
      **/
-    SendFailure: GenericPalletError<Rv>;
+    SendFailure: GenericPalletError;
 
     /**
      * The version of the `Versioned` value used is not able to be
      * interpreted.
      **/
-    BadVersion: GenericPalletError<Rv>;
+    BadVersion: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XTokens`'s errors
@@ -3644,110 +3637,110 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Asset has no reserve location.
      **/
-    AssetHasNoReserve: GenericPalletError<Rv>;
+    AssetHasNoReserve: GenericPalletError;
 
     /**
      * Not cross-chain transfer.
      **/
-    NotCrossChainTransfer: GenericPalletError<Rv>;
+    NotCrossChainTransfer: GenericPalletError;
 
     /**
      * Invalid transfer destination.
      **/
-    InvalidDest: GenericPalletError<Rv>;
+    InvalidDest: GenericPalletError;
 
     /**
      * Currency is not cross-chain transferable.
      **/
-    NotCrossChainTransferableCurrency: GenericPalletError<Rv>;
+    NotCrossChainTransferableCurrency: GenericPalletError;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError<Rv>;
+    UnweighableMessage: GenericPalletError;
 
     /**
      * XCM execution failed.
      **/
-    XcmExecutionFailed: GenericPalletError<Rv>;
+    XcmExecutionFailed: GenericPalletError;
 
     /**
      * Could not re-anchor the assets to declare the fees for the
      * destination chain.
      **/
-    CannotReanchor: GenericPalletError<Rv>;
+    CannotReanchor: GenericPalletError;
 
     /**
      * Could not get ancestry of asset reserve location.
      **/
-    InvalidAncestry: GenericPalletError<Rv>;
+    InvalidAncestry: GenericPalletError;
 
     /**
      * The Asset is invalid.
      **/
-    InvalidAsset: GenericPalletError<Rv>;
+    InvalidAsset: GenericPalletError;
 
     /**
      * The destination `Location` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError<Rv>;
+    DestinationNotInvertible: GenericPalletError;
 
     /**
      * The version of the `Versioned` value used is not able to be
      * interpreted.
      **/
-    BadVersion: GenericPalletError<Rv>;
+    BadVersion: GenericPalletError;
 
     /**
      * We tried sending distinct asset and fee but they have different
      * reserve chains.
      **/
-    DistinctReserveForAssetAndFee: GenericPalletError<Rv>;
+    DistinctReserveForAssetAndFee: GenericPalletError;
 
     /**
      * The fee is zero.
      **/
-    ZeroFee: GenericPalletError<Rv>;
+    ZeroFee: GenericPalletError;
 
     /**
      * The transfering asset amount is zero.
      **/
-    ZeroAmount: GenericPalletError<Rv>;
+    ZeroAmount: GenericPalletError;
 
     /**
      * The number of assets to be sent is over the maximum.
      **/
-    TooManyAssetsBeingSent: GenericPalletError<Rv>;
+    TooManyAssetsBeingSent: GenericPalletError;
 
     /**
      * The specified index does not exist in a Assets struct.
      **/
-    AssetIndexNonExistent: GenericPalletError<Rv>;
+    AssetIndexNonExistent: GenericPalletError;
 
     /**
      * Fee is not enough.
      **/
-    FeeNotEnough: GenericPalletError<Rv>;
+    FeeNotEnough: GenericPalletError;
 
     /**
      * Not supported Location
      **/
-    NotSupportedLocation: GenericPalletError<Rv>;
+    NotSupportedLocation: GenericPalletError;
 
     /**
      * MinXcmFee not registered for certain reserve location
      **/
-    MinXcmFeeNotDefined: GenericPalletError<Rv>;
+    MinXcmFeeNotDefined: GenericPalletError;
 
     /**
      * Asset transfer is limited by RateLimiter.
      **/
-    RateLimited: GenericPalletError<Rv>;
+    RateLimited: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `UnknownTokens`'s errors
@@ -3756,22 +3749,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The balance is too low.
      **/
-    BalanceTooLow: GenericPalletError<Rv>;
+    BalanceTooLow: GenericPalletError;
 
     /**
      * The operation will cause balance to overflow.
      **/
-    BalanceOverflow: GenericPalletError<Rv>;
+    BalanceOverflow: GenericPalletError;
 
     /**
      * Unhandled asset.
      **/
-    UnhandledAsset: GenericPalletError<Rv>;
+    UnhandledAsset: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CollatorSelection`'s errors
@@ -3780,92 +3773,92 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The pallet has too many candidates.
      **/
-    TooManyCandidates: GenericPalletError<Rv>;
+    TooManyCandidates: GenericPalletError;
 
     /**
      * Leaving would result in too few candidates.
      **/
-    TooFewEligibleCollators: GenericPalletError<Rv>;
+    TooFewEligibleCollators: GenericPalletError;
 
     /**
      * Account is already a candidate.
      **/
-    AlreadyCandidate: GenericPalletError<Rv>;
+    AlreadyCandidate: GenericPalletError;
 
     /**
      * Account is not a candidate.
      **/
-    NotCandidate: GenericPalletError<Rv>;
+    NotCandidate: GenericPalletError;
 
     /**
      * There are too many Invulnerables.
      **/
-    TooManyInvulnerables: GenericPalletError<Rv>;
+    TooManyInvulnerables: GenericPalletError;
 
     /**
      * Account is already an Invulnerable.
      **/
-    AlreadyInvulnerable: GenericPalletError<Rv>;
+    AlreadyInvulnerable: GenericPalletError;
 
     /**
      * Account is not an Invulnerable.
      **/
-    NotInvulnerable: GenericPalletError<Rv>;
+    NotInvulnerable: GenericPalletError;
 
     /**
      * Account has no associated validator ID.
      **/
-    NoAssociatedValidatorId: GenericPalletError<Rv>;
+    NoAssociatedValidatorId: GenericPalletError;
 
     /**
      * Validator ID is not yet registered.
      **/
-    ValidatorNotRegistered: GenericPalletError<Rv>;
+    ValidatorNotRegistered: GenericPalletError;
 
     /**
      * Could not insert in the candidate list.
      **/
-    InsertToCandidateListFailed: GenericPalletError<Rv>;
+    InsertToCandidateListFailed: GenericPalletError;
 
     /**
      * Could not remove from the candidate list.
      **/
-    RemoveFromCandidateListFailed: GenericPalletError<Rv>;
+    RemoveFromCandidateListFailed: GenericPalletError;
 
     /**
      * New deposit amount would be below the minimum candidacy bond.
      **/
-    DepositTooLow: GenericPalletError<Rv>;
+    DepositTooLow: GenericPalletError;
 
     /**
      * Could not update the candidate list.
      **/
-    UpdateCandidateListFailed: GenericPalletError<Rv>;
+    UpdateCandidateListFailed: GenericPalletError;
 
     /**
      * Deposit amount is too low to take the target's slot in the candidate list.
      **/
-    InsufficientBond: GenericPalletError<Rv>;
+    InsufficientBond: GenericPalletError;
 
     /**
      * The target account to be replaced in the candidate list is not a candidate.
      **/
-    TargetIsNotCandidate: GenericPalletError<Rv>;
+    TargetIsNotCandidate: GenericPalletError;
 
     /**
      * The updated deposit amount is equal to the amount already reserved.
      **/
-    IdenticalDeposit: GenericPalletError<Rv>;
+    IdenticalDeposit: GenericPalletError;
 
     /**
      * Cannot lower candidacy bond while occupying a future collator slot in the list.
      **/
-    InvalidUnreserve: GenericPalletError<Rv>;
+    InvalidUnreserve: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Session`'s errors
@@ -3874,55 +3867,152 @@ 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;
+  };
+  /**
+   * Pallet `Ismp`'s errors
+   **/
+  ismp: {
+    /**
+     * Invalid ISMP message
+     **/
+    InvalidMessage: GenericPalletError;
+
+    /**
+     * Requested message was not found
+     **/
+    MessageNotFound: GenericPalletError;
+
+    /**
+     * Encountered an error while creating the consensus client.
+     **/
+    ConsensusClientCreationFailed: GenericPalletError;
+
+    /**
+     * Couldn't update unbonding period
+     **/
+    UnbondingPeriodUpdateFailed: GenericPalletError;
+
+    /**
+     * Couldn't update challenge period
+     **/
+    ChallengePeriodUpdateFailed: GenericPalletError;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
+  };
+  /**
+   * Pallet `Hyperbridge`'s errors
+   **/
+  hyperbridge: {
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
+  };
+  /**
+   * Pallet `TokenGateway`'s errors
+   **/
+  tokenGateway: {
+    /**
+     * A asset that has not been registered
+     **/
+    UnregisteredAsset: GenericPalletError;
+
+    /**
+     * Error while teleporting asset
+     **/
+    AssetTeleportError: GenericPalletError;
+
+    /**
+     * Coprocessor was not configured in the runtime
+     **/
+    CoprocessorNotConfigured: GenericPalletError;
+
+    /**
+     * Asset or update Dispatch Error
+     **/
+    DispatchError: GenericPalletError;
+
+    /**
+     * Asset Id creation failed
+     **/
+    AssetCreationError: GenericPalletError;
+
+    /**
+     * Asset decimals not found
+     **/
+    AssetDecimalsNotFound: GenericPalletError;
+
+    /**
+     * Protocol Params have not been initialized
+     **/
+    NotInitialized: GenericPalletError;
+
+    /**
+     * Unknown Asset
+     **/
+    UnknownAsset: GenericPalletError;
+
+    /**
+     * Only root or asset owner can update asset
+     **/
+    NotAssetOwner: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `EmaOracle`'s errors
    **/
   emaOracle: {
-    TooManyUniqueEntries: GenericPalletError<Rv>;
-    OnTradeValueZero: GenericPalletError<Rv>;
-    OracleNotFound: GenericPalletError<Rv>;
+    TooManyUniqueEntries: GenericPalletError;
+    OnTradeValueZero: GenericPalletError;
+    OracleNotFound: GenericPalletError;
 
     /**
      * Asset not found
      **/
-    AssetNotFound: GenericPalletError<Rv>;
+    AssetNotFound: GenericPalletError;
 
     /**
      * The new price is outside the max allowed range
      **/
-    PriceOutsideAllowedRange: GenericPalletError<Rv>;
+    PriceOutsideAllowedRange: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Broadcast`'s errors
@@ -3931,16 +4021,16 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The execution context call stack has reached its maximum size
      **/
-    ExecutionCallStackOverflow: GenericPalletError<Rv>;
+    ExecutionCallStackOverflow: GenericPalletError;
 
     /**
      * The execution context call stack is empty, unable to decrease level
      **/
-    ExecutionCallStackUnderflow: GenericPalletError<Rv>;
+    ExecutionCallStackUnderflow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
 }