@dedot/chaintypes 0.194.0 → 0.196.0

package/kusama/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,
@@ -70,7 +70,7 @@ import type {
   PalletRcMigratorQueuePriority,
 } from './types.js';
 
-export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
+export interface ChainEvents extends GenericChainEvents {
   /**
    * Pallet `System`'s events
    **/
@@ -78,18 +78,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 }
@@ -98,33 +92,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 }
@@ -133,7 +126,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Indices`'s events
@@ -142,23 +135,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 }
@@ -167,7 +159,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Balances`'s events
@@ -176,40 +168,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 }
@@ -218,87 +209,87 @@ 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 }>;
 
     /**
      * An unexpected/defensive event was triggered.
      **/
-    Unexpected: GenericPalletEvent<Rv, 'Balances', 'Unexpected', PalletBalancesUnexpectedKind>;
+    Unexpected: GenericPalletEvent<'Balances', 'Unexpected', PalletBalancesUnexpectedKind>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TransactionPayment`'s events
@@ -309,7 +300,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 }
@@ -318,7 +308,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Staking`'s events
@@ -328,18 +318,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 }
@@ -348,14 +332,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 }
@@ -365,17 +348,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\]
@@ -383,39 +361,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 }
@@ -425,7 +402,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 }
@@ -434,38 +410,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 `Offences`'s events
@@ -476,12 +447,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 `Historical`'s events
@@ -490,17 +461,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The merkle root of the validators of the said session were stored
      **/
-    RootStored: GenericPalletEvent<Rv, 'Historical', 'RootStored', { index: number }>;
+    RootStored: GenericPalletEvent<'Historical', 'RootStored', { index: number }>;
 
     /**
      * The merkle roots of up to this session index were pruned
      **/
