@dedot/chaintypes 0.193.0 → 0.195.0

package/substrate/events.d.ts

@@ -1,6 +1,6 @@
 // Generated by dedot cli
 
-import type { GenericChainEvents, GenericPalletEvent, RpcVersion } from 'dedot/types';
+import type { GenericChainEvents, GenericPalletEvent } from 'dedot/types';
 import type {
   DispatchError,
   AccountId32,
@@ -67,7 +67,7 @@ import type {
   KitchensinkRuntimeOriginCaller,
 } from './types.js';
 
-export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
+export interface ChainEvents extends GenericChainEvents {
   /**
    * Pallet `System`'s events
    **/
@@ -75,18 +75,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An extrinsic completed successfully.
      **/
-    ExtrinsicSuccess: GenericPalletEvent<
-      Rv,
-      'System',
-      'ExtrinsicSuccess',
-      { dispatchInfo: FrameSystemDispatchEventInfo }
-    >;
+    ExtrinsicSuccess: GenericPalletEvent<'System', 'ExtrinsicSuccess', { dispatchInfo: FrameSystemDispatchEventInfo }>;
 
     /**
      * An extrinsic failed.
      **/
     ExtrinsicFailed: GenericPalletEvent<
-      Rv,
       'System',
       'ExtrinsicFailed',
       { dispatchError: DispatchError; dispatchInfo: FrameSystemDispatchEventInfo }
@@ -95,33 +89,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * `:code` was updated.
      **/
-    CodeUpdated: GenericPalletEvent<Rv, 'System', 'CodeUpdated', null>;
+    CodeUpdated: GenericPalletEvent<'System', 'CodeUpdated', null>;
 
     /**
      * A new account was created.
      **/
-    NewAccount: GenericPalletEvent<Rv, 'System', 'NewAccount', { account: AccountId32 }>;
+    NewAccount: GenericPalletEvent<'System', 'NewAccount', { account: AccountId32 }>;
 
     /**
      * An account was reaped.
      **/
-    KilledAccount: GenericPalletEvent<Rv, 'System', 'KilledAccount', { account: AccountId32 }>;
+    KilledAccount: GenericPalletEvent<'System', 'KilledAccount', { account: AccountId32 }>;
 
     /**
      * On on-chain remark happened.
      **/
-    Remarked: GenericPalletEvent<Rv, 'System', 'Remarked', { sender: AccountId32; hash: H256 }>;
+    Remarked: GenericPalletEvent<'System', 'Remarked', { sender: AccountId32; hash: H256 }>;
 
     /**
      * An upgrade was authorized.
      **/
-    UpgradeAuthorized: GenericPalletEvent<Rv, 'System', 'UpgradeAuthorized', { codeHash: H256; checkVersion: boolean }>;
+    UpgradeAuthorized: GenericPalletEvent<'System', 'UpgradeAuthorized', { codeHash: H256; checkVersion: boolean }>;
 
     /**
      * An invalid authorized upgrade was rejected while trying to apply it.
      **/
     RejectedInvalidAuthorizedUpgrade: GenericPalletEvent<
-      Rv,
       'System',
       'RejectedInvalidAuthorizedUpgrade',
       { codeHash: H256; error: DispatchError }
@@ -130,7 +123,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Utility`'s events
@@ -140,47 +133,47 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
      * well as the error.
      **/
-    BatchInterrupted: GenericPalletEvent<Rv, 'Utility', 'BatchInterrupted', { index: number; error: DispatchError }>;
+    BatchInterrupted: GenericPalletEvent<'Utility', 'BatchInterrupted', { index: number; error: DispatchError }>;
 
     /**
      * Batch of dispatches completed fully with no error.
      **/
-    BatchCompleted: GenericPalletEvent<Rv, 'Utility', 'BatchCompleted', null>;
+    BatchCompleted: GenericPalletEvent<'Utility', 'BatchCompleted', null>;
 
     /**
      * Batch of dispatches completed but has errors.
      **/
-    BatchCompletedWithErrors: GenericPalletEvent<Rv, 'Utility', 'BatchCompletedWithErrors', null>;
+    BatchCompletedWithErrors: GenericPalletEvent<'Utility', 'BatchCompletedWithErrors', null>;
 
     /**
      * A single item within a Batch of dispatches has completed with no error.
      **/
-    ItemCompleted: GenericPalletEvent<Rv, 'Utility', 'ItemCompleted', null>;
+    ItemCompleted: GenericPalletEvent<'Utility', 'ItemCompleted', null>;
 
     /**
      * A single item within a Batch of dispatches has completed with error.
      **/
-    ItemFailed: GenericPalletEvent<Rv, 'Utility', 'ItemFailed', { error: DispatchError }>;
+    ItemFailed: GenericPalletEvent<'Utility', 'ItemFailed', { error: DispatchError }>;
 
     /**
      * A call was dispatched.
      **/
-    DispatchedAs: GenericPalletEvent<Rv, 'Utility', 'DispatchedAs', { result: Result<[], DispatchError> }>;
+    DispatchedAs: GenericPalletEvent<'Utility', 'DispatchedAs', { result: Result<[], DispatchError> }>;
 
     /**
      * Main call was dispatched.
      **/
-    IfElseMainSuccess: GenericPalletEvent<Rv, 'Utility', 'IfElseMainSuccess', null>;
+    IfElseMainSuccess: GenericPalletEvent<'Utility', 'IfElseMainSuccess', null>;
 
     /**
      * The fallback call was dispatched.
      **/
-    IfElseFallbackCalled: GenericPalletEvent<Rv, 'Utility', 'IfElseFallbackCalled', { mainError: DispatchError }>;
+    IfElseFallbackCalled: GenericPalletEvent<'Utility', 'IfElseFallbackCalled', { mainError: DispatchError }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Indices`'s events
@@ -189,23 +182,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A account index was assigned.
      **/
-    IndexAssigned: GenericPalletEvent<Rv, 'Indices', 'IndexAssigned', { who: AccountId32; index: number }>;
+    IndexAssigned: GenericPalletEvent<'Indices', 'IndexAssigned', { who: AccountId32; index: number }>;
 
     /**
      * A account index has been freed up (unassigned).
      **/
-    IndexFreed: GenericPalletEvent<Rv, 'Indices', 'IndexFreed', { index: number }>;
+    IndexFreed: GenericPalletEvent<'Indices', 'IndexFreed', { index: number }>;
 
     /**
      * A account index has been frozen to its current account ID.
      **/
-    IndexFrozen: GenericPalletEvent<Rv, 'Indices', 'IndexFrozen', { index: number; who: AccountId32 }>;
+    IndexFrozen: GenericPalletEvent<'Indices', 'IndexFrozen', { index: number; who: AccountId32 }>;
 
     /**
      * A deposit to reserve an index has been poked/reconsidered.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Indices',
       'DepositPoked',
       { who: AccountId32; index: number; oldDeposit: bigint; newDeposit: bigint }
@@ -214,7 +206,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Balances`'s events
@@ -223,40 +215,39 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An account was created with some free balance.
      **/
-    Endowed: GenericPalletEvent<Rv, 'Balances', 'Endowed', { account: AccountId32; freeBalance: bigint }>;
+    Endowed: GenericPalletEvent<'Balances', 'Endowed', { account: AccountId32; freeBalance: bigint }>;
 
     /**
      * An account was removed whose balance was non-zero but below ExistentialDeposit,
      * resulting in an outright loss.
      **/
-    DustLost: GenericPalletEvent<Rv, 'Balances', 'DustLost', { account: AccountId32; amount: bigint }>;
+    DustLost: GenericPalletEvent<'Balances', 'DustLost', { account: AccountId32; amount: bigint }>;
 
     /**
      * Transfer succeeded.
      **/
-    Transfer: GenericPalletEvent<Rv, 'Balances', 'Transfer', { from: AccountId32; to: AccountId32; amount: bigint }>;
+    Transfer: GenericPalletEvent<'Balances', 'Transfer', { from: AccountId32; to: AccountId32; amount: bigint }>;
 
     /**
      * A balance was set by root.
      **/
-    BalanceSet: GenericPalletEvent<Rv, 'Balances', 'BalanceSet', { who: AccountId32; free: bigint }>;
+    BalanceSet: GenericPalletEvent<'Balances', 'BalanceSet', { who: AccountId32; free: bigint }>;
 
     /**
      * Some balance was reserved (moved from free to reserved).
      **/
-    Reserved: GenericPalletEvent<Rv, 'Balances', 'Reserved', { who: AccountId32; amount: bigint }>;
+    Reserved: GenericPalletEvent<'Balances', 'Reserved', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was unreserved (moved from reserved to free).
      **/
-    Unreserved: GenericPalletEvent<Rv, 'Balances', 'Unreserved', { who: AccountId32; amount: bigint }>;
+    Unreserved: GenericPalletEvent<'Balances', 'Unreserved', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was moved from the reserve of the first account to the second account.
      * Final argument indicates the destination balance type.
      **/
     ReserveRepatriated: GenericPalletEvent<
-      Rv,
       'Balances',
       'ReserveRepatriated',
       { from: AccountId32; to: AccountId32; amount: bigint; destinationStatus: FrameSupportTokensMiscBalanceStatus }
@@ -265,82 +256,82 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some amount was deposited (e.g. for transaction fees).
      **/
-    Deposit: GenericPalletEvent<Rv, 'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
+    Deposit: GenericPalletEvent<'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdraw: GenericPalletEvent<Rv, 'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
+    Withdraw: GenericPalletEvent<'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was removed from the account (e.g. for misbehavior).
      **/
-    Slashed: GenericPalletEvent<Rv, 'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was minted into an account.
      **/
-    Minted: GenericPalletEvent<Rv, 'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
+    Minted: GenericPalletEvent<'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was burned from an account.
      **/
-    Burned: GenericPalletEvent<Rv, 'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
+    Burned: GenericPalletEvent<'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was suspended from an account (it can be restored later).
      **/
-    Suspended: GenericPalletEvent<Rv, 'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
+    Suspended: GenericPalletEvent<'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was restored into an account.
      **/
-    Restored: GenericPalletEvent<Rv, 'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
+    Restored: GenericPalletEvent<'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
 
     /**
      * An account was upgraded.
      **/
-    Upgraded: GenericPalletEvent<Rv, 'Balances', 'Upgraded', { who: AccountId32 }>;
+    Upgraded: GenericPalletEvent<'Balances', 'Upgraded', { who: AccountId32 }>;
 
     /**
      * Total issuance was increased by `amount`, creating a credit to be balanced.
      **/
-    Issued: GenericPalletEvent<Rv, 'Balances', 'Issued', { amount: bigint }>;
+    Issued: GenericPalletEvent<'Balances', 'Issued', { amount: bigint }>;
 
     /**
      * Total issuance was decreased by `amount`, creating a debt to be balanced.
      **/
-    Rescinded: GenericPalletEvent<Rv, 'Balances', 'Rescinded', { amount: bigint }>;
+    Rescinded: GenericPalletEvent<'Balances', 'Rescinded', { amount: bigint }>;
 
     /**
      * Some balance was locked.
      **/
-    Locked: GenericPalletEvent<Rv, 'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
+    Locked: GenericPalletEvent<'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was unlocked.
      **/
-    Unlocked: GenericPalletEvent<Rv, 'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
+    Unlocked: GenericPalletEvent<'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
+    Frozen: GenericPalletEvent<'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
+    Thawed: GenericPalletEvent<'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
 
     /**
      * The `TotalIssuance` was forcefully changed.
      **/
-    TotalIssuanceForced: GenericPalletEvent<Rv, 'Balances', 'TotalIssuanceForced', { old: bigint; new: bigint }>;
+    TotalIssuanceForced: GenericPalletEvent<'Balances', 'TotalIssuanceForced', { old: bigint; new: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TransactionPayment`'s events
@@ -351,7 +342,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * has been paid by `who`.
      **/
     TransactionFeePaid: GenericPalletEvent<
-      Rv,
       'TransactionPayment',
       'TransactionFeePaid',
       { who: AccountId32; actualFee: bigint; tip: bigint }
@@ -360,7 +350,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetConversionTxPayment`'s events
@@ -371,7 +361,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * has been paid by `who` in an asset `asset_id`.
      **/
     AssetTxFeePaid: GenericPalletEvent<
-      Rv,
       'AssetConversionTxPayment',
       'AssetTxFeePaid',
       { who: AccountId32; actualFee: bigint; tip: bigint; assetId: FrameSupportTokensFungibleUnionOfNativeOrWithId }
@@ -381,7 +370,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A swap of the refund in native currency back to asset failed.
      **/
     AssetRefundFailed: GenericPalletEvent<
-      Rv,
       'AssetConversionTxPayment',
       'AssetRefundFailed',
       { nativeAmountKept: bigint }
@@ -390,7 +378,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ElectionProviderMultiPhase`'s events
@@ -406,7 +394,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * room for this one.
      **/
     SolutionStored: GenericPalletEvent<
-      Rv,
       'ElectionProviderMultiPhase',
       'SolutionStored',
       {
@@ -420,7 +407,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The election has been finalized, with the given computation and score.
      **/
     ElectionFinalized: GenericPalletEvent<
-      Rv,
       'ElectionProviderMultiPhase',
       'ElectionFinalized',
       { compute: PalletElectionProviderMultiPhaseElectionCompute; score: SpNposElectionsElectionScore }
@@ -431,23 +417,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      *
      * Not much can be said about which computes failed in the process.
      **/
-    ElectionFailed: GenericPalletEvent<Rv, 'ElectionProviderMultiPhase', 'ElectionFailed', null>;
+    ElectionFailed: GenericPalletEvent<'ElectionProviderMultiPhase', 'ElectionFailed', null>;
 
     /**
      * An account has been rewarded for their signed submission being finalized.
      **/
-    Rewarded: GenericPalletEvent<Rv, 'ElectionProviderMultiPhase', 'Rewarded', { account: AccountId32; value: bigint }>;
+    Rewarded: GenericPalletEvent<'ElectionProviderMultiPhase', 'Rewarded', { account: AccountId32; value: bigint }>;
 
     /**
      * An account has been slashed for submitting an invalid signed submission.
      **/
-    Slashed: GenericPalletEvent<Rv, 'ElectionProviderMultiPhase', 'Slashed', { account: AccountId32; value: bigint }>;
+    Slashed: GenericPalletEvent<'ElectionProviderMultiPhase', 'Slashed', { account: AccountId32; value: bigint }>;
 
     /**
      * There was a phase transition in a given round.
      **/
     PhaseTransitioned: GenericPalletEvent<
-      Rv,
       'ElectionProviderMultiPhase',
       'PhaseTransitioned',
       { from: PalletElectionProviderMultiPhasePhase; to: PalletElectionProviderMultiPhasePhase; round: number }
@@ -456,7 +441,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Staking`'s events
@@ -466,18 +451,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The era payout has been set; the first balance is the validator-payout; the second is
      * the remainder from the maximum amount of reward.
      **/
-    EraPaid: GenericPalletEvent<
-      Rv,
-      'Staking',
-      'EraPaid',
-      { eraIndex: number; validatorPayout: bigint; remainder: bigint }
-    >;
+    EraPaid: GenericPalletEvent<'Staking', 'EraPaid', { eraIndex: number; validatorPayout: bigint; remainder: bigint }>;
 
     /**
      * The nominator has been rewarded by this amount to this destination.
      **/
     Rewarded: GenericPalletEvent<
-      Rv,
       'Staking',
       'Rewarded',
       { stash: AccountId32; dest: PalletStakingRewardDestination; amount: bigint }
@@ -486,14 +465,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A staker (validator or nominator) has been slashed by the given amount.
      **/
-    Slashed: GenericPalletEvent<Rv, 'Staking', 'Slashed', { staker: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<'Staking', 'Slashed', { staker: AccountId32; amount: bigint }>;
 
     /**
      * A slash for the given validator, for the given percentage of their stake, at the given
      * era as been reported.
      **/
     SlashReported: GenericPalletEvent<
-      Rv,
       'Staking',
       'SlashReported',
       { validator: AccountId32; fraction: Perbill; slashEra: number }
@@ -503,17 +481,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An old slashing report from a prior era was discarded because it could
      * not be processed.
      **/
-    OldSlashingReportDiscarded: GenericPalletEvent<
-      Rv,
-      'Staking',
-      'OldSlashingReportDiscarded',
-      { sessionIndex: number }
-    >;
+    OldSlashingReportDiscarded: GenericPalletEvent<'Staking', 'OldSlashingReportDiscarded', { sessionIndex: number }>;
 
     /**
      * A new set of stakers was elected.
      **/
-    StakersElected: GenericPalletEvent<Rv, 'Staking', 'StakersElected', null>;
+    StakersElected: GenericPalletEvent<'Staking', 'StakersElected', null>;
 
     /**
      * An account has bonded this amount. \[stash, amount\]
@@ -521,39 +494,38 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
      * it will not be emitted for staking rewards when they are added to stake.
      **/
-    Bonded: GenericPalletEvent<Rv, 'Staking', 'Bonded', { stash: AccountId32; amount: bigint }>;
+    Bonded: GenericPalletEvent<'Staking', 'Bonded', { stash: AccountId32; amount: bigint }>;
 
     /**
      * An account has unbonded this amount.
      **/
-    Unbonded: GenericPalletEvent<Rv, 'Staking', 'Unbonded', { stash: AccountId32; amount: bigint }>;
+    Unbonded: GenericPalletEvent<'Staking', 'Unbonded', { stash: AccountId32; amount: bigint }>;
 
     /**
      * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
      * from the unlocking queue.
      **/
-    Withdrawn: GenericPalletEvent<Rv, 'Staking', 'Withdrawn', { stash: AccountId32; amount: bigint }>;
+    Withdrawn: GenericPalletEvent<'Staking', 'Withdrawn', { stash: AccountId32; amount: bigint }>;
 
     /**
      * A nominator has been kicked from a validator.
      **/
-    Kicked: GenericPalletEvent<Rv, 'Staking', 'Kicked', { nominator: AccountId32; stash: AccountId32 }>;
+    Kicked: GenericPalletEvent<'Staking', 'Kicked', { nominator: AccountId32; stash: AccountId32 }>;
 
     /**
      * The election failed. No new era is planned.
      **/
-    StakingElectionFailed: GenericPalletEvent<Rv, 'Staking', 'StakingElectionFailed', null>;
+    StakingElectionFailed: GenericPalletEvent<'Staking', 'StakingElectionFailed', null>;
 
     /**
      * An account has stopped participating as either a validator or nominator.
      **/
-    Chilled: GenericPalletEvent<Rv, 'Staking', 'Chilled', { stash: AccountId32 }>;
+    Chilled: GenericPalletEvent<'Staking', 'Chilled', { stash: AccountId32 }>;
 
     /**
      * A Page of stakers rewards are getting paid. `next` is `None` if all pages are claimed.
      **/
     PayoutStarted: GenericPalletEvent<
-      Rv,
       'Staking',
       'PayoutStarted',
       { eraIndex: number; validatorStash: AccountId32; page: number; next?: number | undefined }
@@ -563,7 +535,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A validator has set their preferences.
      **/
     ValidatorPrefsSet: GenericPalletEvent<
-      Rv,
       'Staking',
       'ValidatorPrefsSet',
       { stash: AccountId32; prefs: PalletStakingValidatorPrefs }
@@ -572,38 +543,33 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Voters size limit reached.
      **/
-    SnapshotVotersSizeExceeded: GenericPalletEvent<Rv, 'Staking', 'SnapshotVotersSizeExceeded', { size: number }>;
+    SnapshotVotersSizeExceeded: GenericPalletEvent<'Staking', 'SnapshotVotersSizeExceeded', { size: number }>;
 
     /**
      * Targets size limit reached.
      **/
-    SnapshotTargetsSizeExceeded: GenericPalletEvent<Rv, 'Staking', 'SnapshotTargetsSizeExceeded', { size: number }>;
+    SnapshotTargetsSizeExceeded: GenericPalletEvent<'Staking', 'SnapshotTargetsSizeExceeded', { size: number }>;
 
     /**
      * A new force era mode was set.
      **/
-    ForceEra: GenericPalletEvent<Rv, 'Staking', 'ForceEra', { mode: PalletStakingForcing }>;
+    ForceEra: GenericPalletEvent<'Staking', 'ForceEra', { mode: PalletStakingForcing }>;
 
     /**
      * Report of a controller batch deprecation.
      **/
-    ControllerBatchDeprecated: GenericPalletEvent<Rv, 'Staking', 'ControllerBatchDeprecated', { failures: number }>;
+    ControllerBatchDeprecated: GenericPalletEvent<'Staking', 'ControllerBatchDeprecated', { failures: number }>;
 
     /**
      * Staking balance migrated from locks to holds, with any balance that could not be held
      * is force withdrawn.
      **/
-    CurrencyMigrated: GenericPalletEvent<
-      Rv,
-      'Staking',
-      'CurrencyMigrated',
-      { stash: AccountId32; forceWithdraw: bigint }
-    >;
+    CurrencyMigrated: GenericPalletEvent<'Staking', 'CurrencyMigrated', { stash: AccountId32; forceWithdraw: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Session`'s events
@@ -613,22 +579,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * New session has happened. Note that the argument is the session index, not the
      * block number as the type might suggest.
      **/
-    NewSession: GenericPalletEvent<Rv, 'Session', 'NewSession', { sessionIndex: number }>;
+    NewSession: GenericPalletEvent<'Session', 'NewSession', { sessionIndex: number }>;
 
     /**
      * Validator has been disabled.
      **/
-    ValidatorDisabled: GenericPalletEvent<Rv, 'Session', 'ValidatorDisabled', { validator: AccountId32 }>;
+    ValidatorDisabled: GenericPalletEvent<'Session', 'ValidatorDisabled', { validator: AccountId32 }>;
 
     /**
      * Validator has been re-enabled.
      **/
-    ValidatorReenabled: GenericPalletEvent<Rv, 'Session', 'ValidatorReenabled', { validator: AccountId32 }>;
+    ValidatorReenabled: GenericPalletEvent<'Session', 'ValidatorReenabled', { validator: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Democracy`'s events
@@ -637,68 +603,62 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion has been proposed by a public account.
      **/
-    Proposed: GenericPalletEvent<Rv, 'Democracy', 'Proposed', { proposalIndex: number; deposit: bigint }>;
+    Proposed: GenericPalletEvent<'Democracy', 'Proposed', { proposalIndex: number; deposit: bigint }>;
 
     /**
      * A public proposal has been tabled for referendum vote.
      **/
-    Tabled: GenericPalletEvent<Rv, 'Democracy', 'Tabled', { proposalIndex: number; deposit: bigint }>;
+    Tabled: GenericPalletEvent<'Democracy', 'Tabled', { proposalIndex: number; deposit: bigint }>;
 
     /**
      * An external proposal has been tabled.
      **/
-    ExternalTabled: GenericPalletEvent<Rv, 'Democracy', 'ExternalTabled', null>;
+    ExternalTabled: GenericPalletEvent<'Democracy', 'ExternalTabled', null>;
 
     /**
      * A referendum has begun.
      **/
-    Started: GenericPalletEvent<
-      Rv,
-      'Democracy',
-      'Started',
-      { refIndex: number; threshold: PalletDemocracyVoteThreshold }
-    >;
+    Started: GenericPalletEvent<'Democracy', 'Started', { refIndex: number; threshold: PalletDemocracyVoteThreshold }>;
 
     /**
      * A proposal has been approved by referendum.
      **/
-    Passed: GenericPalletEvent<Rv, 'Democracy', 'Passed', { refIndex: number }>;
+    Passed: GenericPalletEvent<'Democracy', 'Passed', { refIndex: number }>;
 
     /**
      * A proposal has been rejected by referendum.
      **/
-    NotPassed: GenericPalletEvent<Rv, 'Democracy', 'NotPassed', { refIndex: number }>;
+    NotPassed: GenericPalletEvent<'Democracy', 'NotPassed', { refIndex: number }>;
 
     /**
      * A referendum has been cancelled.
      **/
-    Cancelled: GenericPalletEvent<Rv, 'Democracy', 'Cancelled', { refIndex: number }>;
+    Cancelled: GenericPalletEvent<'Democracy', 'Cancelled', { refIndex: number }>;
 
     /**
      * An account has delegated their vote to another account.
      **/
-    Delegated: GenericPalletEvent<Rv, 'Democracy', 'Delegated', { who: AccountId32; target: AccountId32 }>;
+    Delegated: GenericPalletEvent<'Democracy', 'Delegated', { who: AccountId32; target: AccountId32 }>;
 
     /**
      * An account has cancelled a previous delegation operation.
      **/
-    Undelegated: GenericPalletEvent<Rv, 'Democracy', 'Undelegated', { account: AccountId32 }>;
+    Undelegated: GenericPalletEvent<'Democracy', 'Undelegated', { account: AccountId32 }>;
 
     /**
      * An external proposal has been vetoed.
      **/
-    Vetoed: GenericPalletEvent<Rv, 'Democracy', 'Vetoed', { who: AccountId32; proposalHash: H256; until: number }>;
+    Vetoed: GenericPalletEvent<'Democracy', 'Vetoed', { who: AccountId32; proposalHash: H256; until: number }>;
 
     /**
      * A proposal_hash has been blacklisted permanently.
      **/
-    Blacklisted: GenericPalletEvent<Rv, 'Democracy', 'Blacklisted', { proposalHash: H256 }>;
+    Blacklisted: GenericPalletEvent<'Democracy', 'Blacklisted', { proposalHash: H256 }>;
 
     /**
      * An account has voted in a referendum
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'Democracy',
       'Voted',
       { voter: AccountId32; refIndex: number; vote: PalletDemocracyVoteAccountVote }
@@ -707,18 +667,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An account has seconded a proposal
      **/
-    Seconded: GenericPalletEvent<Rv, 'Democracy', 'Seconded', { seconder: AccountId32; propIndex: number }>;
+    Seconded: GenericPalletEvent<'Democracy', 'Seconded', { seconder: AccountId32; propIndex: number }>;
 
     /**
      * A proposal got canceled.
      **/
-    ProposalCanceled: GenericPalletEvent<Rv, 'Democracy', 'ProposalCanceled', { propIndex: number }>;
+    ProposalCanceled: GenericPalletEvent<'Democracy', 'ProposalCanceled', { propIndex: number }>;
 
     /**
      * Metadata for a proposal or a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataSet',
       {
@@ -738,7 +697,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a proposal or a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataCleared',
       {
@@ -758,7 +716,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata has been transferred to new owner.
      **/
     MetadataTransferred: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataTransferred',
       {
@@ -782,7 +739,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Council`'s events
@@ -793,7 +750,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'Council',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -804,7 +760,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'Council',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -813,23 +768,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'Council', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'Council', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'Council', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'Council', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
-    Executed: GenericPalletEvent<Rv, 'Council', 'Executed', { proposalHash: H256; result: Result<[], DispatchError> }>;
+    Executed: GenericPalletEvent<'Council', 'Executed', { proposalHash: H256; result: Result<[], DispatchError> }>;
 
     /**
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'Council',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -838,28 +792,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'Council', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'Council', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'Council', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'Council', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
-    ProposalCostBurned: GenericPalletEvent<
-      Rv,
-      'Council',
-      'ProposalCostBurned',
-      { proposalHash: H256; who: AccountId32 }
-    >;
+    ProposalCostBurned: GenericPalletEvent<'Council', 'ProposalCostBurned', { proposalHash: H256; who: AccountId32 }>;
 
     /**
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'Council',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -868,7 +816,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TechnicalCommittee`'s events
@@ -879,7 +827,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -890,7 +837,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -899,18 +845,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'TechnicalCommittee', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'TechnicalCommittee', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
     Executed: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Executed',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -920,7 +865,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -929,18 +873,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'TechnicalCommittee', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'TechnicalCommittee', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
     ProposalCostBurned: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'ProposalCostBurned',
       { proposalHash: H256; who: AccountId32 }
@@ -950,7 +893,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -959,7 +901,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Elections`'s events
@@ -972,29 +914,29 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to
      * begin with.
      **/
-    NewTerm: GenericPalletEvent<Rv, 'Elections', 'NewTerm', { newMembers: Array<[AccountId32, bigint]> }>;
+    NewTerm: GenericPalletEvent<'Elections', 'NewTerm', { newMembers: Array<[AccountId32, bigint]> }>;
 
     /**
      * No (or not enough) candidates existed for this round. This is different from
      * `NewTerm(\[\])`. See the description of `NewTerm`.
      **/
-    EmptyTerm: GenericPalletEvent<Rv, 'Elections', 'EmptyTerm', null>;
+    EmptyTerm: GenericPalletEvent<'Elections', 'EmptyTerm', null>;
 
     /**
      * Internal error happened while trying to perform election.
      **/
-    ElectionError: GenericPalletEvent<Rv, 'Elections', 'ElectionError', null>;
+    ElectionError: GenericPalletEvent<'Elections', 'ElectionError', null>;
 
     /**
      * A member has been removed. This should always be followed by either `NewTerm` or
      * `EmptyTerm`.
      **/
-    MemberKicked: GenericPalletEvent<Rv, 'Elections', 'MemberKicked', { member: AccountId32 }>;
+    MemberKicked: GenericPalletEvent<'Elections', 'MemberKicked', { member: AccountId32 }>;
 
     /**
      * Someone has renounced their candidacy.
      **/
-    Renounced: GenericPalletEvent<Rv, 'Elections', 'Renounced', { candidate: AccountId32 }>;
+    Renounced: GenericPalletEvent<'Elections', 'Renounced', { candidate: AccountId32 }>;
 
     /**
      * A candidate was slashed by amount due to failing to obtain a seat as member or
@@ -1002,18 +944,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      *
      * Note that old members and runners-up are also candidates.
      **/
-    CandidateSlashed: GenericPalletEvent<
-      Rv,
-      'Elections',
-      'CandidateSlashed',
-      { candidate: AccountId32; amount: bigint }
-    >;
+    CandidateSlashed: GenericPalletEvent<'Elections', 'CandidateSlashed', { candidate: AccountId32; amount: bigint }>;
 
     /**
      * A seat holder was slashed by amount by being forcefully removed from the set.
      **/
     SeatHolderSlashed: GenericPalletEvent<
-      Rv,
       'Elections',
       'SeatHolderSlashed',
       { seatHolder: AccountId32; amount: bigint }
@@ -1022,7 +958,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TechnicalMembership`'s events
@@ -1031,37 +967,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The given member was added; see the transaction for who.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'TechnicalMembership', 'MemberAdded', undefined>;
+    MemberAdded: GenericPalletEvent<'TechnicalMembership', 'MemberAdded', undefined>;
 
     /**
      * The given member was removed; see the transaction for who.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'TechnicalMembership', 'MemberRemoved', undefined>;
+    MemberRemoved: GenericPalletEvent<'TechnicalMembership', 'MemberRemoved', undefined>;
 
     /**
      * Two members were swapped; see the transaction for who.
      **/
-    MembersSwapped: GenericPalletEvent<Rv, 'TechnicalMembership', 'MembersSwapped', undefined>;
+    MembersSwapped: GenericPalletEvent<'TechnicalMembership', 'MembersSwapped', undefined>;
 
     /**
      * The membership was reset; see the transaction for who the new set is.
      **/
-    MembersReset: GenericPalletEvent<Rv, 'TechnicalMembership', 'MembersReset', undefined>;
+    MembersReset: GenericPalletEvent<'TechnicalMembership', 'MembersReset', undefined>;
 
     /**
      * One of the members' keys changed.
      **/
-    KeyChanged: GenericPalletEvent<Rv, 'TechnicalMembership', 'KeyChanged', undefined>;
+    KeyChanged: GenericPalletEvent<'TechnicalMembership', 'KeyChanged', undefined>;
 
     /**
      * Phantom member, never used.
      **/
-    Dummy: GenericPalletEvent<Rv, 'TechnicalMembership', 'Dummy', undefined>;
+    Dummy: GenericPalletEvent<'TechnicalMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Grandpa`'s events
@@ -1071,7 +1007,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * New authority set has been applied.
      **/
     NewAuthorities: GenericPalletEvent<
-      Rv,
       'Grandpa',
       'NewAuthorities',
       { authoritySet: Array<[SpConsensusGrandpaAppPublic, bigint]> }
@@ -1080,17 +1015,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Current authority set has been paused.
      **/
-    Paused: GenericPalletEvent<Rv, 'Grandpa', 'Paused', null>;
+    Paused: GenericPalletEvent<'Grandpa', 'Paused', null>;
 
     /**
      * Current authority set has been resumed.
      **/
-    Resumed: GenericPalletEvent<Rv, 'Grandpa', 'Resumed', null>;
+    Resumed: GenericPalletEvent<'Grandpa', 'Resumed', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Treasury`'s events
@@ -1099,38 +1034,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * We have ended a spend period and will now allocate funds.
      **/
-    Spending: GenericPalletEvent<Rv, 'Treasury', 'Spending', { budgetRemaining: bigint }>;
+    Spending: GenericPalletEvent<'Treasury', 'Spending', { budgetRemaining: bigint }>;
 
     /**
      * Some funds have been allocated.
      **/
-    Awarded: GenericPalletEvent<
-      Rv,
-      'Treasury',
-      'Awarded',
-      { proposalIndex: number; award: bigint; account: AccountId32 }
-    >;
+    Awarded: GenericPalletEvent<'Treasury', 'Awarded', { proposalIndex: number; award: bigint; account: AccountId32 }>;
 
     /**
      * Some of our funds have been burnt.
      **/
-    Burnt: GenericPalletEvent<Rv, 'Treasury', 'Burnt', { burntFunds: bigint }>;
+    Burnt: GenericPalletEvent<'Treasury', 'Burnt', { burntFunds: bigint }>;
 
     /**
      * Spending has finished; this is the amount that rolls over until next spend.
      **/
-    Rollover: GenericPalletEvent<Rv, 'Treasury', 'Rollover', { rolloverBalance: bigint }>;
+    Rollover: GenericPalletEvent<'Treasury', 'Rollover', { rolloverBalance: bigint }>;
 
     /**
      * Some funds have been deposited.
      **/
-    Deposit: GenericPalletEvent<Rv, 'Treasury', 'Deposit', { value: bigint }>;
+    Deposit: GenericPalletEvent<'Treasury', 'Deposit', { value: bigint }>;
 
     /**
      * A new spend proposal has been approved.
      **/
     SpendApproved: GenericPalletEvent<
-      Rv,
       'Treasury',
       'SpendApproved',
       { proposalIndex: number; amount: bigint; beneficiary: AccountId32 }
@@ -1139,18 +1068,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The inactive funds of the pallet have been updated.
      **/
-    UpdatedInactive: GenericPalletEvent<
-      Rv,
-      'Treasury',
-      'UpdatedInactive',
-      { reactivated: bigint; deactivated: bigint }
-    >;
+    UpdatedInactive: GenericPalletEvent<'Treasury', 'UpdatedInactive', { reactivated: bigint; deactivated: bigint }>;
 
     /**
      * A new asset spend proposal has been approved.
      **/
     AssetSpendApproved: GenericPalletEvent<
-      Rv,
       'Treasury',
       'AssetSpendApproved',
       {
@@ -1166,47 +1089,44 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An approved spend was voided.
      **/
-    AssetSpendVoided: GenericPalletEvent<Rv, 'Treasury', 'AssetSpendVoided', { index: number }>;
+    AssetSpendVoided: GenericPalletEvent<'Treasury', 'AssetSpendVoided', { index: number }>;
 
     /**
      * A payment happened.
      **/
-    Paid: GenericPalletEvent<Rv, 'Treasury', 'Paid', { index: number; paymentId: [] }>;
+    Paid: GenericPalletEvent<'Treasury', 'Paid', { index: number; paymentId: [] }>;
 
     /**
      * A payment failed and can be retried.
      **/
-    PaymentFailed: GenericPalletEvent<Rv, 'Treasury', 'PaymentFailed', { index: number; paymentId: [] }>;
+    PaymentFailed: GenericPalletEvent<'Treasury', 'PaymentFailed', { index: number; paymentId: [] }>;
 
     /**
      * A spend was processed and removed from the storage. It might have been successfully
      * paid or it may have expired.
      **/
-    SpendProcessed: GenericPalletEvent<Rv, 'Treasury', 'SpendProcessed', { index: number }>;
+    SpendProcessed: GenericPalletEvent<'Treasury', 'SpendProcessed', { index: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetRate`'s events
    **/
   assetRate: {
     AssetRateCreated: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateCreated',
       { assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId; rate: FixedU128 }
     >;
     AssetRateRemoved: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateRemoved',
       { assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId }
     >;
     AssetRateUpdated: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateUpdated',
       { assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId; old: FixedU128; new: FixedU128 }
@@ -1215,7 +1135,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Contracts`'s events
@@ -1224,7 +1144,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Contract deployed by address at the specified address.
      **/
-    Instantiated: GenericPalletEvent<Rv, 'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
+    Instantiated: GenericPalletEvent<'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
 
     /**
      * Contract has been removed.
@@ -1235,7 +1155,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `seal_terminate`.
      **/
     Terminated: GenericPalletEvent<
-      Rv,
       'Contracts',
       'Terminated',
       {
@@ -1255,7 +1174,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Code with the specified hash has been stored.
      **/
     CodeStored: GenericPalletEvent<
-      Rv,
       'Contracts',
       'CodeStored',
       { codeHash: H256; depositHeld: bigint; uploader: AccountId32 }
@@ -1265,7 +1183,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A custom event emitted by the contract.
      **/
     ContractEmitted: GenericPalletEvent<
-      Rv,
       'Contracts',
       'ContractEmitted',
       {
@@ -1286,7 +1203,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A code with the specified hash was removed.
      **/
     CodeRemoved: GenericPalletEvent<
-      Rv,
       'Contracts',
       'CodeRemoved',
       { codeHash: H256; depositReleased: bigint; remover: AccountId32 }
@@ -1296,7 +1212,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A contract's code was updated.
      **/
     ContractCodeUpdated: GenericPalletEvent<
-      Rv,
       'Contracts',
       'ContractCodeUpdated',
       {
@@ -1327,7 +1242,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * rolled back.
      **/
     Called: GenericPalletEvent<
-      Rv,
       'Contracts',
       'Called',
       {
@@ -1353,7 +1267,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * rolled back.
      **/
     DelegateCalled: GenericPalletEvent<
-      Rv,
       'Contracts',
       'DelegateCalled',
       {
@@ -1374,7 +1287,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some funds have been transferred and held as storage deposit.
      **/
     StorageDepositTransferredAndHeld: GenericPalletEvent<
-      Rv,
       'Contracts',
       'StorageDepositTransferredAndHeld',
       { from: AccountId32; to: AccountId32; amount: bigint }
@@ -1384,7 +1296,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some storage deposit funds have been transferred and released.
      **/
     StorageDepositTransferredAndReleased: GenericPalletEvent<
-      Rv,
       'Contracts',
       'StorageDepositTransferredAndReleased',
       { from: AccountId32; to: AccountId32; amount: bigint }
@@ -1393,7 +1304,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Sudo`'s events
@@ -1403,7 +1314,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A sudo call just took place.
      **/
     Sudid: GenericPalletEvent<
-      Rv,
       'Sudo',
       'Sudid',
       {
@@ -1418,7 +1328,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The sudo key has been updated.
      **/
     KeyChanged: GenericPalletEvent<
-      Rv,
       'Sudo',
       'KeyChanged',
       {
@@ -1437,13 +1346,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The key was permanently removed.
      **/
-    KeyRemoved: GenericPalletEvent<Rv, 'Sudo', 'KeyRemoved', null>;
+    KeyRemoved: GenericPalletEvent<'Sudo', 'KeyRemoved', null>;
 
     /**
      * A [sudo_as](Pallet::sudo_as) call just took place.
      **/
     SudoAsDone: GenericPalletEvent<
-      Rv,
       'Sudo',
       'SudoAsDone',
       {
@@ -1457,7 +1365,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ImOnline`'s events
@@ -1467,7 +1375,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new heartbeat was received from `AuthorityId`.
      **/
     HeartbeatReceived: GenericPalletEvent<
-      Rv,
       'ImOnline',
       'HeartbeatReceived',
       { authorityId: PalletImOnlineSr25519AppSr25519Public }
@@ -1476,17 +1383,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * At the end of the session, no offence was committed.
      **/
-    AllGood: GenericPalletEvent<Rv, 'ImOnline', 'AllGood', null>;
+    AllGood: GenericPalletEvent<'ImOnline', 'AllGood', null>;
 
     /**
      * At the end of the session, at least one validator was found to be offline.
      **/
-    SomeOffline: GenericPalletEvent<Rv, 'ImOnline', 'SomeOffline', { offline: Array<[AccountId32, []]> }>;
+    SomeOffline: GenericPalletEvent<'ImOnline', 'SomeOffline', { offline: Array<[AccountId32, []]> }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Offences`'s events
@@ -1497,12 +1404,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * (kind-specific) time slot. This event is not deposited for duplicate slashes.
      * \[kind, timeslot\].
      **/
-    Offence: GenericPalletEvent<Rv, 'Offences', 'Offence', { kind: FixedBytes<16>; timeslot: Bytes }>;
+    Offence: GenericPalletEvent<'Offences', 'Offence', { kind: FixedBytes<16>; timeslot: Bytes }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Identity`'s events
@@ -1511,23 +1418,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A name was set or reset (which will remove all judgements).
      **/
-    IdentitySet: GenericPalletEvent<Rv, 'Identity', 'IdentitySet', { who: AccountId32 }>;
+    IdentitySet: GenericPalletEvent<'Identity', 'IdentitySet', { who: AccountId32 }>;
 
     /**
      * A name was cleared, and the given balance returned.
      **/
-    IdentityCleared: GenericPalletEvent<Rv, 'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
+    IdentityCleared: GenericPalletEvent<'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A name was removed and the given balance slashed.
      **/
-    IdentityKilled: GenericPalletEvent<Rv, 'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
+    IdentityKilled: GenericPalletEvent<'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A judgement was asked from a registrar.
      **/
     JudgementRequested: GenericPalletEvent<
-      Rv,
       'Identity',
       'JudgementRequested',
       { who: AccountId32; registrarIndex: number }
@@ -1537,7 +1443,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A judgement request was retracted.
      **/
     JudgementUnrequested: GenericPalletEvent<
-      Rv,
       'Identity',
       'JudgementUnrequested',
       { who: AccountId32; registrarIndex: number }
@@ -1546,23 +1451,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A judgement was given by a registrar.
      **/
-    JudgementGiven: GenericPalletEvent<
-      Rv,
-      'Identity',
-      'JudgementGiven',
-      { target: AccountId32; registrarIndex: number }
-    >;
+    JudgementGiven: GenericPalletEvent<'Identity', 'JudgementGiven', { target: AccountId32; registrarIndex: number }>;
 
     /**
      * A registrar was added.
      **/
-    RegistrarAdded: GenericPalletEvent<Rv, 'Identity', 'RegistrarAdded', { registrarIndex: number }>;
+    RegistrarAdded: GenericPalletEvent<'Identity', 'RegistrarAdded', { registrarIndex: number }>;
 
     /**
      * A sub-identity was added to an identity and the deposit paid.
      **/
     SubIdentityAdded: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityAdded',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -1572,7 +1471,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account's sub-identities were set (in bulk).
      **/
     SubIdentitiesSet: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentitiesSet',
       { main: AccountId32; numberOfSubs: number; newDeposit: bigint }
@@ -1581,18 +1479,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A given sub-account's associated name was changed by its super-identity.
      **/
-    SubIdentityRenamed: GenericPalletEvent<
-      Rv,
-      'Identity',
-      'SubIdentityRenamed',
-      { sub: AccountId32; main: AccountId32 }
-    >;
+    SubIdentityRenamed: GenericPalletEvent<'Identity', 'SubIdentityRenamed', { sub: AccountId32; main: AccountId32 }>;
 
     /**
      * A sub-identity was removed from an identity and the deposit freed.
      **/
     SubIdentityRemoved: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityRemoved',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -1603,7 +1495,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * main identity account to the sub-identity account.
      **/
     SubIdentityRevoked: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityRevoked',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -1612,23 +1503,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A username authority was added.
      **/
-    AuthorityAdded: GenericPalletEvent<Rv, 'Identity', 'AuthorityAdded', { authority: AccountId32 }>;
+    AuthorityAdded: GenericPalletEvent<'Identity', 'AuthorityAdded', { authority: AccountId32 }>;
 
     /**
      * A username authority was removed.
      **/
-    AuthorityRemoved: GenericPalletEvent<Rv, 'Identity', 'AuthorityRemoved', { authority: AccountId32 }>;
+    AuthorityRemoved: GenericPalletEvent<'Identity', 'AuthorityRemoved', { authority: AccountId32 }>;
 
     /**
      * A username was set for `who`.
      **/
-    UsernameSet: GenericPalletEvent<Rv, 'Identity', 'UsernameSet', { who: AccountId32; username: Bytes }>;
+    UsernameSet: GenericPalletEvent<'Identity', 'UsernameSet', { who: AccountId32; username: Bytes }>;
 
     /**
      * A username was queued, but `who` must accept it prior to `expiration`.
      **/
     UsernameQueued: GenericPalletEvent<
-      Rv,
       'Identity',
       'UsernameQueued',
       { who: AccountId32; username: Bytes; expiration: number }
@@ -1637,19 +1527,18 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A queued username passed its expiration without being claimed and was removed.
      **/
-    PreapprovalExpired: GenericPalletEvent<Rv, 'Identity', 'PreapprovalExpired', { whose: AccountId32 }>;
+    PreapprovalExpired: GenericPalletEvent<'Identity', 'PreapprovalExpired', { whose: AccountId32 }>;
 
     /**
      * A username was set as a primary and can be looked up from `who`.
      **/
-    PrimaryUsernameSet: GenericPalletEvent<Rv, 'Identity', 'PrimaryUsernameSet', { who: AccountId32; username: Bytes }>;
+    PrimaryUsernameSet: GenericPalletEvent<'Identity', 'PrimaryUsernameSet', { who: AccountId32; username: Bytes }>;
 
     /**
      * A dangling username (as in, a username corresponding to an account that has removed its
      * identity) has been removed.
      **/
     DanglingUsernameRemoved: GenericPalletEvent<
-      Rv,
       'Identity',
       'DanglingUsernameRemoved',
       { who: AccountId32; username: Bytes }
@@ -1658,22 +1547,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A username has been unbound.
      **/
-    UsernameUnbound: GenericPalletEvent<Rv, 'Identity', 'UsernameUnbound', { username: Bytes }>;
+    UsernameUnbound: GenericPalletEvent<'Identity', 'UsernameUnbound', { username: Bytes }>;
 
     /**
      * A username has been removed.
      **/
-    UsernameRemoved: GenericPalletEvent<Rv, 'Identity', 'UsernameRemoved', { username: Bytes }>;
+    UsernameRemoved: GenericPalletEvent<'Identity', 'UsernameRemoved', { username: Bytes }>;
 
     /**
      * A username has been killed.
      **/
-    UsernameKilled: GenericPalletEvent<Rv, 'Identity', 'UsernameKilled', { username: Bytes }>;
+    UsernameKilled: GenericPalletEvent<'Identity', 'UsernameKilled', { username: Bytes }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Society`'s events
@@ -1682,51 +1571,45 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The society is founded by the given identity.
      **/
-    Founded: GenericPalletEvent<Rv, 'Society', 'Founded', { founder: AccountId32 }>;
+    Founded: GenericPalletEvent<'Society', 'Founded', { founder: AccountId32 }>;
 
     /**
      * A membership bid just happened. The given account is the candidate's ID and their offer
      * is the second.
      **/
-    Bid: GenericPalletEvent<Rv, 'Society', 'Bid', { candidateId: AccountId32; offer: bigint }>;
+    Bid: GenericPalletEvent<'Society', 'Bid', { candidateId: AccountId32; offer: bigint }>;
 
     /**
      * A membership bid just happened by vouching. The given account is the candidate's ID and
      * their offer is the second. The vouching party is the third.
      **/
-    Vouch: GenericPalletEvent<
-      Rv,
-      'Society',
-      'Vouch',
-      { candidateId: AccountId32; offer: bigint; vouching: AccountId32 }
-    >;
+    Vouch: GenericPalletEvent<'Society', 'Vouch', { candidateId: AccountId32; offer: bigint; vouching: AccountId32 }>;
 
     /**
      * A candidate was dropped (due to an excess of bids in the system).
      **/
-    AutoUnbid: GenericPalletEvent<Rv, 'Society', 'AutoUnbid', { candidate: AccountId32 }>;
+    AutoUnbid: GenericPalletEvent<'Society', 'AutoUnbid', { candidate: AccountId32 }>;
 
     /**
      * A candidate was dropped (by their request).
      **/
-    Unbid: GenericPalletEvent<Rv, 'Society', 'Unbid', { candidate: AccountId32 }>;
+    Unbid: GenericPalletEvent<'Society', 'Unbid', { candidate: AccountId32 }>;
 
     /**
      * A candidate was dropped (by request of who vouched for them).
      **/
-    Unvouch: GenericPalletEvent<Rv, 'Society', 'Unvouch', { candidate: AccountId32 }>;
+    Unvouch: GenericPalletEvent<'Society', 'Unvouch', { candidate: AccountId32 }>;
 
     /**
      * A group of candidates have been inducted. The batch's primary is the first value, the
      * batch in full is the second.
      **/
-    Inducted: GenericPalletEvent<Rv, 'Society', 'Inducted', { primary: AccountId32; candidates: Array<AccountId32> }>;
+    Inducted: GenericPalletEvent<'Society', 'Inducted', { primary: AccountId32; candidates: Array<AccountId32> }>;
 
     /**
      * A suspended member has been judged.
      **/
     SuspendedMemberJudgement: GenericPalletEvent<
-      Rv,
       'Society',
       'SuspendedMemberJudgement',
       { who: AccountId32; judged: boolean }
@@ -1735,52 +1618,52 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A candidate has been suspended
      **/
-    CandidateSuspended: GenericPalletEvent<Rv, 'Society', 'CandidateSuspended', { candidate: AccountId32 }>;
+    CandidateSuspended: GenericPalletEvent<'Society', 'CandidateSuspended', { candidate: AccountId32 }>;
 
     /**
      * A member has been suspended
      **/
-    MemberSuspended: GenericPalletEvent<Rv, 'Society', 'MemberSuspended', { member: AccountId32 }>;
+    MemberSuspended: GenericPalletEvent<'Society', 'MemberSuspended', { member: AccountId32 }>;
 
     /**
      * A member has been challenged
      **/
-    Challenged: GenericPalletEvent<Rv, 'Society', 'Challenged', { member: AccountId32 }>;
+    Challenged: GenericPalletEvent<'Society', 'Challenged', { member: AccountId32 }>;
 
     /**
      * A vote has been placed
      **/
-    Vote: GenericPalletEvent<Rv, 'Society', 'Vote', { candidate: AccountId32; voter: AccountId32; vote: boolean }>;
+    Vote: GenericPalletEvent<'Society', 'Vote', { candidate: AccountId32; voter: AccountId32; vote: boolean }>;
 
     /**
      * A vote has been placed for a defending member
      **/
-    DefenderVote: GenericPalletEvent<Rv, 'Society', 'DefenderVote', { voter: AccountId32; vote: boolean }>;
+    DefenderVote: GenericPalletEvent<'Society', 'DefenderVote', { voter: AccountId32; vote: boolean }>;
 
     /**
      * A new set of \[params\] has been set for the group.
      **/
-    NewParams: GenericPalletEvent<Rv, 'Society', 'NewParams', { params: PalletSocietyGroupParams }>;
+    NewParams: GenericPalletEvent<'Society', 'NewParams', { params: PalletSocietyGroupParams }>;
 
     /**
      * Society is unfounded.
      **/
-    Unfounded: GenericPalletEvent<Rv, 'Society', 'Unfounded', { founder: AccountId32 }>;
+    Unfounded: GenericPalletEvent<'Society', 'Unfounded', { founder: AccountId32 }>;
 
     /**
      * Some funds were deposited into the society account.
      **/
-    Deposit: GenericPalletEvent<Rv, 'Society', 'Deposit', { value: bigint }>;
+    Deposit: GenericPalletEvent<'Society', 'Deposit', { value: bigint }>;
 
     /**
      * A \[member\] got elevated to \[rank\].
      **/
-    Elevated: GenericPalletEvent<Rv, 'Society', 'Elevated', { member: AccountId32; rank: number }>;
+    Elevated: GenericPalletEvent<'Society', 'Elevated', { member: AccountId32; rank: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Recovery`'s events
@@ -1789,13 +1672,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A recovery process has been set up for an account.
      **/
-    RecoveryCreated: GenericPalletEvent<Rv, 'Recovery', 'RecoveryCreated', { account: AccountId32 }>;
+    RecoveryCreated: GenericPalletEvent<'Recovery', 'RecoveryCreated', { account: AccountId32 }>;
 
     /**
      * A recovery process has been initiated for lost account by rescuer account.
      **/
     RecoveryInitiated: GenericPalletEvent<
-      Rv,
       'Recovery',
       'RecoveryInitiated',
       { lostAccount: AccountId32; rescuerAccount: AccountId32 }
@@ -1805,7 +1687,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A recovery process for lost account by rescuer account has been vouched for by sender.
      **/
     RecoveryVouched: GenericPalletEvent<
-      Rv,
       'Recovery',
       'RecoveryVouched',
       { lostAccount: AccountId32; rescuerAccount: AccountId32; sender: AccountId32 }
@@ -1815,7 +1696,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A recovery process for lost account by rescuer account has been closed.
      **/
     RecoveryClosed: GenericPalletEvent<
-      Rv,
       'Recovery',
       'RecoveryClosed',
       { lostAccount: AccountId32; rescuerAccount: AccountId32 }
@@ -1825,7 +1705,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Lost account has been successfully recovered by rescuer account.
      **/
     AccountRecovered: GenericPalletEvent<
-      Rv,
       'Recovery',
       'AccountRecovered',
       { lostAccount: AccountId32; rescuerAccount: AccountId32 }
@@ -1834,12 +1713,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A recovery process has been removed for an account.
      **/
-    RecoveryRemoved: GenericPalletEvent<Rv, 'Recovery', 'RecoveryRemoved', { lostAccount: AccountId32 }>;
+    RecoveryRemoved: GenericPalletEvent<'Recovery', 'RecoveryRemoved', { lostAccount: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Vesting`'s events
@@ -1849,17 +1728,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The amount vested has been updated. This could indicate a change in funds available.
      * The balance given is the amount which is left unvested (and thus locked).
      **/
-    VestingUpdated: GenericPalletEvent<Rv, 'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
+    VestingUpdated: GenericPalletEvent<'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
 
     /**
      * An \[account\] has become fully vested.
      **/
-    VestingCompleted: GenericPalletEvent<Rv, 'Vesting', 'VestingCompleted', { account: AccountId32 }>;
+    VestingCompleted: GenericPalletEvent<'Vesting', 'VestingCompleted', { account: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Scheduler`'s events
@@ -1868,18 +1747,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Scheduled some task.
      **/
-    Scheduled: GenericPalletEvent<Rv, 'Scheduler', 'Scheduled', { when: number; index: number }>;
+    Scheduled: GenericPalletEvent<'Scheduler', 'Scheduled', { when: number; index: number }>;
 
     /**
      * Canceled some task.
      **/
-    Canceled: GenericPalletEvent<Rv, 'Scheduler', 'Canceled', { when: number; index: number }>;
+    Canceled: GenericPalletEvent<'Scheduler', 'Canceled', { when: number; index: number }>;
 
     /**
      * Dispatched some task.
      **/
     Dispatched: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'Dispatched',
       { task: [number, number]; id?: FixedBytes<32> | undefined; result: Result<[], DispatchError> }
@@ -1889,7 +1767,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Set a retry configuration for some task.
      **/
     RetrySet: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'RetrySet',
       { task: [number, number]; id?: FixedBytes<32> | undefined; period: number; retries: number }
@@ -1899,7 +1776,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Cancel a retry configuration for some task.
      **/
     RetryCancelled: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'RetryCancelled',
       { task: [number, number]; id?: FixedBytes<32> | undefined }
@@ -1909,7 +1785,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The call for the provided hash was not found so the task has been aborted.
      **/
     CallUnavailable: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'CallUnavailable',
       { task: [number, number]; id?: FixedBytes<32> | undefined }
@@ -1919,7 +1794,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The given task was unable to be renewed since the agenda is full at that block.
      **/
     PeriodicFailed: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'PeriodicFailed',
       { task: [number, number]; id?: FixedBytes<32> | undefined }
@@ -1930,7 +1804,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * was not enough weight to reschedule it.
      **/
     RetryFailed: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'RetryFailed',
       { task: [number, number]; id?: FixedBytes<32> | undefined }
@@ -1940,7 +1813,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The given task can never be executed since it is overweight.
      **/
     PermanentlyOverweight: GenericPalletEvent<
-      Rv,
       'Scheduler',
       'PermanentlyOverweight',
       { task: [number, number]; id?: FixedBytes<32> | undefined }
@@ -1949,12 +1821,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Agenda is incomplete from `when`.
      **/
-    AgendaIncomplete: GenericPalletEvent<Rv, 'Scheduler', 'AgendaIncomplete', { when: number }>;
+    AgendaIncomplete: GenericPalletEvent<'Scheduler', 'AgendaIncomplete', { when: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Glutton`'s events
@@ -1964,7 +1836,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The pallet has been (re)initialized.
      **/
     PalletInitialized: GenericPalletEvent<
-      Rv,
       'Glutton',
       'PalletInitialized',
       {
@@ -1979,7 +1850,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The computation limit has been updated.
      **/
     ComputationLimitSet: GenericPalletEvent<
-      Rv,
       'Glutton',
       'ComputationLimitSet',
       {
@@ -1994,7 +1864,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The storage limit has been updated.
      **/
     StorageLimitSet: GenericPalletEvent<
-      Rv,
       'Glutton',
       'StorageLimitSet',
       {
@@ -2009,7 +1878,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The block length limit has been updated.
      **/
     BlockLengthLimitSet: GenericPalletEvent<
-      Rv,
       'Glutton',
       'BlockLengthLimitSet',
       {
@@ -2023,7 +1891,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Preimage`'s events
@@ -2032,22 +1900,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A preimage has been noted.
      **/
-    Noted: GenericPalletEvent<Rv, 'Preimage', 'Noted', { hash: H256 }>;
+    Noted: GenericPalletEvent<'Preimage', 'Noted', { hash: H256 }>;
 
     /**
      * A preimage has been requested.
      **/
-    Requested: GenericPalletEvent<Rv, 'Preimage', 'Requested', { hash: H256 }>;
+    Requested: GenericPalletEvent<'Preimage', 'Requested', { hash: H256 }>;
 
     /**
      * A preimage has ben cleared.
      **/
-    Cleared: GenericPalletEvent<Rv, 'Preimage', 'Cleared', { hash: H256 }>;
+    Cleared: GenericPalletEvent<'Preimage', 'Cleared', { hash: H256 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Proxy`'s events
@@ -2056,14 +1924,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proxy was executed correctly, with the given.
      **/
-    ProxyExecuted: GenericPalletEvent<Rv, 'Proxy', 'ProxyExecuted', { result: Result<[], DispatchError> }>;
+    ProxyExecuted: GenericPalletEvent<'Proxy', 'ProxyExecuted', { result: Result<[], DispatchError> }>;
 
     /**
      * A pure account has been created by new proxy with given
      * disambiguation index and proxy type.
      **/
     PureCreated: GenericPalletEvent<
-      Rv,
       'Proxy',
       'PureCreated',
       { pure: AccountId32; who: AccountId32; proxyType: KitchensinkRuntimeProxyType; disambiguationIndex: number }
@@ -2072,13 +1939,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An announcement was placed to make a call in the future.
      **/
-    Announced: GenericPalletEvent<Rv, 'Proxy', 'Announced', { real: AccountId32; proxy: AccountId32; callHash: H256 }>;
+    Announced: GenericPalletEvent<'Proxy', 'Announced', { real: AccountId32; proxy: AccountId32; callHash: H256 }>;
 
     /**
      * A proxy was added.
      **/
     ProxyAdded: GenericPalletEvent<
-      Rv,
       'Proxy',
       'ProxyAdded',
       { delegator: AccountId32; delegatee: AccountId32; proxyType: KitchensinkRuntimeProxyType; delay: number }
@@ -2088,7 +1954,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proxy was removed.
      **/
     ProxyRemoved: GenericPalletEvent<
-      Rv,
       'Proxy',
       'ProxyRemoved',
       { delegator: AccountId32; delegatee: AccountId32; proxyType: KitchensinkRuntimeProxyType; delay: number }
@@ -2098,7 +1963,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A deposit stored for proxies or announcements was poked / updated.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Proxy',
       'DepositPoked',
       { who: AccountId32; kind: PalletProxyDepositKind; oldDeposit: bigint; newDeposit: bigint }
@@ -2107,7 +1971,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Multisig`'s events
@@ -2117,7 +1981,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new multisig operation has begun.
      **/
     NewMultisig: GenericPalletEvent<
-      Rv,
       'Multisig',
       'NewMultisig',
       { approving: AccountId32; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -2127,7 +1990,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A multisig operation has been approved by someone.
      **/
     MultisigApproval: GenericPalletEvent<
-      Rv,
       'Multisig',
       'MultisigApproval',
       { approving: AccountId32; timepoint: PalletMultisigTimepoint; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -2137,7 +1999,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A multisig operation has been executed.
      **/
     MultisigExecuted: GenericPalletEvent<
-      Rv,
       'Multisig',
       'MultisigExecuted',
       {
@@ -2153,7 +2014,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A multisig operation has been cancelled.
      **/
     MultisigCancelled: GenericPalletEvent<
-      Rv,
       'Multisig',
       'MultisigCancelled',
       { cancelling: AccountId32; timepoint: PalletMultisigTimepoint; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -2163,7 +2023,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The deposit for a multisig operation has been updated/poked.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Multisig',
       'DepositPoked',
       { who: AccountId32; callHash: FixedBytes<32>; oldDeposit: bigint; newDeposit: bigint }
@@ -2172,7 +2031,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Bounties`'s events
@@ -2181,28 +2040,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New bounty proposal.
      **/
-    BountyProposed: GenericPalletEvent<Rv, 'Bounties', 'BountyProposed', { index: number }>;
+    BountyProposed: GenericPalletEvent<'Bounties', 'BountyProposed', { index: number }>;
 
     /**
      * A bounty proposal was rejected; funds were slashed.
      **/
-    BountyRejected: GenericPalletEvent<Rv, 'Bounties', 'BountyRejected', { index: number; bond: bigint }>;
+    BountyRejected: GenericPalletEvent<'Bounties', 'BountyRejected', { index: number; bond: bigint }>;
 
     /**
      * A bounty proposal is funded and became active.
      **/
-    BountyBecameActive: GenericPalletEvent<Rv, 'Bounties', 'BountyBecameActive', { index: number }>;
+    BountyBecameActive: GenericPalletEvent<'Bounties', 'BountyBecameActive', { index: number }>;
 
     /**
      * A bounty is awarded to a beneficiary.
      **/
-    BountyAwarded: GenericPalletEvent<Rv, 'Bounties', 'BountyAwarded', { index: number; beneficiary: AccountId32 }>;
+    BountyAwarded: GenericPalletEvent<'Bounties', 'BountyAwarded', { index: number; beneficiary: AccountId32 }>;
 
     /**
      * A bounty is claimed by beneficiary.
      **/
     BountyClaimed: GenericPalletEvent<
-      Rv,
       'Bounties',
       'BountyClaimed',
       { index: number; payout: bigint; beneficiary: AccountId32 }
@@ -2211,37 +2069,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A bounty is cancelled.
      **/
-    BountyCanceled: GenericPalletEvent<Rv, 'Bounties', 'BountyCanceled', { index: number }>;
+    BountyCanceled: GenericPalletEvent<'Bounties', 'BountyCanceled', { index: number }>;
 
     /**
      * A bounty expiry is extended.
      **/
-    BountyExtended: GenericPalletEvent<Rv, 'Bounties', 'BountyExtended', { index: number }>;
+    BountyExtended: GenericPalletEvent<'Bounties', 'BountyExtended', { index: number }>;
 
     /**
      * A bounty is approved.
      **/
-    BountyApproved: GenericPalletEvent<Rv, 'Bounties', 'BountyApproved', { index: number }>;
+    BountyApproved: GenericPalletEvent<'Bounties', 'BountyApproved', { index: number }>;
 
     /**
      * A bounty curator is proposed.
      **/
-    CuratorProposed: GenericPalletEvent<Rv, 'Bounties', 'CuratorProposed', { bountyId: number; curator: AccountId32 }>;
+    CuratorProposed: GenericPalletEvent<'Bounties', 'CuratorProposed', { bountyId: number; curator: AccountId32 }>;
 
     /**
      * A bounty curator is unassigned.
      **/
-    CuratorUnassigned: GenericPalletEvent<Rv, 'Bounties', 'CuratorUnassigned', { bountyId: number }>;
+    CuratorUnassigned: GenericPalletEvent<'Bounties', 'CuratorUnassigned', { bountyId: number }>;
 
     /**
      * A bounty curator is accepted.
      **/
-    CuratorAccepted: GenericPalletEvent<Rv, 'Bounties', 'CuratorAccepted', { bountyId: number; curator: AccountId32 }>;
+    CuratorAccepted: GenericPalletEvent<'Bounties', 'CuratorAccepted', { bountyId: number; curator: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Tips`'s events
@@ -2250,32 +2108,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A new tip suggestion has been opened.
      **/
-    NewTip: GenericPalletEvent<Rv, 'Tips', 'NewTip', { tipHash: H256 }>;
+    NewTip: GenericPalletEvent<'Tips', 'NewTip', { tipHash: H256 }>;
 
     /**
      * A tip suggestion has reached threshold and is closing.
      **/
-    TipClosing: GenericPalletEvent<Rv, 'Tips', 'TipClosing', { tipHash: H256 }>;
+    TipClosing: GenericPalletEvent<'Tips', 'TipClosing', { tipHash: H256 }>;
 
     /**
      * A tip suggestion has been closed.
      **/
-    TipClosed: GenericPalletEvent<Rv, 'Tips', 'TipClosed', { tipHash: H256; who: AccountId32; payout: bigint }>;
+    TipClosed: GenericPalletEvent<'Tips', 'TipClosed', { tipHash: H256; who: AccountId32; payout: bigint }>;
 
     /**
      * A tip suggestion has been retracted.
      **/
-    TipRetracted: GenericPalletEvent<Rv, 'Tips', 'TipRetracted', { tipHash: H256 }>;
+    TipRetracted: GenericPalletEvent<'Tips', 'TipRetracted', { tipHash: H256 }>;
 
     /**
      * A tip suggestion has been slashed.
      **/
-    TipSlashed: GenericPalletEvent<Rv, 'Tips', 'TipSlashed', { tipHash: H256; finder: AccountId32; deposit: bigint }>;
+    TipSlashed: GenericPalletEvent<'Tips', 'TipSlashed', { tipHash: H256; finder: AccountId32; deposit: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Assets`'s events
@@ -2284,18 +2142,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some asset class was created.
      **/
-    Created: GenericPalletEvent<Rv, 'Assets', 'Created', { assetId: number; creator: AccountId32; owner: AccountId32 }>;
+    Created: GenericPalletEvent<'Assets', 'Created', { assetId: number; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * Some assets were issued.
      **/
-    Issued: GenericPalletEvent<Rv, 'Assets', 'Issued', { assetId: number; owner: AccountId32; amount: bigint }>;
+    Issued: GenericPalletEvent<'Assets', 'Issued', { assetId: number; owner: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'Assets',
       'Transferred',
       { assetId: number; from: AccountId32; to: AccountId32; amount: bigint }
@@ -2304,13 +2161,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some assets were destroyed.
      **/
-    Burned: GenericPalletEvent<Rv, 'Assets', 'Burned', { assetId: number; owner: AccountId32; balance: bigint }>;
+    Burned: GenericPalletEvent<'Assets', 'Burned', { assetId: number; owner: AccountId32; balance: bigint }>;
 
     /**
      * The management team changed.
      **/
     TeamChanged: GenericPalletEvent<
-      Rv,
       'Assets',
       'TeamChanged',
       { assetId: number; issuer: AccountId32; admin: AccountId32; freezer: AccountId32 }
@@ -2319,33 +2175,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<Rv, 'Assets', 'OwnerChanged', { assetId: number; owner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<'Assets', 'OwnerChanged', { assetId: number; owner: AccountId32 }>;
 
     /**
      * Some account `who` was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'Assets', 'Frozen', { assetId: number; who: AccountId32 }>;
+    Frozen: GenericPalletEvent<'Assets', 'Frozen', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some account `who` was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'Assets', 'Thawed', { assetId: number; who: AccountId32 }>;
+    Thawed: GenericPalletEvent<'Assets', 'Thawed', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some asset `asset_id` was frozen.
      **/
-    AssetFrozen: GenericPalletEvent<Rv, 'Assets', 'AssetFrozen', { assetId: number }>;
+    AssetFrozen: GenericPalletEvent<'Assets', 'AssetFrozen', { assetId: number }>;
 
     /**
      * Some asset `asset_id` was thawed.
      **/
-    AssetThawed: GenericPalletEvent<Rv, 'Assets', 'AssetThawed', { assetId: number }>;
+    AssetThawed: GenericPalletEvent<'Assets', 'AssetThawed', { assetId: number }>;
 
     /**
      * Accounts were destroyed for given asset.
      **/
     AccountsDestroyed: GenericPalletEvent<
-      Rv,
       'Assets',
       'AccountsDestroyed',
       { assetId: number; accountsDestroyed: number; accountsRemaining: number }
@@ -2355,7 +2210,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Approvals were destroyed for given asset.
      **/
     ApprovalsDestroyed: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovalsDestroyed',
       { assetId: number; approvalsDestroyed: number; approvalsRemaining: number }
@@ -2364,23 +2218,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset class is in the process of being destroyed.
      **/
-    DestructionStarted: GenericPalletEvent<Rv, 'Assets', 'DestructionStarted', { assetId: number }>;
+    DestructionStarted: GenericPalletEvent<'Assets', 'DestructionStarted', { assetId: number }>;
 
     /**
      * An asset class was destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'Assets', 'Destroyed', { assetId: number }>;
+    Destroyed: GenericPalletEvent<'Assets', 'Destroyed', { assetId: number }>;
 
     /**
      * Some asset class was force-created.
      **/
-    ForceCreated: GenericPalletEvent<Rv, 'Assets', 'ForceCreated', { assetId: number; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<'Assets', 'ForceCreated', { assetId: number; owner: AccountId32 }>;
 
     /**
      * New metadata has been set for an asset.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Assets',
       'MetadataSet',
       { assetId: number; name: Bytes; symbol: Bytes; decimals: number; isFrozen: boolean }
@@ -2389,13 +2242,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Metadata has been cleared for an asset.
      **/
-    MetadataCleared: GenericPalletEvent<Rv, 'Assets', 'MetadataCleared', { assetId: number }>;
+    MetadataCleared: GenericPalletEvent<'Assets', 'MetadataCleared', { assetId: number }>;
 
     /**
      * (Additional) funds have been approved for transfer to a destination account.
      **/
     ApprovedTransfer: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovedTransfer',
       { assetId: number; source: AccountId32; delegate: AccountId32; amount: bigint }
@@ -2405,7 +2257,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An approval for account `delegate` was cancelled by `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovalCancelled',
       { assetId: number; owner: AccountId32; delegate: AccountId32 }
@@ -2416,7 +2267,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * the approved `delegate`.
      **/
     TransferredApproved: GenericPalletEvent<
-      Rv,
       'Assets',
       'TransferredApproved',
       { assetId: number; owner: AccountId32; delegate: AccountId32; destination: AccountId32; amount: bigint }
@@ -2425,13 +2275,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset has had its attributes changed by the `Force` origin.
      **/
-    AssetStatusChanged: GenericPalletEvent<Rv, 'Assets', 'AssetStatusChanged', { assetId: number }>;
+    AssetStatusChanged: GenericPalletEvent<'Assets', 'AssetStatusChanged', { assetId: number }>;
 
     /**
      * The min_balance of an asset has been updated by the asset owner.
      **/
     AssetMinBalanceChanged: GenericPalletEvent<
-      Rv,
       'Assets',
       'AssetMinBalanceChanged',
       { assetId: number; newMinBalance: bigint }
@@ -2440,27 +2289,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some account `who` was created with a deposit from `depositor`.
      **/
-    Touched: GenericPalletEvent<Rv, 'Assets', 'Touched', { assetId: number; who: AccountId32; depositor: AccountId32 }>;
+    Touched: GenericPalletEvent<'Assets', 'Touched', { assetId: number; who: AccountId32; depositor: AccountId32 }>;
 
     /**
      * Some account `who` was blocked.
      **/
-    Blocked: GenericPalletEvent<Rv, 'Assets', 'Blocked', { assetId: number; who: AccountId32 }>;
+    Blocked: GenericPalletEvent<'Assets', 'Blocked', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some assets were deposited (e.g. for transaction fees).
      **/
-    Deposited: GenericPalletEvent<Rv, 'Assets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
+    Deposited: GenericPalletEvent<'Assets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdrawn: GenericPalletEvent<Rv, 'Assets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
+    Withdrawn: GenericPalletEvent<'Assets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `PoolAssets`'s events
@@ -2469,23 +2318,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some asset class was created.
      **/
-    Created: GenericPalletEvent<
-      Rv,
-      'PoolAssets',
-      'Created',
-      { assetId: number; creator: AccountId32; owner: AccountId32 }
-    >;
+    Created: GenericPalletEvent<'PoolAssets', 'Created', { assetId: number; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * Some assets were issued.
      **/
-    Issued: GenericPalletEvent<Rv, 'PoolAssets', 'Issued', { assetId: number; owner: AccountId32; amount: bigint }>;
+    Issued: GenericPalletEvent<'PoolAssets', 'Issued', { assetId: number; owner: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'Transferred',
       { assetId: number; from: AccountId32; to: AccountId32; amount: bigint }
@@ -2494,13 +2337,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some assets were destroyed.
      **/
-    Burned: GenericPalletEvent<Rv, 'PoolAssets', 'Burned', { assetId: number; owner: AccountId32; balance: bigint }>;
+    Burned: GenericPalletEvent<'PoolAssets', 'Burned', { assetId: number; owner: AccountId32; balance: bigint }>;
 
     /**
      * The management team changed.
      **/
     TeamChanged: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'TeamChanged',
       { assetId: number; issuer: AccountId32; admin: AccountId32; freezer: AccountId32 }
@@ -2509,33 +2351,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<Rv, 'PoolAssets', 'OwnerChanged', { assetId: number; owner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<'PoolAssets', 'OwnerChanged', { assetId: number; owner: AccountId32 }>;
 
     /**
      * Some account `who` was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'PoolAssets', 'Frozen', { assetId: number; who: AccountId32 }>;
+    Frozen: GenericPalletEvent<'PoolAssets', 'Frozen', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some account `who` was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'PoolAssets', 'Thawed', { assetId: number; who: AccountId32 }>;
+    Thawed: GenericPalletEvent<'PoolAssets', 'Thawed', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some asset `asset_id` was frozen.
      **/
-    AssetFrozen: GenericPalletEvent<Rv, 'PoolAssets', 'AssetFrozen', { assetId: number }>;
+    AssetFrozen: GenericPalletEvent<'PoolAssets', 'AssetFrozen', { assetId: number }>;
 
     /**
      * Some asset `asset_id` was thawed.
      **/
-    AssetThawed: GenericPalletEvent<Rv, 'PoolAssets', 'AssetThawed', { assetId: number }>;
+    AssetThawed: GenericPalletEvent<'PoolAssets', 'AssetThawed', { assetId: number }>;
 
     /**
      * Accounts were destroyed for given asset.
      **/
     AccountsDestroyed: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'AccountsDestroyed',
       { assetId: number; accountsDestroyed: number; accountsRemaining: number }
@@ -2545,7 +2386,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Approvals were destroyed for given asset.
      **/
     ApprovalsDestroyed: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'ApprovalsDestroyed',
       { assetId: number; approvalsDestroyed: number; approvalsRemaining: number }
@@ -2554,23 +2394,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset class is in the process of being destroyed.
      **/
-    DestructionStarted: GenericPalletEvent<Rv, 'PoolAssets', 'DestructionStarted', { assetId: number }>;
+    DestructionStarted: GenericPalletEvent<'PoolAssets', 'DestructionStarted', { assetId: number }>;
 
     /**
      * An asset class was destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'PoolAssets', 'Destroyed', { assetId: number }>;
+    Destroyed: GenericPalletEvent<'PoolAssets', 'Destroyed', { assetId: number }>;
 
     /**
      * Some asset class was force-created.
      **/
-    ForceCreated: GenericPalletEvent<Rv, 'PoolAssets', 'ForceCreated', { assetId: number; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<'PoolAssets', 'ForceCreated', { assetId: number; owner: AccountId32 }>;
 
     /**
      * New metadata has been set for an asset.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'MetadataSet',
       { assetId: number; name: Bytes; symbol: Bytes; decimals: number; isFrozen: boolean }
@@ -2579,13 +2418,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Metadata has been cleared for an asset.
      **/
-    MetadataCleared: GenericPalletEvent<Rv, 'PoolAssets', 'MetadataCleared', { assetId: number }>;
+    MetadataCleared: GenericPalletEvent<'PoolAssets', 'MetadataCleared', { assetId: number }>;
 
     /**
      * (Additional) funds have been approved for transfer to a destination account.
      **/
     ApprovedTransfer: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'ApprovedTransfer',
       { assetId: number; source: AccountId32; delegate: AccountId32; amount: bigint }
@@ -2595,7 +2433,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An approval for account `delegate` was cancelled by `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'ApprovalCancelled',
       { assetId: number; owner: AccountId32; delegate: AccountId32 }
@@ -2606,7 +2443,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * the approved `delegate`.
      **/
     TransferredApproved: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'TransferredApproved',
       { assetId: number; owner: AccountId32; delegate: AccountId32; destination: AccountId32; amount: bigint }
@@ -2615,13 +2451,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset has had its attributes changed by the `Force` origin.
      **/
-    AssetStatusChanged: GenericPalletEvent<Rv, 'PoolAssets', 'AssetStatusChanged', { assetId: number }>;
+    AssetStatusChanged: GenericPalletEvent<'PoolAssets', 'AssetStatusChanged', { assetId: number }>;
 
     /**
      * The min_balance of an asset has been updated by the asset owner.
      **/
     AssetMinBalanceChanged: GenericPalletEvent<
-      Rv,
       'PoolAssets',
       'AssetMinBalanceChanged',
       { assetId: number; newMinBalance: bigint }
@@ -2630,32 +2465,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some account `who` was created with a deposit from `depositor`.
      **/
-    Touched: GenericPalletEvent<
-      Rv,
-      'PoolAssets',
-      'Touched',
-      { assetId: number; who: AccountId32; depositor: AccountId32 }
-    >;
+    Touched: GenericPalletEvent<'PoolAssets', 'Touched', { assetId: number; who: AccountId32; depositor: AccountId32 }>;
 
     /**
      * Some account `who` was blocked.
      **/
-    Blocked: GenericPalletEvent<Rv, 'PoolAssets', 'Blocked', { assetId: number; who: AccountId32 }>;
+    Blocked: GenericPalletEvent<'PoolAssets', 'Blocked', { assetId: number; who: AccountId32 }>;
 
     /**
      * Some assets were deposited (e.g. for transaction fees).
      **/
-    Deposited: GenericPalletEvent<Rv, 'PoolAssets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
+    Deposited: GenericPalletEvent<'PoolAssets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdrawn: GenericPalletEvent<Rv, 'PoolAssets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
+    Withdrawn: GenericPalletEvent<'PoolAssets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Lottery`'s events
@@ -2664,27 +2494,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A lottery has been started!
      **/
-    LotteryStarted: GenericPalletEvent<Rv, 'Lottery', 'LotteryStarted', null>;
+    LotteryStarted: GenericPalletEvent<'Lottery', 'LotteryStarted', null>;
 
     /**
      * A new set of calls have been set!
      **/
-    CallsUpdated: GenericPalletEvent<Rv, 'Lottery', 'CallsUpdated', null>;
+    CallsUpdated: GenericPalletEvent<'Lottery', 'CallsUpdated', null>;
 
     /**
      * A winner has been chosen!
      **/
-    Winner: GenericPalletEvent<Rv, 'Lottery', 'Winner', { winner: AccountId32; lotteryBalance: bigint }>;
+    Winner: GenericPalletEvent<'Lottery', 'Winner', { winner: AccountId32; lotteryBalance: bigint }>;
 
     /**
      * A ticket has been bought!
      **/
-    TicketBought: GenericPalletEvent<Rv, 'Lottery', 'TicketBought', { who: AccountId32; callIndex: [number, number] }>;
+    TicketBought: GenericPalletEvent<'Lottery', 'TicketBought', { who: AccountId32; callIndex: [number, number] }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Nis`'s events
@@ -2693,23 +2523,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A bid was successfully placed.
      **/
-    BidPlaced: GenericPalletEvent<Rv, 'Nis', 'BidPlaced', { who: AccountId32; amount: bigint; duration: number }>;
+    BidPlaced: GenericPalletEvent<'Nis', 'BidPlaced', { who: AccountId32; amount: bigint; duration: number }>;
 
     /**
      * A bid was successfully removed (before being accepted).
      **/
-    BidRetracted: GenericPalletEvent<Rv, 'Nis', 'BidRetracted', { who: AccountId32; amount: bigint; duration: number }>;
+    BidRetracted: GenericPalletEvent<'Nis', 'BidRetracted', { who: AccountId32; amount: bigint; duration: number }>;
 
     /**
      * A bid was dropped from a queue because of another, more substantial, bid was present.
      **/
-    BidDropped: GenericPalletEvent<Rv, 'Nis', 'BidDropped', { who: AccountId32; amount: bigint; duration: number }>;
+    BidDropped: GenericPalletEvent<'Nis', 'BidDropped', { who: AccountId32; amount: bigint; duration: number }>;
 
     /**
      * A bid was accepted. The balance may not be released until expiry.
      **/
     Issued: GenericPalletEvent<
-      Rv,
       'Nis',
       'Issued',
       {
@@ -2744,7 +2573,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An receipt has been (at least partially) thawed.
      **/
     Thawed: GenericPalletEvent<
-      Rv,
       'Nis',
       'Thawed',
       {
@@ -2778,17 +2606,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An automatic funding of the deficit was made.
      **/
-    Funded: GenericPalletEvent<Rv, 'Nis', 'Funded', { deficit: bigint }>;
+    Funded: GenericPalletEvent<'Nis', 'Funded', { deficit: bigint }>;
 
     /**
      * A receipt was transferred.
      **/
-    Transferred: GenericPalletEvent<Rv, 'Nis', 'Transferred', { from: AccountId32; to: AccountId32; index: number }>;
+    Transferred: GenericPalletEvent<'Nis', 'Transferred', { from: AccountId32; to: AccountId32; index: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Uniques`'s events
@@ -2797,33 +2625,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A `collection` was created.
      **/
-    Created: GenericPalletEvent<
-      Rv,
-      'Uniques',
-      'Created',
-      { collection: number; creator: AccountId32; owner: AccountId32 }
-    >;
+    Created: GenericPalletEvent<'Uniques', 'Created', { collection: number; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * A `collection` was force-created.
      **/
-    ForceCreated: GenericPalletEvent<Rv, 'Uniques', 'ForceCreated', { collection: number; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<'Uniques', 'ForceCreated', { collection: number; owner: AccountId32 }>;
 
     /**
      * A `collection` was destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'Uniques', 'Destroyed', { collection: number }>;
+    Destroyed: GenericPalletEvent<'Uniques', 'Destroyed', { collection: number }>;
 
     /**
      * An `item` was issued.
      **/
-    Issued: GenericPalletEvent<Rv, 'Uniques', 'Issued', { collection: number; item: number; owner: AccountId32 }>;
+    Issued: GenericPalletEvent<'Uniques', 'Issued', { collection: number; item: number; owner: AccountId32 }>;
 
     /**
      * An `item` was transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'Uniques',
       'Transferred',
       { collection: number; item: number; from: AccountId32; to: AccountId32 }
@@ -2832,38 +2654,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An `item` was destroyed.
      **/
-    Burned: GenericPalletEvent<Rv, 'Uniques', 'Burned', { collection: number; item: number; owner: AccountId32 }>;
+    Burned: GenericPalletEvent<'Uniques', 'Burned', { collection: number; item: number; owner: AccountId32 }>;
 
     /**
      * Some `item` was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'Uniques', 'Frozen', { collection: number; item: number }>;
+    Frozen: GenericPalletEvent<'Uniques', 'Frozen', { collection: number; item: number }>;
 
     /**
      * Some `item` was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'Uniques', 'Thawed', { collection: number; item: number }>;
+    Thawed: GenericPalletEvent<'Uniques', 'Thawed', { collection: number; item: number }>;
 
     /**
      * Some `collection` was frozen.
      **/
-    CollectionFrozen: GenericPalletEvent<Rv, 'Uniques', 'CollectionFrozen', { collection: number }>;
+    CollectionFrozen: GenericPalletEvent<'Uniques', 'CollectionFrozen', { collection: number }>;
 
     /**
      * Some `collection` was thawed.
      **/
-    CollectionThawed: GenericPalletEvent<Rv, 'Uniques', 'CollectionThawed', { collection: number }>;
+    CollectionThawed: GenericPalletEvent<'Uniques', 'CollectionThawed', { collection: number }>;
 
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<Rv, 'Uniques', 'OwnerChanged', { collection: number; newOwner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<'Uniques', 'OwnerChanged', { collection: number; newOwner: AccountId32 }>;
 
     /**
      * The management team changed.
      **/
     TeamChanged: GenericPalletEvent<
-      Rv,
       'Uniques',
       'TeamChanged',
       { collection: number; issuer: AccountId32; admin: AccountId32; freezer: AccountId32 }
@@ -2874,7 +2695,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a `delegate`.
      **/
     ApprovedTransfer: GenericPalletEvent<
-      Rv,
       'Uniques',
       'ApprovedTransfer',
       { collection: number; item: number; owner: AccountId32; delegate: AccountId32 }
@@ -2885,7 +2705,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `collection` was cancelled by its `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
-      Rv,
       'Uniques',
       'ApprovalCancelled',
       { collection: number; item: number; owner: AccountId32; delegate: AccountId32 }
@@ -2894,13 +2713,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A `collection` has had its attributes changed by the `Force` origin.
      **/
-    ItemStatusChanged: GenericPalletEvent<Rv, 'Uniques', 'ItemStatusChanged', { collection: number }>;
+    ItemStatusChanged: GenericPalletEvent<'Uniques', 'ItemStatusChanged', { collection: number }>;
 
     /**
      * New metadata has been set for a `collection`.
      **/
     CollectionMetadataSet: GenericPalletEvent<
-      Rv,
       'Uniques',
       'CollectionMetadataSet',
       { collection: number; data: Bytes; isFrozen: boolean }
@@ -2909,13 +2727,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Metadata has been cleared for a `collection`.
      **/
-    CollectionMetadataCleared: GenericPalletEvent<Rv, 'Uniques', 'CollectionMetadataCleared', { collection: number }>;
+    CollectionMetadataCleared: GenericPalletEvent<'Uniques', 'CollectionMetadataCleared', { collection: number }>;
 
     /**
      * New metadata has been set for an item.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Uniques',
       'MetadataSet',
       { collection: number; item: number; data: Bytes; isFrozen: boolean }
@@ -2924,23 +2741,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Metadata has been cleared for an item.
      **/
-    MetadataCleared: GenericPalletEvent<Rv, 'Uniques', 'MetadataCleared', { collection: number; item: number }>;
+    MetadataCleared: GenericPalletEvent<'Uniques', 'MetadataCleared', { collection: number; item: number }>;
 
     /**
      * Metadata has been cleared for an item.
      **/
-    Redeposited: GenericPalletEvent<
-      Rv,
-      'Uniques',
-      'Redeposited',
-      { collection: number; successfulItems: Array<number> }
-    >;
+    Redeposited: GenericPalletEvent<'Uniques', 'Redeposited', { collection: number; successfulItems: Array<number> }>;
 
     /**
      * New attribute metadata has been set for a `collection` or `item`.
      **/
     AttributeSet: GenericPalletEvent<
-      Rv,
       'Uniques',
       'AttributeSet',
       { collection: number; maybeItem?: number | undefined; key: Bytes; value: Bytes }
@@ -2950,7 +2761,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Attribute metadata has been cleared for a `collection` or `item`.
      **/
     AttributeCleared: GenericPalletEvent<
-      Rv,
       'Uniques',
       'AttributeCleared',
       { collection: number; maybeItem?: number | undefined; key: Bytes }
@@ -2960,7 +2770,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Ownership acceptance has changed for an account.
      **/
     OwnershipAcceptanceChanged: GenericPalletEvent<
-      Rv,
       'Uniques',
       'OwnershipAcceptanceChanged',
       { who: AccountId32; maybeCollection?: number | undefined }
@@ -2970,7 +2779,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Max supply has been set for a collection.
      **/
     CollectionMaxSupplySet: GenericPalletEvent<
-      Rv,
       'Uniques',
       'CollectionMaxSupplySet',
       { collection: number; maxSupply: number }
@@ -2980,7 +2788,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The price was set for the instance.
      **/
     ItemPriceSet: GenericPalletEvent<
-      Rv,
       'Uniques',
       'ItemPriceSet',
       { collection: number; item: number; price: bigint; whitelistedBuyer?: AccountId32 | undefined }
@@ -2989,13 +2796,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The price for the instance was removed.
      **/
-    ItemPriceRemoved: GenericPalletEvent<Rv, 'Uniques', 'ItemPriceRemoved', { collection: number; item: number }>;
+    ItemPriceRemoved: GenericPalletEvent<'Uniques', 'ItemPriceRemoved', { collection: number; item: number }>;
 
     /**
      * An item was bought.
      **/
     ItemBought: GenericPalletEvent<
-      Rv,
       'Uniques',
       'ItemBought',
       { collection: number; item: number; price: bigint; seller: AccountId32; buyer: AccountId32 }
@@ -3004,7 +2810,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Nfts`'s events
@@ -3013,33 +2819,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A `collection` was created.
      **/
-    Created: GenericPalletEvent<
-      Rv,
-      'Nfts',
-      'Created',
-      { collection: number; creator: AccountId32; owner: AccountId32 }
-    >;
+    Created: GenericPalletEvent<'Nfts', 'Created', { collection: number; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * A `collection` was force-created.
      **/
-    ForceCreated: GenericPalletEvent<Rv, 'Nfts', 'ForceCreated', { collection: number; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<'Nfts', 'ForceCreated', { collection: number; owner: AccountId32 }>;
 
     /**
      * A `collection` was destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'Nfts', 'Destroyed', { collection: number }>;
+    Destroyed: GenericPalletEvent<'Nfts', 'Destroyed', { collection: number }>;
 
     /**
      * An `item` was issued.
      **/
-    Issued: GenericPalletEvent<Rv, 'Nfts', 'Issued', { collection: number; item: number; owner: AccountId32 }>;
+    Issued: GenericPalletEvent<'Nfts', 'Issued', { collection: number; item: number; owner: AccountId32 }>;
 
     /**
      * An `item` was transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'Nfts',
       'Transferred',
       { collection: number; item: number; from: AccountId32; to: AccountId32 }
@@ -3048,23 +2848,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An `item` was destroyed.
      **/
-    Burned: GenericPalletEvent<Rv, 'Nfts', 'Burned', { collection: number; item: number; owner: AccountId32 }>;
+    Burned: GenericPalletEvent<'Nfts', 'Burned', { collection: number; item: number; owner: AccountId32 }>;
 
     /**
      * An `item` became non-transferable.
      **/
-    ItemTransferLocked: GenericPalletEvent<Rv, 'Nfts', 'ItemTransferLocked', { collection: number; item: number }>;
+    ItemTransferLocked: GenericPalletEvent<'Nfts', 'ItemTransferLocked', { collection: number; item: number }>;
 
     /**
      * An `item` became transferable.
      **/
-    ItemTransferUnlocked: GenericPalletEvent<Rv, 'Nfts', 'ItemTransferUnlocked', { collection: number; item: number }>;
+    ItemTransferUnlocked: GenericPalletEvent<'Nfts', 'ItemTransferUnlocked', { collection: number; item: number }>;
 
     /**
      * `item` metadata or attributes were locked.
      **/
     ItemPropertiesLocked: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ItemPropertiesLocked',
       { collection: number; item: number; lockMetadata: boolean; lockAttributes: boolean }
@@ -3073,18 +2872,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some `collection` was locked.
      **/
-    CollectionLocked: GenericPalletEvent<Rv, 'Nfts', 'CollectionLocked', { collection: number }>;
+    CollectionLocked: GenericPalletEvent<'Nfts', 'CollectionLocked', { collection: number }>;
 
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<Rv, 'Nfts', 'OwnerChanged', { collection: number; newOwner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<'Nfts', 'OwnerChanged', { collection: number; newOwner: AccountId32 }>;
 
     /**
      * The management team changed.
      **/
     TeamChanged: GenericPalletEvent<
-      Rv,
       'Nfts',
       'TeamChanged',
       {
@@ -3100,7 +2898,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a `delegate`.
      **/
     TransferApproved: GenericPalletEvent<
-      Rv,
       'Nfts',
       'TransferApproved',
       { collection: number; item: number; owner: AccountId32; delegate: AccountId32; deadline?: number | undefined }
@@ -3111,7 +2908,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `collection` was cancelled by its `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ApprovalCancelled',
       { collection: number; item: number; owner: AccountId32; delegate: AccountId32 }
@@ -3121,7 +2917,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * All approvals of an item got cancelled.
      **/
     AllApprovalsCancelled: GenericPalletEvent<
-      Rv,
       'Nfts',
       'AllApprovalsCancelled',
       { collection: number; item: number; owner: AccountId32 }
@@ -3130,43 +2925,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A `collection` has had its config changed by the `Force` origin.
      **/
-    CollectionConfigChanged: GenericPalletEvent<Rv, 'Nfts', 'CollectionConfigChanged', { collection: number }>;
+    CollectionConfigChanged: GenericPalletEvent<'Nfts', 'CollectionConfigChanged', { collection: number }>;
 
     /**
      * New metadata has been set for a `collection`.
      **/
-    CollectionMetadataSet: GenericPalletEvent<Rv, 'Nfts', 'CollectionMetadataSet', { collection: number; data: Bytes }>;
+    CollectionMetadataSet: GenericPalletEvent<'Nfts', 'CollectionMetadataSet', { collection: number; data: Bytes }>;
 
     /**
      * Metadata has been cleared for a `collection`.
      **/
-    CollectionMetadataCleared: GenericPalletEvent<Rv, 'Nfts', 'CollectionMetadataCleared', { collection: number }>;
+    CollectionMetadataCleared: GenericPalletEvent<'Nfts', 'CollectionMetadataCleared', { collection: number }>;
 
     /**
      * New metadata has been set for an item.
      **/
-    ItemMetadataSet: GenericPalletEvent<
-      Rv,
-      'Nfts',
-      'ItemMetadataSet',
-      { collection: number; item: number; data: Bytes }
-    >;
+    ItemMetadataSet: GenericPalletEvent<'Nfts', 'ItemMetadataSet', { collection: number; item: number; data: Bytes }>;
 
     /**
      * Metadata has been cleared for an item.
      **/
-    ItemMetadataCleared: GenericPalletEvent<Rv, 'Nfts', 'ItemMetadataCleared', { collection: number; item: number }>;
+    ItemMetadataCleared: GenericPalletEvent<'Nfts', 'ItemMetadataCleared', { collection: number; item: number }>;
 
     /**
      * The deposit for a set of `item`s within a `collection` has been updated.
      **/
-    Redeposited: GenericPalletEvent<Rv, 'Nfts', 'Redeposited', { collection: number; successfulItems: Array<number> }>;
+    Redeposited: GenericPalletEvent<'Nfts', 'Redeposited', { collection: number; successfulItems: Array<number> }>;
 
     /**
      * New attribute metadata has been set for a `collection` or `item`.
      **/
     AttributeSet: GenericPalletEvent<
-      Rv,
       'Nfts',
       'AttributeSet',
       {
@@ -3182,7 +2971,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Attribute metadata has been cleared for a `collection` or `item`.
      **/
     AttributeCleared: GenericPalletEvent<
-      Rv,
       'Nfts',
       'AttributeCleared',
       { collection: number; maybeItem?: number | undefined; key: Bytes; namespace: PalletNftsAttributeNamespace }
@@ -3192,7 +2980,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new approval to modify item attributes was added.
      **/
     ItemAttributesApprovalAdded: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ItemAttributesApprovalAdded',
       { collection: number; item: number; delegate: AccountId32 }
@@ -3202,7 +2989,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new approval to modify item attributes was removed.
      **/
     ItemAttributesApprovalRemoved: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ItemAttributesApprovalRemoved',
       { collection: number; item: number; delegate: AccountId32 }
@@ -3212,7 +2998,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Ownership acceptance has changed for an account.
      **/
     OwnershipAcceptanceChanged: GenericPalletEvent<
-      Rv,
       'Nfts',
       'OwnershipAcceptanceChanged',
       { who: AccountId32; maybeCollection?: number | undefined }
@@ -3222,7 +3007,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Max supply has been set for a collection.
      **/
     CollectionMaxSupplySet: GenericPalletEvent<
-      Rv,
       'Nfts',
       'CollectionMaxSupplySet',
       { collection: number; maxSupply: number }
@@ -3231,18 +3015,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Mint settings for a collection had changed.
      **/
-    CollectionMintSettingsUpdated: GenericPalletEvent<
-      Rv,
-      'Nfts',
-      'CollectionMintSettingsUpdated',
-      { collection: number }
-    >;
+    CollectionMintSettingsUpdated: GenericPalletEvent<'Nfts', 'CollectionMintSettingsUpdated', { collection: number }>;
 
     /**
      * Event gets emitted when the `NextCollectionId` gets incremented.
      **/
     NextCollectionIdIncremented: GenericPalletEvent<
-      Rv,
       'Nfts',
       'NextCollectionIdIncremented',
       { nextId?: number | undefined }
@@ -3252,7 +3030,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The price was set for the item.
      **/
     ItemPriceSet: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ItemPriceSet',
       { collection: number; item: number; price: bigint; whitelistedBuyer?: AccountId32 | undefined }
@@ -3261,13 +3038,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The price for the item was removed.
      **/
-    ItemPriceRemoved: GenericPalletEvent<Rv, 'Nfts', 'ItemPriceRemoved', { collection: number; item: number }>;
+    ItemPriceRemoved: GenericPalletEvent<'Nfts', 'ItemPriceRemoved', { collection: number; item: number }>;
 
     /**
      * An item was bought.
      **/
     ItemBought: GenericPalletEvent<
-      Rv,
       'Nfts',
       'ItemBought',
       { collection: number; item: number; price: bigint; seller: AccountId32; buyer: AccountId32 }
@@ -3277,7 +3053,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A tip was sent.
      **/
     TipSent: GenericPalletEvent<
-      Rv,
       'Nfts',
       'TipSent',
       { collection: number; item: number; sender: AccountId32; receiver: AccountId32; amount: bigint }
@@ -3287,7 +3062,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An `item` swap intent was created.
      **/
     SwapCreated: GenericPalletEvent<
-      Rv,
       'Nfts',
       'SwapCreated',
       {
@@ -3304,7 +3078,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The swap was cancelled.
      **/
     SwapCancelled: GenericPalletEvent<
-      Rv,
       'Nfts',
       'SwapCancelled',
       {
@@ -3321,7 +3094,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The swap has been claimed.
      **/
     SwapClaimed: GenericPalletEvent<
-      Rv,
       'Nfts',
       'SwapClaimed',
       {
@@ -3340,7 +3112,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * New attributes have been set for an `item` of the `collection`.
      **/
     PreSignedAttributesSet: GenericPalletEvent<
-      Rv,
       'Nfts',
       'PreSignedAttributesSet',
       { collection: number; item: number; namespace: PalletNftsAttributeNamespace }
@@ -3351,7 +3122,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * within that `collection`.
      **/
     PalletAttributeSet: GenericPalletEvent<
-      Rv,
       'Nfts',
       'PalletAttributeSet',
       { collection: number; item?: number | undefined; attribute: PalletNftsPalletAttributes; value: Bytes }
@@ -3360,7 +3130,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `NftFractionalization`'s events
@@ -3370,7 +3140,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An NFT was successfully fractionalized.
      **/
     NftFractionalized: GenericPalletEvent<
-      Rv,
       'NftFractionalization',
       'NftFractionalized',
       { nftCollection: number; nft: number; fractions: bigint; asset: number; beneficiary: AccountId32 }
@@ -3380,7 +3149,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An NFT was successfully returned back.
      **/
     NftUnified: GenericPalletEvent<
-      Rv,
       'NftFractionalization',
       'NftUnified',
       { nftCollection: number; nft: number; asset: number; beneficiary: AccountId32 }
@@ -3389,7 +3157,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Salary`'s events
@@ -3398,37 +3166,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A member is inducted into the payroll.
      **/
-    Inducted: GenericPalletEvent<Rv, 'Salary', 'Inducted', { who: AccountId32 }>;
+    Inducted: GenericPalletEvent<'Salary', 'Inducted', { who: AccountId32 }>;
 
     /**
      * A member registered for a payout.
      **/
-    Registered: GenericPalletEvent<Rv, 'Salary', 'Registered', { who: AccountId32; amount: bigint }>;
+    Registered: GenericPalletEvent<'Salary', 'Registered', { who: AccountId32; amount: bigint }>;
 
     /**
      * A payment happened.
      **/
-    Paid: GenericPalletEvent<
-      Rv,
-      'Salary',
-      'Paid',
-      { who: AccountId32; beneficiary: AccountId32; amount: bigint; id: [] }
-    >;
+    Paid: GenericPalletEvent<'Salary', 'Paid', { who: AccountId32; beneficiary: AccountId32; amount: bigint; id: [] }>;
 
     /**
      * The next cycle begins.
      **/
-    CycleStarted: GenericPalletEvent<Rv, 'Salary', 'CycleStarted', { index: number }>;
+    CycleStarted: GenericPalletEvent<'Salary', 'CycleStarted', { index: number }>;
 
     /**
      * A member swapped their account.
      **/
-    Swapped: GenericPalletEvent<Rv, 'Salary', 'Swapped', { who: AccountId32; newWho: AccountId32 }>;
+    Swapped: GenericPalletEvent<'Salary', 'Swapped', { who: AccountId32; newWho: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CoreFellowship`'s events
@@ -3437,60 +3200,49 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Parameters for the pallet have changed.
      **/
-    ParamsChanged: GenericPalletEvent<
-      Rv,
-      'CoreFellowship',
-      'ParamsChanged',
-      { params: PalletCoreFellowshipParamsType }
-    >;
+    ParamsChanged: GenericPalletEvent<'CoreFellowship', 'ParamsChanged', { params: PalletCoreFellowshipParamsType }>;
 
     /**
      * Member activity flag has been set.
      **/
-    ActiveChanged: GenericPalletEvent<Rv, 'CoreFellowship', 'ActiveChanged', { who: AccountId32; isActive: boolean }>;
+    ActiveChanged: GenericPalletEvent<'CoreFellowship', 'ActiveChanged', { who: AccountId32; isActive: boolean }>;
 
     /**
      * Member has begun being tracked in this pallet.
      **/
-    Inducted: GenericPalletEvent<Rv, 'CoreFellowship', 'Inducted', { who: AccountId32 }>;
+    Inducted: GenericPalletEvent<'CoreFellowship', 'Inducted', { who: AccountId32 }>;
 
     /**
      * Member has been removed from being tracked in this pallet (i.e. because rank is now
      * zero).
      **/
-    Offboarded: GenericPalletEvent<Rv, 'CoreFellowship', 'Offboarded', { who: AccountId32 }>;
+    Offboarded: GenericPalletEvent<'CoreFellowship', 'Offboarded', { who: AccountId32 }>;
 
     /**
      * Member has been promoted to the given rank.
      **/
-    Promoted: GenericPalletEvent<Rv, 'CoreFellowship', 'Promoted', { who: AccountId32; toRank: number }>;
+    Promoted: GenericPalletEvent<'CoreFellowship', 'Promoted', { who: AccountId32; toRank: number }>;
 
     /**
      * Member has been demoted to the given (non-zero) rank.
      **/
-    Demoted: GenericPalletEvent<Rv, 'CoreFellowship', 'Demoted', { who: AccountId32; toRank: number }>;
+    Demoted: GenericPalletEvent<'CoreFellowship', 'Demoted', { who: AccountId32; toRank: number }>;
 
     /**
      * Member has been proven at their current rank, postponing auto-demotion.
      **/
-    Proven: GenericPalletEvent<Rv, 'CoreFellowship', 'Proven', { who: AccountId32; atRank: number }>;
+    Proven: GenericPalletEvent<'CoreFellowship', 'Proven', { who: AccountId32; atRank: number }>;
 
     /**
      * Member has stated evidence of their efforts their request for rank.
      **/
-    Requested: GenericPalletEvent<
-      Rv,
-      'CoreFellowship',
-      'Requested',
-      { who: AccountId32; wish: PalletCoreFellowshipWish }
-    >;
+    Requested: GenericPalletEvent<'CoreFellowship', 'Requested', { who: AccountId32; wish: PalletCoreFellowshipWish }>;
 
     /**
      * Some submitted evidence was judged and removed. There may or may not have been a change
      * to the rank, but in any case, `last_proof` is reset.
      **/
     EvidenceJudged: GenericPalletEvent<
-      Rv,
       'CoreFellowship',
       'EvidenceJudged',
       {
@@ -3524,17 +3276,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Pre-ranked account has been inducted at their current rank.
      **/
-    Imported: GenericPalletEvent<Rv, 'CoreFellowship', 'Imported', { who: AccountId32; rank: number }>;
+    Imported: GenericPalletEvent<'CoreFellowship', 'Imported', { who: AccountId32; rank: number }>;
 
     /**
      * A member had its AccountId swapped.
      **/
-    Swapped: GenericPalletEvent<Rv, 'CoreFellowship', 'Swapped', { who: AccountId32; newWho: AccountId32 }>;
+    Swapped: GenericPalletEvent<'CoreFellowship', 'Swapped', { who: AccountId32; newWho: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TransactionStorage`'s events
@@ -3543,22 +3295,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Stored data under specified index.
      **/
-    Stored: GenericPalletEvent<Rv, 'TransactionStorage', 'Stored', { index: number }>;
+    Stored: GenericPalletEvent<'TransactionStorage', 'Stored', { index: number }>;
 
     /**
      * Renewed data under specified index.
      **/
-    Renewed: GenericPalletEvent<Rv, 'TransactionStorage', 'Renewed', { index: number }>;
+    Renewed: GenericPalletEvent<'TransactionStorage', 'Renewed', { index: number }>;
 
     /**
      * Storage proof was successfully checked.
      **/
-    ProofChecked: GenericPalletEvent<Rv, 'TransactionStorage', 'ProofChecked', null>;
+    ProofChecked: GenericPalletEvent<'TransactionStorage', 'ProofChecked', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `VoterList`'s events
@@ -3567,17 +3319,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Moved an account from one bag to another.
      **/
-    Rebagged: GenericPalletEvent<Rv, 'VoterList', 'Rebagged', { who: AccountId32; from: bigint; to: bigint }>;
+    Rebagged: GenericPalletEvent<'VoterList', 'Rebagged', { who: AccountId32; from: bigint; to: bigint }>;
 
     /**
      * Updated the score of some account to the given amount.
      **/
-    ScoreUpdated: GenericPalletEvent<Rv, 'VoterList', 'ScoreUpdated', { who: AccountId32; newScore: bigint }>;
+    ScoreUpdated: GenericPalletEvent<'VoterList', 'ScoreUpdated', { who: AccountId32; newScore: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `StateTrieMigration`'s events
@@ -3588,7 +3340,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `compute`.
      **/
     Migrated: GenericPalletEvent<
-      Rv,
       'StateTrieMigration',
       'Migrated',
       { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute }
@@ -3597,22 +3348,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some account got slashed by the given amount.
      **/
-    Slashed: GenericPalletEvent<Rv, 'StateTrieMigration', 'Slashed', { who: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<'StateTrieMigration', 'Slashed', { who: AccountId32; amount: bigint }>;
 
     /**
      * The auto migration task finished.
      **/
-    AutoMigrationFinished: GenericPalletEvent<Rv, 'StateTrieMigration', 'AutoMigrationFinished', null>;
+    AutoMigrationFinished: GenericPalletEvent<'StateTrieMigration', 'AutoMigrationFinished', null>;
 
     /**
      * Migration got halted due to an error or miss-configuration.
      **/
-    Halted: GenericPalletEvent<Rv, 'StateTrieMigration', 'Halted', { error: PalletStateTrieMigrationError }>;
+    Halted: GenericPalletEvent<'StateTrieMigration', 'Halted', { error: PalletStateTrieMigrationError }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ChildBounties`'s events
@@ -3621,13 +3372,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A child-bounty is added.
      **/
-    Added: GenericPalletEvent<Rv, 'ChildBounties', 'Added', { index: number; childIndex: number }>;
+    Added: GenericPalletEvent<'ChildBounties', 'Added', { index: number; childIndex: number }>;
 
     /**
      * A child-bounty is awarded to a beneficiary.
      **/
     Awarded: GenericPalletEvent<
-      Rv,
       'ChildBounties',
       'Awarded',
       { index: number; childIndex: number; beneficiary: AccountId32 }
@@ -3637,7 +3387,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A child-bounty is claimed by beneficiary.
      **/
     Claimed: GenericPalletEvent<
-      Rv,
       'ChildBounties',
       'Claimed',
       { index: number; childIndex: number; payout: bigint; beneficiary: AccountId32 }
@@ -3646,12 +3395,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A child-bounty is cancelled.
      **/
-    Canceled: GenericPalletEvent<Rv, 'ChildBounties', 'Canceled', { index: number; childIndex: number }>;
+    Canceled: GenericPalletEvent<'ChildBounties', 'Canceled', { index: number; childIndex: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Referenda`'s events
@@ -3661,7 +3410,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been submitted.
      **/
     Submitted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Submitted',
       {
@@ -3686,7 +3434,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been placed.
      **/
     DecisionDepositPlaced: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionDepositPlaced',
       {
@@ -3711,7 +3458,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been refunded.
      **/
     DecisionDepositRefunded: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionDepositRefunded',
       {
@@ -3736,7 +3482,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A deposit has been slashed.
      **/
     DepositSlashed: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DepositSlashed',
       {
@@ -3756,7 +3501,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has moved into the deciding phase.
      **/
     DecisionStarted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionStarted',
       {
@@ -3782,7 +3526,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmStarted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'ConfirmStarted',
       {
@@ -3793,7 +3536,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmAborted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'ConfirmAborted',
       {
@@ -3808,7 +3550,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has ended its confirmation phase and is ready for approval.
      **/
     Confirmed: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Confirmed',
       {
@@ -3828,7 +3569,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been approved and its proposal has been scheduled.
      **/
     Approved: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Approved',
       {
@@ -3843,7 +3583,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proposal has been rejected by referendum.
      **/
     Rejected: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Rejected',
       {
@@ -3863,7 +3602,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been timed out without being decided.
      **/
     TimedOut: GenericPalletEvent<
-      Rv,
       'Referenda',
       'TimedOut',
       {
@@ -3883,7 +3621,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been cancelled.
      **/
     Cancelled: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Cancelled',
       {
@@ -3903,7 +3640,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been killed.
      **/
     Killed: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Killed',
       {
@@ -3923,7 +3659,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The submission deposit has been refunded.
      **/
     SubmissionDepositRefunded: GenericPalletEvent<
-      Rv,
       'Referenda',
       'SubmissionDepositRefunded',
       {
@@ -3948,7 +3683,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Referenda',
       'MetadataSet',
       {
@@ -3968,7 +3702,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'Referenda',
       'MetadataCleared',
       {
@@ -3987,7 +3720,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Remark`'s events
@@ -3996,12 +3729,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Stored data off chain.
      **/
-    Stored: GenericPalletEvent<Rv, 'Remark', 'Stored', { sender: AccountId32; contentHash: H256 }>;
+    Stored: GenericPalletEvent<'Remark', 'Stored', { sender: AccountId32; contentHash: H256 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `RootTesting`'s events
@@ -4010,12 +3743,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Event dispatched when the trigger_defensive extrinsic is called.
      **/
-    DefensiveTestCall: GenericPalletEvent<Rv, 'RootTesting', 'DefensiveTestCall', undefined>;
+    DefensiveTestCall: GenericPalletEvent<'RootTesting', 'DefensiveTestCall', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ConvictionVoting`'s events
@@ -4024,18 +3757,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An account has delegated their vote to another account. \[who, target\]
      **/
-    Delegated: GenericPalletEvent<Rv, 'ConvictionVoting', 'Delegated', [AccountId32, AccountId32]>;
+    Delegated: GenericPalletEvent<'ConvictionVoting', 'Delegated', [AccountId32, AccountId32]>;
 
     /**
      * An \[account\] has cancelled a previous delegation operation.
      **/
-    Undelegated: GenericPalletEvent<Rv, 'ConvictionVoting', 'Undelegated', AccountId32>;
+    Undelegated: GenericPalletEvent<'ConvictionVoting', 'Undelegated', AccountId32>;
 
     /**
      * An account has voted
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'ConvictionVoting',
       'Voted',
       { who: AccountId32; vote: PalletConvictionVotingVoteAccountVote }
@@ -4045,7 +3777,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A vote has been removed
      **/
     VoteRemoved: GenericPalletEvent<
-      Rv,
       'ConvictionVoting',
       'VoteRemoved',
       { who: AccountId32; vote: PalletConvictionVotingVoteAccountVote }
@@ -4054,21 +3785,20 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The lockup period of a conviction vote expired, and the funds have been unlocked.
      **/
-    VoteUnlocked: GenericPalletEvent<Rv, 'ConvictionVoting', 'VoteUnlocked', { who: AccountId32; class: number }>;
+    VoteUnlocked: GenericPalletEvent<'ConvictionVoting', 'VoteUnlocked', { who: AccountId32; class: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Whitelist`'s events
    **/
   whitelist: {
-    CallWhitelisted: GenericPalletEvent<Rv, 'Whitelist', 'CallWhitelisted', { callHash: H256 }>;
-    WhitelistedCallRemoved: GenericPalletEvent<Rv, 'Whitelist', 'WhitelistedCallRemoved', { callHash: H256 }>;
+    CallWhitelisted: GenericPalletEvent<'Whitelist', 'CallWhitelisted', { callHash: H256 }>;
+    WhitelistedCallRemoved: GenericPalletEvent<'Whitelist', 'WhitelistedCallRemoved', { callHash: H256 }>;
     WhitelistedCallDispatched: GenericPalletEvent<
-      Rv,
       'Whitelist',
       'WhitelistedCallDispatched',
       { callHash: H256; result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo> }
@@ -4077,7 +3807,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AllianceMotion`'s events
@@ -4088,7 +3818,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -4099,7 +3828,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -4108,18 +3836,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'AllianceMotion', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'AllianceMotion', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'AllianceMotion', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'AllianceMotion', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
     Executed: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'Executed',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -4129,7 +3856,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -4138,18 +3864,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'AllianceMotion', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'AllianceMotion', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'AllianceMotion', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'AllianceMotion', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
     ProposalCostBurned: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'ProposalCostBurned',
       { proposalHash: H256; who: AccountId32 }
@@ -4159,7 +3884,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'AllianceMotion',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -4168,7 +3892,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Alliance`'s events
@@ -4177,23 +3901,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A new rule has been set.
      **/
-    NewRuleSet: GenericPalletEvent<Rv, 'Alliance', 'NewRuleSet', { rule: PalletAllianceCid }>;
+    NewRuleSet: GenericPalletEvent<'Alliance', 'NewRuleSet', { rule: PalletAllianceCid }>;
 
     /**
      * A new announcement has been proposed.
      **/
-    Announced: GenericPalletEvent<Rv, 'Alliance', 'Announced', { announcement: PalletAllianceCid }>;
+    Announced: GenericPalletEvent<'Alliance', 'Announced', { announcement: PalletAllianceCid }>;
 
     /**
      * An on-chain announcement has been removed.
      **/
-    AnnouncementRemoved: GenericPalletEvent<Rv, 'Alliance', 'AnnouncementRemoved', { announcement: PalletAllianceCid }>;
+    AnnouncementRemoved: GenericPalletEvent<'Alliance', 'AnnouncementRemoved', { announcement: PalletAllianceCid }>;
 
     /**
      * Some accounts have been initialized as members (fellows/allies).
      **/
     MembersInitialized: GenericPalletEvent<
-      Rv,
       'Alliance',
       'MembersInitialized',
       { fellows: Array<AccountId32>; allies: Array<AccountId32> }
@@ -4203,7 +3926,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account has been added as an Ally and reserved its deposit.
      **/
     NewAllyJoined: GenericPalletEvent<
-      Rv,
       'Alliance',
       'NewAllyJoined',
       { ally: AccountId32; nominator?: AccountId32 | undefined; reserved?: bigint | undefined }
@@ -4212,13 +3934,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An ally has been elevated to Fellow.
      **/
-    AllyElevated: GenericPalletEvent<Rv, 'Alliance', 'AllyElevated', { ally: AccountId32 }>;
+    AllyElevated: GenericPalletEvent<'Alliance', 'AllyElevated', { ally: AccountId32 }>;
 
     /**
      * A member gave retirement notice and their retirement period started.
      **/
     MemberRetirementPeriodStarted: GenericPalletEvent<
-      Rv,
       'Alliance',
       'MemberRetirementPeriodStarted',
       { member: AccountId32 }
@@ -4228,7 +3949,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A member has retired with its deposit unreserved.
      **/
     MemberRetired: GenericPalletEvent<
-      Rv,
       'Alliance',
       'MemberRetired',
       { member: AccountId32; unreserved?: bigint | undefined }
@@ -4237,18 +3957,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A member has been kicked out with its deposit slashed.
      **/
-    MemberKicked: GenericPalletEvent<
-      Rv,
-      'Alliance',
-      'MemberKicked',
-      { member: AccountId32; slashed?: bigint | undefined }
-    >;
+    MemberKicked: GenericPalletEvent<'Alliance', 'MemberKicked', { member: AccountId32; slashed?: bigint | undefined }>;
 
     /**
      * Accounts or websites have been added into the list of unscrupulous items.
      **/
     UnscrupulousItemAdded: GenericPalletEvent<
-      Rv,
       'Alliance',
       'UnscrupulousItemAdded',
       { items: Array<PalletAllianceUnscrupulousItem> }
@@ -4258,7 +3972,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Accounts or websites have been removed from the list of unscrupulous items.
      **/
     UnscrupulousItemRemoved: GenericPalletEvent<
-      Rv,
       'Alliance',
       'UnscrupulousItemRemoved',
       { items: Array<PalletAllianceUnscrupulousItem> }
@@ -4268,7 +3981,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Alliance disbanded. Includes number deleted members and unreserved deposits.
      **/
     AllianceDisbanded: GenericPalletEvent<
-      Rv,
       'Alliance',
       'AllianceDisbanded',
       { fellowMembers: number; allyMembers: number; unreserved: number }
@@ -4277,12 +3989,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A Fellow abdicated their voting rights. They are now an Ally.
      **/
-    FellowAbdicated: GenericPalletEvent<Rv, 'Alliance', 'FellowAbdicated', { fellow: AccountId32 }>;
+    FellowAbdicated: GenericPalletEvent<'Alliance', 'FellowAbdicated', { fellow: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `NominationPools`'s events
@@ -4291,13 +4003,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A pool has been created.
      **/
-    Created: GenericPalletEvent<Rv, 'NominationPools', 'Created', { depositor: AccountId32; poolId: number }>;
+    Created: GenericPalletEvent<'NominationPools', 'Created', { depositor: AccountId32; poolId: number }>;
 
     /**
      * A member has became bonded in a pool.
      **/
     Bonded: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'Bonded',
       { member: AccountId32; poolId: number; bonded: bigint; joined: boolean }
@@ -4306,12 +4017,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A payout has been made to a member.
      **/
-    PaidOut: GenericPalletEvent<
-      Rv,
-      'NominationPools',
-      'PaidOut',
-      { member: AccountId32; poolId: number; payout: bigint }
-    >;
+    PaidOut: GenericPalletEvent<'NominationPools', 'PaidOut', { member: AccountId32; poolId: number; payout: bigint }>;
 
     /**
      * A member has unbonded from their pool.
@@ -4327,7 +4033,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * requested to be unbonded.
      **/
     Unbonded: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'Unbonded',
       { member: AccountId32; poolId: number; balance: bigint; points: bigint; era: number }
@@ -4342,7 +4047,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * will be 1.
      **/
     Withdrawn: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'Withdrawn',
       { member: AccountId32; poolId: number; balance: bigint; points: bigint }
@@ -4351,13 +4055,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A pool has been destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'NominationPools', 'Destroyed', { poolId: number }>;
+    Destroyed: GenericPalletEvent<'NominationPools', 'Destroyed', { poolId: number }>;
 
     /**
      * The state of a pool has changed
      **/
     StateChanged: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'StateChanged',
       { poolId: number; newState: PalletNominationPoolsPoolState }
@@ -4371,7 +4074,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * represented by `released_balance`.
      **/
     MemberRemoved: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'MemberRemoved',
       { poolId: number; member: AccountId32; releasedBalance: bigint }
@@ -4382,7 +4084,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * can never change.
      **/
     RolesUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'RolesUpdated',
       { root?: AccountId32 | undefined; bouncer?: AccountId32 | undefined; nominator?: AccountId32 | undefined }
@@ -4391,13 +4092,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The active balance of pool `pool_id` has been slashed to `balance`.
      **/
-    PoolSlashed: GenericPalletEvent<Rv, 'NominationPools', 'PoolSlashed', { poolId: number; balance: bigint }>;
+    PoolSlashed: GenericPalletEvent<'NominationPools', 'PoolSlashed', { poolId: number; balance: bigint }>;
 
     /**
      * The unbond pool at `era` of pool `pool_id` has been slashed to `balance`.
      **/
     UnbondingPoolSlashed: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'UnbondingPoolSlashed',
       { poolId: number; era: number; balance: bigint }
@@ -4407,7 +4107,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool's commission setting has been changed.
      **/
     PoolCommissionUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolCommissionUpdated',
       { poolId: number; current?: [Perbill, AccountId32] | undefined }
@@ -4417,7 +4116,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool's maximum commission setting has been changed.
      **/
     PoolMaxCommissionUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolMaxCommissionUpdated',
       { poolId: number; maxCommission: Perbill }
@@ -4427,7 +4125,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool's commission `change_rate` has been changed.
      **/
     PoolCommissionChangeRateUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolCommissionChangeRateUpdated',
       { poolId: number; changeRate: PalletNominationPoolsCommissionChangeRate }
@@ -4437,7 +4134,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Pool commission claim permission has been updated.
      **/
     PoolCommissionClaimPermissionUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolCommissionClaimPermissionUpdated',
       { poolId: number; permission?: PalletNominationPoolsCommissionClaimPermission | undefined }
@@ -4447,7 +4143,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Pool commission has been claimed.
      **/
     PoolCommissionClaimed: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolCommissionClaimed',
       { poolId: number; commission: bigint }
@@ -4457,7 +4152,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Topped up deficit in frozen ED of the reward pool.
      **/
     MinBalanceDeficitAdjusted: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'MinBalanceDeficitAdjusted',
       { poolId: number; amount: bigint }
@@ -4467,7 +4161,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Claimed excess frozen ED of af the reward pool.
      **/
     MinBalanceExcessAdjusted: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'MinBalanceExcessAdjusted',
       { poolId: number; amount: bigint }
@@ -4477,7 +4170,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool member's claim permission has been updated.
      **/
     MemberClaimPermissionUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'MemberClaimPermissionUpdated',
       { member: AccountId32; permission: PalletNominationPoolsClaimPermission }
@@ -4486,19 +4178,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A pool's metadata was updated.
      **/
-    MetadataUpdated: GenericPalletEvent<
-      Rv,
-      'NominationPools',
-      'MetadataUpdated',
-      { poolId: number; caller: AccountId32 }
-    >;
+    MetadataUpdated: GenericPalletEvent<'NominationPools', 'MetadataUpdated', { poolId: number; caller: AccountId32 }>;
 
     /**
      * A pool's nominating account (or the pool's root account) has nominated a validator set
      * on behalf of the pool.
      **/
     PoolNominationMade: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolNominationMade',
       { poolId: number; caller: AccountId32 }
@@ -4508,7 +4194,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The pool is chilled i.e. no longer nominating.
      **/
     PoolNominatorChilled: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolNominatorChilled',
       { poolId: number; caller: AccountId32 }
@@ -4518,7 +4203,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Global parameters regulating nomination pools have been updated.
      **/
     GlobalParamsUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'GlobalParamsUpdated',
       {
@@ -4534,7 +4218,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `RankedPolls`'s events
@@ -4544,7 +4228,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been submitted.
      **/
     Submitted: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Submitted',
       {
@@ -4569,7 +4252,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been placed.
      **/
     DecisionDepositPlaced: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'DecisionDepositPlaced',
       {
@@ -4594,7 +4276,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been refunded.
      **/
     DecisionDepositRefunded: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'DecisionDepositRefunded',
       {
@@ -4619,7 +4300,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A deposit has been slashed.
      **/
     DepositSlashed: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'DepositSlashed',
       {
@@ -4639,7 +4319,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has moved into the deciding phase.
      **/
     DecisionStarted: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'DecisionStarted',
       {
@@ -4665,7 +4344,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmStarted: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'ConfirmStarted',
       {
@@ -4676,7 +4354,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmAborted: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'ConfirmAborted',
       {
@@ -4691,7 +4368,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has ended its confirmation phase and is ready for approval.
      **/
     Confirmed: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Confirmed',
       {
@@ -4711,7 +4387,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been approved and its proposal has been scheduled.
      **/
     Approved: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Approved',
       {
@@ -4726,7 +4401,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proposal has been rejected by referendum.
      **/
     Rejected: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Rejected',
       {
@@ -4746,7 +4420,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been timed out without being decided.
      **/
     TimedOut: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'TimedOut',
       {
@@ -4766,7 +4439,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been cancelled.
      **/
     Cancelled: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Cancelled',
       {
@@ -4786,7 +4458,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been killed.
      **/
     Killed: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'Killed',
       {
@@ -4806,7 +4477,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The submission deposit has been refunded.
      **/
     SubmissionDepositRefunded: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'SubmissionDepositRefunded',
       {
@@ -4831,7 +4501,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'MetadataSet',
       {
@@ -4851,7 +4520,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'RankedPolls',
       'MetadataCleared',
       {
@@ -4870,7 +4538,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `RankedCollective`'s events
@@ -4879,24 +4547,23 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A member `who` has been added.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'RankedCollective', 'MemberAdded', { who: AccountId32 }>;
+    MemberAdded: GenericPalletEvent<'RankedCollective', 'MemberAdded', { who: AccountId32 }>;
 
     /**
      * The member `who`se rank has been changed to the given `rank`.
      **/
-    RankChanged: GenericPalletEvent<Rv, 'RankedCollective', 'RankChanged', { who: AccountId32; rank: number }>;
+    RankChanged: GenericPalletEvent<'RankedCollective', 'RankChanged', { who: AccountId32; rank: number }>;
 
     /**
      * The member `who` of given `rank` has been removed from the collective.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'RankedCollective', 'MemberRemoved', { who: AccountId32; rank: number }>;
+    MemberRemoved: GenericPalletEvent<'RankedCollective', 'MemberRemoved', { who: AccountId32; rank: number }>;
 
     /**
      * The member `who` has voted for the `poll` with the given `vote` leading to an updated
      * `tally`.
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'RankedCollective',
       'Voted',
       { who: AccountId32; poll: number; vote: PalletRankedCollectiveVoteRecord; tally: PalletRankedCollectiveTally }
@@ -4906,7 +4573,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The member `who` had their `AccountId` changed to `new_who`.
      **/
     MemberExchanged: GenericPalletEvent<
-      Rv,
       'RankedCollective',
       'MemberExchanged',
       { who: AccountId32; newWho: AccountId32 }
@@ -4915,7 +4581,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetConversion`'s events
@@ -4925,7 +4591,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A successful call of the `CreatePool` extrinsic will create this event.
      **/
     PoolCreated: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'PoolCreated',
       {
@@ -4957,7 +4622,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A successful call of the `AddLiquidity` extrinsic will create this event.
      **/
     LiquidityAdded: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'LiquidityAdded',
       {
@@ -5002,7 +4666,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A successful call of the `RemoveLiquidity` extrinsic will create this event.
      **/
     LiquidityRemoved: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'LiquidityRemoved',
       {
@@ -5053,7 +4716,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * and `SwapTokenForExactToken` will generate this event.
      **/
     SwapExecuted: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'SwapExecuted',
       {
@@ -5089,7 +4751,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Assets have been converted from one to another.
      **/
     SwapCreditExecuted: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'SwapCreditExecuted',
       {
@@ -5115,7 +4776,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Pool has been touched in order to fulfill operational requirements.
      **/
     Touched: GenericPalletEvent<
-      Rv,
       'AssetConversion',
       'Touched',
       {
@@ -5134,7 +4794,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `FastUnstake`'s events
@@ -5143,22 +4803,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A staker was unstaked.
      **/
-    Unstaked: GenericPalletEvent<
-      Rv,
-      'FastUnstake',
-      'Unstaked',
-      { stash: AccountId32; result: Result<[], DispatchError> }
-    >;
+    Unstaked: GenericPalletEvent<'FastUnstake', 'Unstaked', { stash: AccountId32; result: Result<[], DispatchError> }>;
 
     /**
      * A staker was slashed for requesting fast-unstake whilst being exposed.
      **/
-    Slashed: GenericPalletEvent<Rv, 'FastUnstake', 'Slashed', { stash: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<'FastUnstake', 'Slashed', { stash: AccountId32; amount: bigint }>;
 
     /**
      * A batch was partially checked for the given eras, but the process did not finish.
      **/
-    BatchChecked: GenericPalletEvent<Rv, 'FastUnstake', 'BatchChecked', { eras: Array<number> }>;
+    BatchChecked: GenericPalletEvent<'FastUnstake', 'BatchChecked', { eras: Array<number> }>;
 
     /**
      * A batch of a given size was terminated.
@@ -5166,17 +4821,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This is always follows by a number of `Unstaked` or `Slashed` events, marking the end
      * of the batch. A new batch will be created upon next block.
      **/
-    BatchFinished: GenericPalletEvent<Rv, 'FastUnstake', 'BatchFinished', { size: number }>;
+    BatchFinished: GenericPalletEvent<'FastUnstake', 'BatchFinished', { size: number }>;
 
     /**
      * An internal error happened. Operations will be paused now.
      **/
-    InternalError: GenericPalletEvent<Rv, 'FastUnstake', 'InternalError', null>;
+    InternalError: GenericPalletEvent<'FastUnstake', 'InternalError', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MessageQueue`'s events
@@ -5186,7 +4841,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message discarded due to an error in the `MessageProcessor` (usually a format error).
      **/
     ProcessingFailed: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'ProcessingFailed',
       {
@@ -5214,7 +4868,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message is processed.
      **/
     Processed: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'Processed',
       {
@@ -5249,7 +4902,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message placed in overweight queue.
      **/
     OverweightEnqueued: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'OverweightEnqueued',
       {
@@ -5279,7 +4931,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This page was reaped.
      **/
     PageReaped: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'PageReaped',
       {
@@ -5298,18 +4949,18 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Pov`'s events
    **/
   pov: {
-    TestEvent: GenericPalletEvent<Rv, 'Pov', 'TestEvent', undefined>;
+    TestEvent: GenericPalletEvent<'Pov', 'TestEvent', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TxPause`'s events
@@ -5318,17 +4969,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * This pallet, or a specific call is now paused.
      **/
-    CallPaused: GenericPalletEvent<Rv, 'TxPause', 'CallPaused', { fullName: [Bytes, Bytes] }>;
+    CallPaused: GenericPalletEvent<'TxPause', 'CallPaused', { fullName: [Bytes, Bytes] }>;
 
     /**
      * This pallet, or a specific call is now unpaused.
      **/
-    CallUnpaused: GenericPalletEvent<Rv, 'TxPause', 'CallUnpaused', { fullName: [Bytes, Bytes] }>;
+    CallUnpaused: GenericPalletEvent<'TxPause', 'CallUnpaused', { fullName: [Bytes, Bytes] }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `SafeMode`'s events
@@ -5337,51 +4988,51 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The safe-mode was entered until inclusively this block.
      **/
-    Entered: GenericPalletEvent<Rv, 'SafeMode', 'Entered', { until: number }>;
+    Entered: GenericPalletEvent<'SafeMode', 'Entered', { until: number }>;
 
     /**
      * The safe-mode was extended until inclusively this block.
      **/
-    Extended: GenericPalletEvent<Rv, 'SafeMode', 'Extended', { until: number }>;
+    Extended: GenericPalletEvent<'SafeMode', 'Extended', { until: number }>;
 
     /**
      * Exited the safe-mode for a specific reason.
      **/
-    Exited: GenericPalletEvent<Rv, 'SafeMode', 'Exited', { reason: PalletSafeModeExitReason }>;
+    Exited: GenericPalletEvent<'SafeMode', 'Exited', { reason: PalletSafeModeExitReason }>;
 
     /**
      * An account reserved funds for either entering or extending the safe-mode.
      **/
-    DepositPlaced: GenericPalletEvent<Rv, 'SafeMode', 'DepositPlaced', { account: AccountId32; amount: bigint }>;
+    DepositPlaced: GenericPalletEvent<'SafeMode', 'DepositPlaced', { account: AccountId32; amount: bigint }>;
 
     /**
      * An account had a reserve released that was reserved.
      **/
-    DepositReleased: GenericPalletEvent<Rv, 'SafeMode', 'DepositReleased', { account: AccountId32; amount: bigint }>;
+    DepositReleased: GenericPalletEvent<'SafeMode', 'DepositReleased', { account: AccountId32; amount: bigint }>;
 
     /**
      * An account had reserve slashed that was reserved.
      **/
-    DepositSlashed: GenericPalletEvent<Rv, 'SafeMode', 'DepositSlashed', { account: AccountId32; amount: bigint }>;
+    DepositSlashed: GenericPalletEvent<'SafeMode', 'DepositSlashed', { account: AccountId32; amount: bigint }>;
 
     /**
      * Could not hold funds for entering or extending the safe-mode.
      *
      * This error comes from the underlying `Currency`.
      **/
-    CannotDeposit: GenericPalletEvent<Rv, 'SafeMode', 'CannotDeposit', null>;
+    CannotDeposit: GenericPalletEvent<'SafeMode', 'CannotDeposit', null>;
 
     /**
      * Could not release funds for entering or extending the safe-mode.
      *
      * This error comes from the underlying `Currency`.
      **/
-    CannotRelease: GenericPalletEvent<Rv, 'SafeMode', 'CannotRelease', null>;
+    CannotRelease: GenericPalletEvent<'SafeMode', 'CannotRelease', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Statement`'s events
@@ -5391,7 +5042,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new statement is submitted
      **/
     NewStatement: GenericPalletEvent<
-      Rv,
       'Statement',
       'NewStatement',
       { account: AccountId32; statement: SpStatementStoreStatement }
@@ -5400,7 +5050,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MultiBlockMigrations`'s events
@@ -5412,7 +5062,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
      **/
     UpgradeStarted: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'UpgradeStarted',
       {
@@ -5431,20 +5080,19 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      *
      * This implies that all of its migrations completed successfully as well.
      **/
-    UpgradeCompleted: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeCompleted', null>;
+    UpgradeCompleted: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeCompleted', null>;
 
     /**
      * Runtime upgrade failed.
      *
      * This is very bad and will require governance intervention.
      **/
-    UpgradeFailed: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeFailed', null>;
+    UpgradeFailed: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeFailed', null>;
 
     /**
      * A migration was skipped since it was already executed in the past.
      **/
     MigrationSkipped: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationSkipped',
       {
@@ -5459,7 +5107,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A migration progressed.
      **/
     MigrationAdvanced: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationAdvanced',
       {
@@ -5479,7 +5126,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Migration completed.
      **/
     MigrationCompleted: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationCompleted',
       {
@@ -5501,7 +5147,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This implies that the whole upgrade failed and governance intervention is required.
      **/
     MigrationFailed: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationFailed',
       {
@@ -5521,7 +5166,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The set of historical migrations has been cleared.
      **/
     HistoricCleared: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'HistoricCleared',
       {
@@ -5535,7 +5179,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Broker`'s events
@@ -5545,7 +5189,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region of Bulk Coretime has been purchased.
      **/
     Purchased: GenericPalletEvent<
-      Rv,
       'Broker',
       'Purchased',
       {
@@ -5575,7 +5218,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The workload of a core has become renewable.
      **/
     Renewable: GenericPalletEvent<
-      Rv,
       'Broker',
       'Renewable',
       {
@@ -5607,7 +5249,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A workload has been renewed.
      **/
     Renewed: GenericPalletEvent<
-      Rv,
       'Broker',
       'Renewed',
       {
@@ -5652,7 +5293,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Ownership of a Region has been transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'Broker',
       'Transferred',
       {
@@ -5682,7 +5322,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region has been split into two non-overlapping Regions.
      **/
     Partitioned: GenericPalletEvent<
-      Rv,
       'Broker',
       'Partitioned',
       {
@@ -5702,7 +5341,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region has been converted into two overlapping Regions each of lesser regularity.
      **/
     Interlaced: GenericPalletEvent<
-      Rv,
       'Broker',
       'Interlaced',
       {
@@ -5722,7 +5360,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region has been assigned to a particular task.
      **/
     Assigned: GenericPalletEvent<
-      Rv,
       'Broker',
       'Assigned',
       {
@@ -5747,7 +5384,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An assignment has been removed from the workplan.
      **/
     AssignmentRemoved: GenericPalletEvent<
-      Rv,
       'Broker',
       'AssignmentRemoved',
       {
@@ -5762,7 +5398,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region has been added to the Instantaneous Coretime Pool.
      **/
     Pooled: GenericPalletEvent<
-      Rv,
       'Broker',
       'Pooled',
       {
@@ -5782,7 +5417,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new number of cores has been requested.
      **/
     CoreCountRequested: GenericPalletEvent<
-      Rv,
       'Broker',
       'CoreCountRequested',
       {
@@ -5797,7 +5431,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The number of cores available for scheduling has changed.
      **/
     CoreCountChanged: GenericPalletEvent<
-      Rv,
       'Broker',
       'CoreCountChanged',
       {
@@ -5812,7 +5445,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * There is a new reservation for a workload.
      **/
     ReservationMade: GenericPalletEvent<
-      Rv,
       'Broker',
       'ReservationMade',
       {
@@ -5832,7 +5464,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A reservation for a workload has been cancelled.
      **/
     ReservationCancelled: GenericPalletEvent<
-      Rv,
       'Broker',
       'ReservationCancelled',
       {
@@ -5852,7 +5483,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new sale has been initialized.
      **/
     SaleInitialized: GenericPalletEvent<
-      Rv,
       'Broker',
       'SaleInitialized',
       {
@@ -5904,7 +5534,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new lease has been created.
      **/
     Leased: GenericPalletEvent<
-      Rv,
       'Broker',
       'Leased',
       {
@@ -5926,7 +5555,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A lease has been removed.
      **/
     LeaseRemoved: GenericPalletEvent<
-      Rv,
       'Broker',
       'LeaseRemoved',
       {
@@ -5941,7 +5569,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A lease is about to end.
      **/
     LeaseEnding: GenericPalletEvent<
-      Rv,
       'Broker',
       'LeaseEnding',
       {
@@ -5961,7 +5588,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The sale rotation has been started and a new sale is imminent.
      **/
     SalesStarted: GenericPalletEvent<
-      Rv,
       'Broker',
       'SalesStarted',
       {
@@ -5981,7 +5607,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The act of claiming revenue has begun.
      **/
     RevenueClaimBegun: GenericPalletEvent<
-      Rv,
       'Broker',
       'RevenueClaimBegun',
       {
@@ -6001,7 +5626,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A particular timeslice has a non-zero claim.
      **/
     RevenueClaimItem: GenericPalletEvent<
-      Rv,
       'Broker',
       'RevenueClaimItem',
       {
@@ -6021,7 +5645,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A revenue claim has (possibly only in part) been paid.
      **/
     RevenueClaimPaid: GenericPalletEvent<
-      Rv,
       'Broker',
       'RevenueClaimPaid',
       {
@@ -6046,7 +5669,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some Instantaneous Coretime Pool credit has been purchased.
      **/
     CreditPurchased: GenericPalletEvent<
-      Rv,
       'Broker',
       'CreditPurchased',
       {
@@ -6071,7 +5693,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Region has been dropped due to being out of date.
      **/
     RegionDropped: GenericPalletEvent<
-      Rv,
       'Broker',
       'RegionDropped',
       {
@@ -6091,7 +5712,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some historical Instantaneous Core Pool contribution record has been dropped.
      **/
     ContributionDropped: GenericPalletEvent<
-      Rv,
       'Broker',
       'ContributionDropped',
       {
@@ -6106,7 +5726,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some historical Instantaneous Core Pool payment record has been initialized.
      **/
     HistoryInitialized: GenericPalletEvent<
-      Rv,
       'Broker',
       'HistoryInitialized',
       {
@@ -6132,7 +5751,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some historical Instantaneous Core Pool payment record has been dropped.
      **/
     HistoryDropped: GenericPalletEvent<
-      Rv,
       'Broker',
       'HistoryDropped',
       {
@@ -6153,7 +5771,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * timeslice was already known. Governance may need to intervene.
      **/
     HistoryIgnored: GenericPalletEvent<
-      Rv,
       'Broker',
       'HistoryIgnored',
       {
@@ -6173,7 +5790,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some historical Instantaneous Core Pool Revenue is ready for payout claims.
      **/
     ClaimsReady: GenericPalletEvent<
-      Rv,
       'Broker',
       'ClaimsReady',
       {
@@ -6198,7 +5814,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Core has been assigned to one or more tasks and/or the Pool on the Relay-chain.
      **/
     CoreAssigned: GenericPalletEvent<
-      Rv,
       'Broker',
       'CoreAssigned',
       {
@@ -6223,7 +5838,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some historical Instantaneous Core Pool payment record has been dropped.
      **/
     PotentialRenewalDropped: GenericPalletEvent<
-      Rv,
       'Broker',
       'PotentialRenewalDropped',
       {
@@ -6239,7 +5853,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     AutoRenewalEnabled: GenericPalletEvent<
-      Rv,
       'Broker',
       'AutoRenewalEnabled',
       {
@@ -6255,7 +5868,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     AutoRenewalDisabled: GenericPalletEvent<
-      Rv,
       'Broker',
       'AutoRenewalDisabled',
       {
@@ -6276,7 +5888,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * funded.
      **/
     AutoRenewalFailed: GenericPalletEvent<
-      Rv,
       'Broker',
       'AutoRenewalFailed',
       {
@@ -6300,12 +5911,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This should never happen, given that enable_auto_renew checks for this before enabling
      * auto-renewal.
      **/
-    AutoRenewalLimitReached: GenericPalletEvent<Rv, 'Broker', 'AutoRenewalLimitReached', null>;
+    AutoRenewalLimitReached: GenericPalletEvent<'Broker', 'AutoRenewalLimitReached', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Parameters`'s events
@@ -6317,7 +5928,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Is also emitted when the value was not changed.
      **/
     Updated: GenericPalletEvent<
-      Rv,
       'Parameters',
       'Updated',
       {
@@ -6341,7 +5951,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `SkipFeelessPayment`'s events
@@ -6350,12 +5960,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A transaction fee was skipped.
      **/
-    FeeSkipped: GenericPalletEvent<Rv, 'SkipFeelessPayment', 'FeeSkipped', { origin: KitchensinkRuntimeOriginCaller }>;
+    FeeSkipped: GenericPalletEvent<'SkipFeelessPayment', 'FeeSkipped', { origin: KitchensinkRuntimeOriginCaller }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetConversionMigration`'s events
@@ -6365,7 +5975,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Indicates that a pool has been migrated to the new account ID.
      **/
     MigratedToNewAccount: GenericPalletEvent<
-      Rv,
       'AssetConversionMigration',
       'MigratedToNewAccount',
       {
@@ -6389,7 +5998,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Revive`'s events
@@ -6399,7 +6008,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A custom event emitted by the contract.
      **/
     ContractEmitted: GenericPalletEvent<
-      Rv,
       'Revive',
       'ContractEmitted',
       {
@@ -6425,7 +6033,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `DelegatedStaking`'s events
@@ -6435,7 +6043,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Funds delegated by a delegator.
      **/
     Delegated: GenericPalletEvent<
-      Rv,
       'DelegatedStaking',
       'Delegated',
       { agent: AccountId32; delegator: AccountId32; amount: bigint }
@@ -6445,7 +6052,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Funds released to a delegator.
      **/
     Released: GenericPalletEvent<
-      Rv,
       'DelegatedStaking',
       'Released',
       { agent: AccountId32; delegator: AccountId32; amount: bigint }
@@ -6455,7 +6061,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Funds slashed from a delegator.
      **/
     Slashed: GenericPalletEvent<
-      Rv,
       'DelegatedStaking',
       'Slashed',
       { agent: AccountId32; delegator: AccountId32; amount: bigint }
@@ -6465,7 +6070,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Unclaimed delegation funds migrated to delegator.
      **/
     MigratedDelegation: GenericPalletEvent<
-      Rv,
       'DelegatedStaking',
       'MigratedDelegation',
       { agent: AccountId32; delegator: AccountId32; amount: bigint }
@@ -6474,7 +6078,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetRewards`'s events
@@ -6484,7 +6088,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account staked some tokens in a pool.
      **/
     Staked: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'Staked',
       {
@@ -6509,7 +6112,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account unstaked some tokens from a pool.
      **/
     Unstaked: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'Unstaked',
       {
@@ -6539,7 +6141,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account harvested some rewards.
      **/
     RewardsHarvested: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'RewardsHarvested',
       {
@@ -6569,7 +6170,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new reward pool was created.
      **/
     PoolCreated: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'PoolCreated',
       {
@@ -6614,7 +6214,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool reward rate was modified by the admin.
      **/
     PoolRewardRateModified: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'PoolRewardRateModified',
       {
@@ -6634,7 +6233,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool admin was modified.
      **/
     PoolAdminModified: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'PoolAdminModified',
       {
@@ -6654,7 +6252,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool expiry block was modified by the admin.
      **/
     PoolExpiryBlockModified: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'PoolExpiryBlockModified',
       {
@@ -6674,7 +6271,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pool information was cleared after it's completion.
      **/
     PoolCleanedUp: GenericPalletEvent<
-      Rv,
       'AssetRewards',
       'PoolCleanedUp',
       {
@@ -6688,19 +6284,19 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetsFreezer`'s events
    **/
   assetsFreezer: {
-    Frozen: GenericPalletEvent<Rv, 'AssetsFreezer', 'Frozen', { who: AccountId32; assetId: number; amount: bigint }>;
-    Thawed: GenericPalletEvent<Rv, 'AssetsFreezer', 'Thawed', { who: AccountId32; assetId: number; amount: bigint }>;
+    Frozen: GenericPalletEvent<'AssetsFreezer', 'Frozen', { who: AccountId32; assetId: number; amount: bigint }>;
+    Thawed: GenericPalletEvent<'AssetsFreezer', 'Thawed', { who: AccountId32; assetId: number; amount: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MetaTx`'s events
@@ -6713,7 +6309,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * information.
      **/
     Dispatched: GenericPalletEvent<
-      Rv,
       'MetaTx',
       'Dispatched',
       { result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo> }
@@ -6722,6 +6317,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
 }