-    RootsPruned: GenericPalletEvent<Rv, 'Historical', 'RootsPruned', { upTo: number }>;
+    RootsPruned: GenericPalletEvent<'Historical', 'RootsPruned', { upTo: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Session`'s events
@@ -510,28 +481,28 @@ 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 }>;
 
     /**
      * The `NewSession` event in the current block also implies a new validator set to be
      * queued.
      **/
-    NewQueued: GenericPalletEvent<Rv, 'Session', 'NewQueued', null>;
+    NewQueued: GenericPalletEvent<'Session', 'NewQueued', null>;
 
     /**
      * 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 `Grandpa`'s events
@@ -541,7 +512,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]> }
@@ -550,17 +520,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
@@ -569,38 +539,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 }
@@ -609,18 +573,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',
       {
@@ -636,28 +594,28 @@ 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: bigint }>;
+    Paid: GenericPalletEvent<'Treasury', 'Paid', { index: number; paymentId: bigint }>;
 
     /**
      * A payment failed and can be retried.
      **/
-    PaymentFailed: GenericPalletEvent<Rv, 'Treasury', 'PaymentFailed', { index: number; paymentId: bigint }>;
+    PaymentFailed: GenericPalletEvent<'Treasury', 'PaymentFailed', { index: number; paymentId: bigint }>;
 
     /**
      * 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 `ConvictionVoting`'s events
@@ -666,18 +624,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 }
@@ -687,7 +644,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A vote has been removed
      **/
     VoteRemoved: GenericPalletEvent<
-      Rv,
       'ConvictionVoting',
       'VoteRemoved',
       { who: AccountId32; vote: PalletConvictionVotingVoteAccountVote }
@@ -696,12 +652,12 @@ 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 `Referenda`'s events
@@ -711,7 +667,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been submitted.
      **/
     Submitted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Submitted',
       {
@@ -736,7 +691,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been placed.
      **/
     DecisionDepositPlaced: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionDepositPlaced',
       {
@@ -761,7 +715,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been refunded.
      **/
     DecisionDepositRefunded: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionDepositRefunded',
       {
@@ -786,7 +739,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A deposit has been slashed.
      **/
     DepositSlashed: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DepositSlashed',
       {
@@ -806,7 +758,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has moved into the deciding phase.
      **/
     DecisionStarted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'DecisionStarted',
       {
@@ -832,7 +783,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmStarted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'ConfirmStarted',
       {
@@ -843,7 +793,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmAborted: GenericPalletEvent<
-      Rv,
       'Referenda',
       'ConfirmAborted',
       {
@@ -858,7 +807,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',
       {
@@ -878,7 +826,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',
       {
@@ -893,7 +840,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proposal has been rejected by referendum.
      **/
     Rejected: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Rejected',
       {
@@ -913,7 +859,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been timed out without being decided.
      **/
     TimedOut: GenericPalletEvent<
-      Rv,
       'Referenda',
       'TimedOut',
       {
@@ -933,7 +878,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been cancelled.
      **/
     Cancelled: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Cancelled',
       {
@@ -953,7 +897,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been killed.
      **/
     Killed: GenericPalletEvent<
-      Rv,
       'Referenda',
       'Killed',
       {
@@ -973,7 +916,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The submission deposit has been refunded.
      **/
     SubmissionDepositRefunded: GenericPalletEvent<
-      Rv,
       'Referenda',
       'SubmissionDepositRefunded',
       {
@@ -998,7 +940,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Referenda',
       'MetadataSet',
       {
@@ -1018,7 +959,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'Referenda',
       'MetadataCleared',
       {
@@ -1037,7 +977,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `FellowshipCollective`'s events
@@ -1046,24 +986,23 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A member `who` has been added.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'FellowshipCollective', 'MemberAdded', { who: AccountId32 }>;
+    MemberAdded: GenericPalletEvent<'FellowshipCollective', 'MemberAdded', { who: AccountId32 }>;
 
     /**
      * The member `who`se rank has been changed to the given `rank`.
      **/
-    RankChanged: GenericPalletEvent<Rv, 'FellowshipCollective', 'RankChanged', { who: AccountId32; rank: number }>;
+    RankChanged: GenericPalletEvent<'FellowshipCollective', 'RankChanged', { who: AccountId32; rank: number }>;
 
     /**
      * The member `who` of given `rank` has been removed from the collective.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'FellowshipCollective', 'MemberRemoved', { who: AccountId32; rank: number }>;
+    MemberRemoved: GenericPalletEvent<'FellowshipCollective', '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,
       'FellowshipCollective',
       'Voted',
       { who: AccountId32; poll: number; vote: PalletRankedCollectiveVoteRecord; tally: PalletRankedCollectiveTally }
@@ -1073,7 +1012,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The member `who` had their `AccountId` changed to `new_who`.
      **/
     MemberExchanged: GenericPalletEvent<
-      Rv,
       'FellowshipCollective',
       'MemberExchanged',
       { who: AccountId32; newWho: AccountId32 }
@@ -1082,7 +1020,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `FellowshipReferenda`'s events
@@ -1092,7 +1030,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been submitted.
      **/
     Submitted: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'Submitted',
       {
@@ -1117,7 +1054,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been placed.
      **/
     DecisionDepositPlaced: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'DecisionDepositPlaced',
       {
@@ -1142,7 +1078,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The decision deposit has been refunded.
      **/
     DecisionDepositRefunded: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'DecisionDepositRefunded',
       {
@@ -1167,7 +1102,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A deposit has been slashed.
      **/
     DepositSlashed: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'DepositSlashed',
       {
@@ -1187,7 +1121,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has moved into the deciding phase.
      **/
     DecisionStarted: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'DecisionStarted',
       {
@@ -1213,7 +1146,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmStarted: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'ConfirmStarted',
       {
@@ -1224,7 +1156,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
     ConfirmAborted: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'ConfirmAborted',
       {
@@ -1239,7 +1170,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,
       'FellowshipReferenda',
       'Confirmed',
       {
@@ -1259,7 +1189,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been approved and its proposal has been scheduled.
      **/
     Approved: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'Approved',
       {
@@ -1274,7 +1203,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proposal has been rejected by referendum.
      **/
     Rejected: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'Rejected',
       {
@@ -1294,7 +1222,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been timed out without being decided.
      **/
     TimedOut: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'TimedOut',
       {
@@ -1314,7 +1241,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been cancelled.
      **/
     Cancelled: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'Cancelled',
       {
@@ -1334,7 +1260,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A referendum has been killed.
      **/
     Killed: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'Killed',
       {
@@ -1354,7 +1279,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The submission deposit has been refunded.
      **/
     SubmissionDepositRefunded: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'SubmissionDepositRefunded',
       {
@@ -1379,7 +1303,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'MetadataSet',
       {
@@ -1399,7 +1322,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'FellowshipReferenda',
       'MetadataCleared',
       {
@@ -1418,16 +1340,15 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * 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> }
@@ -1436,7 +1357,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Parameters`'s events
@@ -1448,7 +1369,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Is also emitted when the value was not changed.
      **/
     Updated: GenericPalletEvent<
-      Rv,
       'Parameters',
       'Updated',
       {
@@ -1472,7 +1392,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Claims`'s events
@@ -1482,7 +1402,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Someone claimed some DOTs.
      **/
     Claimed: GenericPalletEvent<
-      Rv,
       'Claims',
       'Claimed',
       { who: AccountId32; ethereumAddress: EthereumAddress; amount: bigint }
@@ -1491,7 +1410,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Utility`'s events
@@ -1501,47 +1420,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 `Society`'s events
@@ -1550,51 +1469,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 }
@@ -1603,53 +1516,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 }>;
 
     /**
      * A deposit was poked / adjusted.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Society',
       'DepositPoked',
       { who: AccountId32; oldDeposit: bigint; newDeposit: bigint }
@@ -1658,7 +1570,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Recovery`'s events
@@ -1667,13 +1579,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 }
@@ -1683,7 +1594,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 }
@@ -1693,7 +1603,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 }
@@ -1703,7 +1612,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 }
@@ -1712,13 +1620,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 }>;
 
     /**
      * A deposit has been updated.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Recovery',
       'DepositPoked',
       { who: AccountId32; kind: PalletRecoveryDepositKind; oldDeposit: bigint; newDeposit: bigint }
@@ -1727,7 +1634,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Vesting`'s events
@@ -1736,28 +1643,23 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A vesting schedule has been created.
      **/
-    VestingCreated: GenericPalletEvent<
-      Rv,
-      'Vesting',
-      'VestingCreated',
-      { account: AccountId32; scheduleIndex: number }
-    >;
+    VestingCreated: GenericPalletEvent<'Vesting', 'VestingCreated', { account: AccountId32; scheduleIndex: number }>;
 
     /**
      * 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
@@ -1766,18 +1668,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> }
@@ -1787,7 +1688,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 }
@@ -1797,7 +1697,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 }
@@ -1807,7 +1706,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 }
@@ -1817,7 +1715,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 }
@@ -1828,7 +1725,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 }
@@ -1838,7 +1734,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 }
@@ -1847,12 +1742,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 `Proxy`'s events
@@ -1861,14 +1756,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',
       {
@@ -1883,7 +1777,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A pure proxy was killed by its spawner.
      **/
     PureKilled: GenericPalletEvent<
-      Rv,
       'Proxy',
       'PureKilled',
       {
@@ -1897,13 +1790,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: KusamaRuntimeConstantsProxyProxyType; delay: number }
@@ -1913,7 +1805,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proxy was removed.
      **/
     ProxyRemoved: GenericPalletEvent<
-      Rv,
       'Proxy',
       'ProxyRemoved',
       { delegator: AccountId32; delegatee: AccountId32; proxyType: KusamaRuntimeConstantsProxyProxyType; delay: number }
@@ -1923,7 +1814,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 }
@@ -1932,7 +1822,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Multisig`'s events
@@ -1942,7 +1832,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> }
@@ -1952,7 +1841,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> }
@@ -1962,7 +1850,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A multisig operation has been executed.
      **/
     MultisigExecuted: GenericPalletEvent<
-      Rv,
       'Multisig',
       'MultisigExecuted',
       {
@@ -1978,7 +1865,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> }
@@ -1988,7 +1874,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 }
@@ -1997,7 +1882,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Preimage`'s events
@@ -2006,22 +1891,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 `Bounties`'s events
@@ -2030,28 +1915,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 }
@@ -2060,38 +1944,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 }>;
 
     /**
      * A bounty deposit has been poked.
      **/
     DepositPoked: GenericPalletEvent<
-      Rv,
       'Bounties',
       'DepositPoked',
       { bountyId: number; proposer: AccountId32; oldDeposit: bigint; newDeposit: bigint }
@@ -2100,7 +1983,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ChildBounties`'s events
@@ -2109,13 +1992,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 }
@@ -2125,7 +2007,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 }
@@ -2134,12 +2015,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 `ElectionProviderMultiPhase`'s events
@@ -2155,7 +2036,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * room for this one.
      **/
     SolutionStored: GenericPalletEvent<
-      Rv,
       'ElectionProviderMultiPhase',
       'SolutionStored',
       {
@@ -2169,7 +2049,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 }
@@ -2180,23 +2059,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 }
@@ -2205,7 +2083,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `VoterList`'s events
@@ -2214,17 +2092,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 `NominationPools`'s events
@@ -2233,13 +2111,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 }
@@ -2248,12 +2125,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.
@@ -2269,7 +2141,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 }
@@ -2284,7 +2155,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 }
@@ -2293,13 +2163,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 }
@@ -2313,7 +2182,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 }
@@ -2324,7 +2192,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 }
@@ -2333,13 +2200,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 }
@@ -2349,7 +2215,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 }
@@ -2359,7 +2224,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 }
@@ -2369,7 +2233,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 }
@@ -2379,7 +2242,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 }
@@ -2389,7 +2251,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Pool commission has been claimed.
      **/
     PoolCommissionClaimed: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'PoolCommissionClaimed',
       { poolId: number; commission: bigint }
@@ -2399,7 +2260,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 }
@@ -2409,7 +2269,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 }
@@ -2419,7 +2278,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 }
@@ -2428,19 +2286,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 }
@@ -2450,7 +2302,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 }
@@ -2460,7 +2311,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Global parameters regulating nomination pools have been updated.
      **/
     GlobalParamsUpdated: GenericPalletEvent<
-      Rv,
       'NominationPools',
       'GlobalParamsUpdated',
       {
@@ -2476,7 +2326,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `FastUnstake`'s events
@@ -2485,22 +2335,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.
@@ -2508,17 +2353,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 `DelegatedStaking`'s events
@@ -2528,7 +2373,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 }
@@ -2538,7 +2382,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 }
@@ -2548,7 +2391,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 }
@@ -2558,7 +2400,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 }
@@ -2567,7 +2408,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `StakingAhClient`'s events
@@ -2577,7 +2418,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new validator set has been received.
      **/
     ValidatorSetReceived: GenericPalletEvent<
-      Rv,
       'StakingAhClient',
       'ValidatorSetReceived',
       { id: number; newValidatorSetCount: number; pruneUpTo?: number | undefined; leftover: boolean }
@@ -2589,24 +2429,24 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Note that this event is more resembling an error, but we use an event because in this
      * pallet we need to mutate storage upon some failures.
      **/
-    CouldNotMergeAndDropped: GenericPalletEvent<Rv, 'StakingAhClient', 'CouldNotMergeAndDropped', null>;
+    CouldNotMergeAndDropped: GenericPalletEvent<'StakingAhClient', 'CouldNotMergeAndDropped', null>;
 
     /**
      * The validator set received is way too small, as per
      * [`Config::MinimumValidatorSetSize`].
      **/
-    SetTooSmallAndDropped: GenericPalletEvent<Rv, 'StakingAhClient', 'SetTooSmallAndDropped', null>;
+    SetTooSmallAndDropped: GenericPalletEvent<'StakingAhClient', 'SetTooSmallAndDropped', null>;
 
     /**
      * Something occurred that should never happen under normal operation. Logged as an event
      * for fail-safe observability.
      **/
-    Unexpected: GenericPalletEvent<Rv, 'StakingAhClient', 'Unexpected', PalletStakingAsyncAhClientUnexpectedKind>;
+    Unexpected: GenericPalletEvent<'StakingAhClient', 'Unexpected', PalletStakingAsyncAhClientUnexpectedKind>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ParaInclusion`'s events
@@ -2616,7 +2456,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A candidate was backed. `[candidate, head_data]`
      **/
     CandidateBacked: GenericPalletEvent<
-      Rv,
       'ParaInclusion',
       'CandidateBacked',
       [
@@ -2631,7 +2470,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A candidate was included. `[candidate, head_data]`
      **/
     CandidateIncluded: GenericPalletEvent<
-      Rv,
       'ParaInclusion',
       'CandidateIncluded',
       [
@@ -2646,7 +2484,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A candidate timed out. `[candidate, head_data]`
      **/
     CandidateTimedOut: GenericPalletEvent<
-      Rv,
       'ParaInclusion',
       'CandidateTimedOut',
       [
@@ -2660,7 +2497,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some upward messages have been received and will be processed.
      **/
     UpwardMessagesReceived: GenericPalletEvent<
-      Rv,
       'ParaInclusion',
       'UpwardMessagesReceived',
       { from: PolkadotParachainPrimitivesPrimitivesId; count: number }
@@ -2669,7 +2505,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Paras`'s events
@@ -2678,39 +2514,33 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Current code has been updated for a Para. `para_id`
      **/
-    CurrentCodeUpdated: GenericPalletEvent<Rv, 'Paras', 'CurrentCodeUpdated', PolkadotParachainPrimitivesPrimitivesId>;
+    CurrentCodeUpdated: GenericPalletEvent<'Paras', 'CurrentCodeUpdated', PolkadotParachainPrimitivesPrimitivesId>;
 
     /**
      * Current head has been updated for a Para. `para_id`
      **/
-    CurrentHeadUpdated: GenericPalletEvent<Rv, 'Paras', 'CurrentHeadUpdated', PolkadotParachainPrimitivesPrimitivesId>;
+    CurrentHeadUpdated: GenericPalletEvent<'Paras', 'CurrentHeadUpdated', PolkadotParachainPrimitivesPrimitivesId>;
 
     /**
      * A code upgrade has been scheduled for a Para. `para_id`
      **/
-    CodeUpgradeScheduled: GenericPalletEvent<
-      Rv,
-      'Paras',
-      'CodeUpgradeScheduled',
-      PolkadotParachainPrimitivesPrimitivesId
-    >;
+    CodeUpgradeScheduled: GenericPalletEvent<'Paras', 'CodeUpgradeScheduled', PolkadotParachainPrimitivesPrimitivesId>;
 
     /**
      * A new head has been noted for a Para. `para_id`
      **/
-    NewHeadNoted: GenericPalletEvent<Rv, 'Paras', 'NewHeadNoted', PolkadotParachainPrimitivesPrimitivesId>;
+    NewHeadNoted: GenericPalletEvent<'Paras', 'NewHeadNoted', PolkadotParachainPrimitivesPrimitivesId>;
 
     /**
      * A para has been queued to execute pending actions. `para_id`
      **/
-    ActionQueued: GenericPalletEvent<Rv, 'Paras', 'ActionQueued', [PolkadotParachainPrimitivesPrimitivesId, number]>;
+    ActionQueued: GenericPalletEvent<'Paras', 'ActionQueued', [PolkadotParachainPrimitivesPrimitivesId, number]>;
 
     /**
      * The given para either initiated or subscribed to a PVF check for the given validation
      * code. `code_hash` `para_id`
      **/
     PvfCheckStarted: GenericPalletEvent<
-      Rv,
       'Paras',
       'PvfCheckStarted',
       [PolkadotParachainPrimitivesPrimitivesValidationCodeHash, PolkadotParachainPrimitivesPrimitivesId]
@@ -2721,7 +2551,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `code_hash` `para_id`
      **/
     PvfCheckAccepted: GenericPalletEvent<
-      Rv,
       'Paras',
       'PvfCheckAccepted',
       [PolkadotParachainPrimitivesPrimitivesValidationCodeHash, PolkadotParachainPrimitivesPrimitivesId]
@@ -2732,7 +2561,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `code_hash` `para_id`
      **/
     PvfCheckRejected: GenericPalletEvent<
-      Rv,
       'Paras',
       'PvfCheckRejected',
       [PolkadotParachainPrimitivesPrimitivesValidationCodeHash, PolkadotParachainPrimitivesPrimitivesId]
@@ -2742,7 +2570,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The upgrade cooldown was removed.
      **/
     UpgradeCooldownRemoved: GenericPalletEvent<
-      Rv,
       'Paras',
       'UpgradeCooldownRemoved',
       {
@@ -2757,7 +2584,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new code hash has been authorized for a Para.
      **/
     CodeAuthorized: GenericPalletEvent<
-      Rv,
       'Paras',
       'CodeAuthorized',
       {
@@ -2781,7 +2607,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Hrmp`'s events
@@ -2791,7 +2617,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Open HRMP channel requested.
      **/
     OpenChannelRequested: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'OpenChannelRequested',
       {
@@ -2806,7 +2631,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An HRMP channel request sent by the receiver was canceled by either party.
      **/
     OpenChannelCanceled: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'OpenChannelCanceled',
       {
@@ -2819,7 +2643,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Open HRMP channel accepted.
      **/
     OpenChannelAccepted: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'OpenChannelAccepted',
       { sender: PolkadotParachainPrimitivesPrimitivesId; recipient: PolkadotParachainPrimitivesPrimitivesId }
@@ -2829,7 +2652,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * HRMP channel closed.
      **/
     ChannelClosed: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'ChannelClosed',
       {
@@ -2842,7 +2664,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An HRMP channel was opened via Root origin.
      **/
     HrmpChannelForceOpened: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'HrmpChannelForceOpened',
       {
@@ -2857,7 +2678,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An HRMP channel was opened with a system chain.
      **/
     HrmpSystemChannelOpened: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'HrmpSystemChannelOpened',
       {
@@ -2872,7 +2692,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An HRMP channel's deposits were updated.
      **/
     OpenChannelDepositsUpdated: GenericPalletEvent<
-      Rv,
       'Hrmp',
       'OpenChannelDepositsUpdated',
       { sender: PolkadotParachainPrimitivesPrimitivesId; recipient: PolkadotParachainPrimitivesPrimitivesId }
@@ -2881,7 +2700,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ParasDisputes`'s events
@@ -2891,7 +2710,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A dispute has been initiated. \[candidate hash, dispute location\]
      **/
     DisputeInitiated: GenericPalletEvent<
-      Rv,
       'ParasDisputes',
       'DisputeInitiated',
       [PolkadotCorePrimitivesCandidateHash, PolkadotRuntimeParachainsDisputesDisputeLocation]
@@ -2902,7 +2720,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `\[para id, candidate hash, dispute result\]`
      **/
     DisputeConcluded: GenericPalletEvent<
-      Rv,
       'ParasDisputes',
       'DisputeConcluded',
       [PolkadotCorePrimitivesCandidateHash, PolkadotRuntimeParachainsDisputesDisputeResult]
@@ -2914,12 +2731,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * instead revert the block at the given height. This should be the
      * number of the child of the last known valid block in the chain.
      **/
-    Revert: GenericPalletEvent<Rv, 'ParasDisputes', 'Revert', number>;
+    Revert: GenericPalletEvent<'ParasDisputes', 'Revert', number>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `OnDemandAssignmentProvider`'s events
@@ -2929,7 +2746,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An order was placed at some spot price amount by orderer ordered_by
      **/
     OnDemandOrderPlaced: GenericPalletEvent<
-      Rv,
       'OnDemandAssignmentProvider',
       'OnDemandOrderPlaced',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; spotPrice: bigint; orderedBy: AccountId32 }
@@ -2938,13 +2754,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The value of the spot price has likely changed
      **/
-    SpotPriceSet: GenericPalletEvent<Rv, 'OnDemandAssignmentProvider', 'SpotPriceSet', { spotPrice: bigint }>;
+    SpotPriceSet: GenericPalletEvent<'OnDemandAssignmentProvider', 'SpotPriceSet', { spotPrice: bigint }>;
 
     /**
      * An account was given credits.
      **/
     AccountCredited: GenericPalletEvent<
-      Rv,
       'OnDemandAssignmentProvider',
       'AccountCredited',
       { who: AccountId32; amount: bigint }
@@ -2953,32 +2768,24 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Registrar`'s events
    **/
   registrar: {
     Registered: GenericPalletEvent<
-      Rv,
       'Registrar',
       'Registered',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; manager: AccountId32 }
     >;
-    Deregistered: GenericPalletEvent<
-      Rv,
-      'Registrar',
-      'Deregistered',
-      { paraId: PolkadotParachainPrimitivesPrimitivesId }
-    >;
+    Deregistered: GenericPalletEvent<'Registrar', 'Deregistered', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
     Reserved: GenericPalletEvent<
-      Rv,
       'Registrar',
       'Reserved',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; who: AccountId32 }
     >;
     Swapped: GenericPalletEvent<
-      Rv,
       'Registrar',
       'Swapped',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; otherId: PolkadotParachainPrimitivesPrimitivesId }
@@ -2987,7 +2794,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Slots`'s events
@@ -2996,7 +2803,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A new `[lease_period]` is beginning.
      **/
-    NewLeasePeriod: GenericPalletEvent<Rv, 'Slots', 'NewLeasePeriod', { leasePeriod: number }>;
+    NewLeasePeriod: GenericPalletEvent<'Slots', 'NewLeasePeriod', { leasePeriod: number }>;
 
     /**
      * A para has won the right to a continuous set of lease periods as a parachain.
@@ -3004,7 +2811,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Second balance is the total amount reserved.
      **/
     Leased: GenericPalletEvent<
-      Rv,
       'Slots',
       'Leased',
       {
@@ -3020,7 +2826,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Auctions`'s events
@@ -3031,7 +2837,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * close and the first lease period of the quadruplet that is auctioned.
      **/
     AuctionStarted: GenericPalletEvent<
-      Rv,
       'Auctions',
       'AuctionStarted',
       { auctionIndex: number; leasePeriod: number; ending: number }
@@ -3040,14 +2845,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An auction ended. All funds become unreserved.
      **/
-    AuctionClosed: GenericPalletEvent<Rv, 'Auctions', 'AuctionClosed', { auctionIndex: number }>;
+    AuctionClosed: GenericPalletEvent<'Auctions', 'AuctionClosed', { auctionIndex: number }>;
 
     /**
      * Funds were reserved for a winning bid. First balance is the extra amount reserved.
      * Second is the total.
      **/
     Reserved: GenericPalletEvent<
-      Rv,
       'Auctions',
       'Reserved',
       { bidder: AccountId32; extraReserved: bigint; totalAmount: bigint }
@@ -3056,14 +2860,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Funds were unreserved since bidder is no longer active. `[bidder, amount]`
      **/
-    Unreserved: GenericPalletEvent<Rv, 'Auctions', 'Unreserved', { bidder: AccountId32; amount: bigint }>;
+    Unreserved: GenericPalletEvent<'Auctions', 'Unreserved', { bidder: AccountId32; amount: bigint }>;
 
     /**
      * Someone attempted to lease the same slot twice for a parachain. The amount is held in
      * reserve but no parachain slot has been leased.
      **/
     ReserveConfiscated: GenericPalletEvent<
-      Rv,
       'Auctions',
       'ReserveConfiscated',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; leaser: AccountId32; amount: bigint }
@@ -3073,7 +2876,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A new bid has been accepted as the current winner.
      **/
     BidAccepted: GenericPalletEvent<
-      Rv,
       'Auctions',
       'BidAccepted',
       {
@@ -3089,12 +2891,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The winning offset was chosen for an auction. This will map into the `Winning` storage
      * map.
      **/
-    WinningOffset: GenericPalletEvent<Rv, 'Auctions', 'WinningOffset', { auctionIndex: number; blockNumber: number }>;
+    WinningOffset: GenericPalletEvent<'Auctions', 'WinningOffset', { auctionIndex: number; blockNumber: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Crowdloan`'s events
@@ -3103,13 +2905,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Create a new crowdloaning campaign.
      **/
-    Created: GenericPalletEvent<Rv, 'Crowdloan', 'Created', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
+    Created: GenericPalletEvent<'Crowdloan', 'Created', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
 
     /**
      * Contributed to a crowd sale.
      **/
     Contributed: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'Contributed',
       { who: AccountId32; fundIndex: PolkadotParachainPrimitivesPrimitivesId; amount: bigint }
@@ -3119,7 +2920,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Withdrew full balance of a contributor.
      **/
     Withdrew: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'Withdrew',
       { who: AccountId32; fundIndex: PolkadotParachainPrimitivesPrimitivesId; amount: bigint }
@@ -3130,7 +2930,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * over child keys that still need to be killed.
      **/
     PartiallyRefunded: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'PartiallyRefunded',
       { paraId: PolkadotParachainPrimitivesPrimitivesId }
@@ -3139,23 +2938,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * All loans in a fund have been refunded.
      **/
-    AllRefunded: GenericPalletEvent<
-      Rv,
-      'Crowdloan',
-      'AllRefunded',
-      { paraId: PolkadotParachainPrimitivesPrimitivesId }
-    >;
+    AllRefunded: GenericPalletEvent<'Crowdloan', 'AllRefunded', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
 
     /**
      * Fund is dissolved.
      **/
-    Dissolved: GenericPalletEvent<Rv, 'Crowdloan', 'Dissolved', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
+    Dissolved: GenericPalletEvent<'Crowdloan', 'Dissolved', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
 
     /**
      * The result of trying to submit a new bid to the Slots pallet.
      **/
     HandleBidResult: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'HandleBidResult',
       { paraId: PolkadotParachainPrimitivesPrimitivesId; result: Result<[], DispatchError> }
@@ -3164,13 +2957,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The configuration to a crowdloan has been edited.
      **/
-    Edited: GenericPalletEvent<Rv, 'Crowdloan', 'Edited', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
+    Edited: GenericPalletEvent<'Crowdloan', 'Edited', { paraId: PolkadotParachainPrimitivesPrimitivesId }>;
 
     /**
      * A memo has been updated.
      **/
     MemoUpdated: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'MemoUpdated',
       { who: AccountId32; paraId: PolkadotParachainPrimitivesPrimitivesId; memo: Bytes }
@@ -3180,7 +2972,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A parachain has been moved to `NewRaise`
      **/
     AddedToNewRaise: GenericPalletEvent<
-      Rv,
       'Crowdloan',
       'AddedToNewRaise',
       { paraId: PolkadotParachainPrimitivesPrimitivesId }
@@ -3189,7 +2980,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Coretime`'s events
@@ -3198,17 +2989,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The broker chain has asked for revenue information for a specific block.
      **/
-    RevenueInfoRequested: GenericPalletEvent<Rv, 'Coretime', 'RevenueInfoRequested', { when: number }>;
+    RevenueInfoRequested: GenericPalletEvent<'Coretime', 'RevenueInfoRequested', { when: number }>;
 
     /**
      * A core has received a new assignment from the broker chain.
      **/
-    CoreAssigned: GenericPalletEvent<Rv, 'Coretime', 'CoreAssigned', { core: PolkadotPrimitivesV8CoreIndex }>;
+    CoreAssigned: GenericPalletEvent<'Coretime', 'CoreAssigned', { core: PolkadotPrimitivesV8CoreIndex }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `XcmPallet`'s events
@@ -3217,13 +3008,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Execution of an XCM message was attempted.
      **/
-    Attempted: GenericPalletEvent<Rv, 'XcmPallet', 'Attempted', { outcome: StagingXcmV5TraitsOutcome }>;
+    Attempted: GenericPalletEvent<'XcmPallet', 'Attempted', { outcome: StagingXcmV5TraitsOutcome }>;
 
     /**
      * An XCM message was sent.
      **/
     Sent: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'Sent',
       {
@@ -3238,7 +3028,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An XCM message failed to send.
      **/
     SendFailed: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'SendFailed',
       {
@@ -3253,7 +3042,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An XCM message failed to process.
      **/
     ProcessXcmError: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'ProcessXcmError',
       { origin: StagingXcmV5Location; error: XcmV5TraitsError; messageId: FixedBytes<32> }
@@ -3265,7 +3053,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * because the query timed out.
      **/
     UnexpectedResponse: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'UnexpectedResponse',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -3276,7 +3063,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * no registered notification call.
      **/
     ResponseReady: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'ResponseReady',
       { queryId: bigint; response: StagingXcmV5Response }
@@ -3286,12 +3072,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Query response has been received and query is removed. The registered notification has
      * been dispatched and executed successfully.
      **/
-    Notified: GenericPalletEvent<
-      Rv,
-      'XcmPallet',
-      'Notified',
-      { queryId: bigint; palletIndex: number; callIndex: number }
-    >;
+    Notified: GenericPalletEvent<'XcmPallet', 'Notified', { queryId: bigint; palletIndex: number; callIndex: number }>;
 
     /**
      * Query response has been received and query is removed. The registered notification
@@ -3299,7 +3080,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * originally budgeted by this runtime for the query result.
      **/
     NotifyOverweight: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'NotifyOverweight',
       {
@@ -3316,7 +3096,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dispatching the notification call.
      **/
     NotifyDispatchError: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'NotifyDispatchError',
       { queryId: bigint; palletIndex: number; callIndex: number }
@@ -3328,7 +3107,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * is not `(origin, QueryId, Response)`.
      **/
     NotifyDecodeFailed: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'NotifyDecodeFailed',
       { queryId: bigint; palletIndex: number; callIndex: number }
@@ -3340,7 +3118,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * be received and acted upon.
      **/
     InvalidResponder: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'InvalidResponder',
       { origin: StagingXcmV5Location; queryId: bigint; expectedLocation?: StagingXcmV5Location | undefined }
@@ -3356,7 +3133,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * needed.
      **/
     InvalidResponderVersion: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'InvalidResponderVersion',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -3365,13 +3141,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Received query response has been read and removed.
      **/
-    ResponseTaken: GenericPalletEvent<Rv, 'XcmPallet', 'ResponseTaken', { queryId: bigint }>;
+    ResponseTaken: GenericPalletEvent<'XcmPallet', 'ResponseTaken', { queryId: bigint }>;
 
     /**
      * Some assets have been placed in an asset trap.
      **/
     AssetsTrapped: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'AssetsTrapped',
       { hash: H256; origin: StagingXcmV5Location; assets: XcmVersionedAssets }
@@ -3383,7 +3158,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The cost of sending it (borne by the chain) is included.
      **/
     VersionChangeNotified: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'VersionChangeNotified',
       { destination: StagingXcmV5Location; result: number; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -3394,7 +3168,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * automatic notification or a manual intervention.
      **/
     SupportedVersionChanged: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'SupportedVersionChanged',
       { location: StagingXcmV5Location; version: number }
@@ -3405,7 +3178,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * sending the notification to it.
      **/
     NotifyTargetSendFail: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'NotifyTargetSendFail',
       { location: StagingXcmV5Location; queryId: bigint; error: XcmV5TraitsError }
@@ -3416,7 +3188,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * migrating the location to our new XCM format.
      **/
     NotifyTargetMigrationFail: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'NotifyTargetMigrationFail',
       { location: XcmVersionedLocation; queryId: bigint }
@@ -3432,7 +3203,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * needed.
      **/
     InvalidQuerierVersion: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'InvalidQuerierVersion',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -3444,7 +3214,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * be received and acted upon.
      **/
     InvalidQuerier: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'InvalidQuerier',
       {
@@ -3460,7 +3229,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A version information message is sent to them and its cost is included.
      **/
     VersionNotifyStarted: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'VersionNotifyStarted',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -3470,7 +3238,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * We have requested that a remote chain send us XCM version change notifications.
      **/
     VersionNotifyRequested: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'VersionNotifyRequested',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -3481,7 +3248,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * notifications.
      **/
     VersionNotifyUnrequested: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'VersionNotifyUnrequested',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -3491,7 +3257,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Fees were paid from a location for an operation (often for using `SendXcm`).
      **/
     FeesPaid: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'FeesPaid',
       { paying: StagingXcmV5Location; fees: StagingXcmV5AssetAssets }
@@ -3501,7 +3266,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some assets have been claimed from an asset trap
      **/
     AssetsClaimed: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'AssetsClaimed',
       { hash: H256; origin: StagingXcmV5Location; assets: XcmVersionedAssets }
@@ -3510,14 +3274,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A XCM version migration finished.
      **/
-    VersionMigrationFinished: GenericPalletEvent<Rv, 'XcmPallet', 'VersionMigrationFinished', { version: number }>;
+    VersionMigrationFinished: GenericPalletEvent<'XcmPallet', 'VersionMigrationFinished', { version: number }>;
 
     /**
      * An `aliaser` location was authorized by `target` to alias it, authorization valid until
      * `expiry` block number.
      **/
     AliasAuthorized: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'AliasAuthorized',
       { aliaser: StagingXcmV5Location; target: StagingXcmV5Location; expiry?: bigint | undefined }
@@ -3527,7 +3290,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `target` removed alias authorization for `aliaser`.
      **/
     AliasAuthorizationRemoved: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'AliasAuthorizationRemoved',
       { aliaser: StagingXcmV5Location; target: StagingXcmV5Location }
@@ -3537,7 +3299,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `target` removed all alias authorizations.
      **/
     AliasesAuthorizationsRemoved: GenericPalletEvent<
-      Rv,
       'XcmPallet',
       'AliasesAuthorizationsRemoved',
       { target: StagingXcmV5Location }
@@ -3546,7 +3307,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MessageQueue`'s events
@@ -3556,7 +3317,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',
       {
@@ -3584,7 +3344,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message is processed.
      **/
     Processed: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'Processed',
       {
@@ -3619,7 +3378,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message placed in overweight queue.
      **/
     OverweightEnqueued: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'OverweightEnqueued',
       {
@@ -3649,7 +3407,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This page was reaped.
      **/
     PageReaped: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'PageReaped',
       {
@@ -3668,26 +3425,23 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `AssetRate`'s events
    **/
   assetRate: {
     AssetRateCreated: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateCreated',
       { assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset; rate: FixedU128 }
     >;
     AssetRateRemoved: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateRemoved',
       { assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset }
     >;
     AssetRateUpdated: GenericPalletEvent<
-      Rv,
       'AssetRate',
       'AssetRateUpdated',
       { assetKind: PolkadotRuntimeCommonImplsVersionedLocatableAsset; old: FixedU128; new: FixedU128 }
@@ -3696,7 +3450,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `RcMigrator`'s events
@@ -3706,7 +3460,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A stage transition has occurred.
      **/
     StageTransition: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'StageTransition',
       {
@@ -3730,7 +3483,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * to understand. The activation is immediate and affects all events happening
      * afterwards.
      **/
-    AssetHubMigrationStarted: GenericPalletEvent<Rv, 'RcMigrator', 'AssetHubMigrationStarted', null>;
+    AssetHubMigrationStarted: GenericPalletEvent<'RcMigrator', 'AssetHubMigrationStarted', null>;
 
     /**
      * The Asset Hub Migration finished.
@@ -3739,13 +3492,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * to understand. The finishing is immediate and affects all events happening
      * afterwards.
      **/
-    AssetHubMigrationFinished: GenericPalletEvent<Rv, 'RcMigrator', 'AssetHubMigrationFinished', null>;
+    AssetHubMigrationFinished: GenericPalletEvent<'RcMigrator', 'AssetHubMigrationFinished', null>;
 
     /**
      * A query response has been received.
      **/
     QueryResponseReceived: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'QueryResponseReceived',
       {
@@ -3765,7 +3517,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A XCM message has been resent.
      **/
     XcmResendAttempt: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'XcmResendAttempt',
       {
@@ -3785,7 +3536,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The unprocessed message buffer size has been set.
      **/
     UnprocessedMsgBufferSet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'UnprocessedMsgBufferSet',
       {
@@ -3805,7 +3555,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Whether the AH UMP queue was prioritized for the next block.
      **/
     AhUmpQueuePrioritySet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'AhUmpQueuePrioritySet',
       {
@@ -3832,7 +3581,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The AH UMP queue priority config was set.
      **/
     AhUmpQueuePriorityConfigSet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'AhUmpQueuePriorityConfigSet',
       {
@@ -3852,7 +3600,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The total issuance was recorded.
      **/
     MigratedBalanceRecordSet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'MigratedBalanceRecordSet',
       { kept: bigint; migrated: bigint }
@@ -3862,7 +3609,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The RC kept balance was consumed.
      **/
     MigratedBalanceConsumed: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'MigratedBalanceConsumed',
       { kept: bigint; migrated: bigint }
@@ -3872,7 +3618,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The manager account id was set.
      **/
     ManagerSet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'ManagerSet',
       {
@@ -3892,7 +3637,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An XCM message was sent.
      **/
     XcmSent: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'XcmSent',
       {
@@ -3906,13 +3650,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The staking elections were paused.
      **/
-    StakingElectionsPaused: GenericPalletEvent<Rv, 'RcMigrator', 'StakingElectionsPaused', null>;
+    StakingElectionsPaused: GenericPalletEvent<'RcMigrator', 'StakingElectionsPaused', null>;
 
     /**
      * The accounts to be preserved on Relay Chain were set.
      **/
     AccountsPreserved: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'AccountsPreserved',
       {
@@ -3927,7 +3670,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The canceller account id was set.
      **/
     CancellerSet: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'CancellerSet',
       {
@@ -3947,7 +3689,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The migration was paused.
      **/
     MigrationPaused: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'MigrationPaused',
       {
@@ -3961,13 +3702,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The migration was cancelled.
      **/
-    MigrationCancelled: GenericPalletEvent<Rv, 'RcMigrator', 'MigrationCancelled', null>;
+    MigrationCancelled: GenericPalletEvent<'RcMigrator', 'MigrationCancelled', null>;
 
     /**
      * Some pure accounts were indexed for possibly receiving free `Any` proxies.
      **/
     PureAccountsIndexed: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'PureAccountsIndexed',
       {
@@ -3982,7 +3722,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The manager multisig dispatched something.
      **/
     ManagerMultisigDispatched: GenericPalletEvent<
-      Rv,
       'RcMigrator',
       'ManagerMultisigDispatched',
       { res: Result<[], DispatchError> }
@@ -3991,11 +3730,11 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The manager multisig received a vote.
      **/
-    ManagerMultisigVoted: GenericPalletEvent<Rv, 'RcMigrator', 'ManagerMultisigVoted', { votes: number }>;
+    ManagerMultisigVoted: GenericPalletEvent<'RcMigrator', 'ManagerMultisigVoted', { votes: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
 }