@dedot/chaintypes 0.194.0 → 0.196.0

package/astar/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, H256, Result, Bytes, FixedBytes, FixedU128, H160, U256 } from 'dedot/codecs';
 import type {
   FrameSystemDispatchEventInfo,
@@ -35,7 +35,7 @@ import type {
   PalletSafeModeExitReason,
 } from './types.js';
 
-export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
+export interface ChainEvents extends GenericChainEvents {
   /**
    * Pallet `System`'s events
    **/
@@ -43,18 +43,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 }
@@ -63,32 +57,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 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Utility`'s events
@@ -98,37 +92,37 @@ 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> }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Identity`'s events
@@ -137,23 +131,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A name was set or reset (which will remove all judgements).
      **/
-    IdentitySet: GenericPalletEvent<Rv, 'Identity', 'IdentitySet', { who: AccountId32 }>;
+    IdentitySet: GenericPalletEvent<'Identity', 'IdentitySet', { who: AccountId32 }>;
 
     /**
      * A name was cleared, and the given balance returned.
      **/
-    IdentityCleared: GenericPalletEvent<Rv, 'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
+    IdentityCleared: GenericPalletEvent<'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A name was removed and the given balance slashed.
      **/
-    IdentityKilled: GenericPalletEvent<Rv, 'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
+    IdentityKilled: GenericPalletEvent<'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A judgement was asked from a registrar.
      **/
     JudgementRequested: GenericPalletEvent<
-      Rv,
       'Identity',
       'JudgementRequested',
       { who: AccountId32; registrarIndex: number }
@@ -163,7 +156,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A judgement request was retracted.
      **/
     JudgementUnrequested: GenericPalletEvent<
-      Rv,
       'Identity',
       'JudgementUnrequested',
       { who: AccountId32; registrarIndex: number }
@@ -172,23 +164,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A judgement was given by a registrar.
      **/
-    JudgementGiven: GenericPalletEvent<
-      Rv,
-      'Identity',
-      'JudgementGiven',
-      { target: AccountId32; registrarIndex: number }
-    >;
+    JudgementGiven: GenericPalletEvent<'Identity', 'JudgementGiven', { target: AccountId32; registrarIndex: number }>;
 
     /**
      * A registrar was added.
      **/
-    RegistrarAdded: GenericPalletEvent<Rv, 'Identity', 'RegistrarAdded', { registrarIndex: number }>;
+    RegistrarAdded: GenericPalletEvent<'Identity', 'RegistrarAdded', { registrarIndex: number }>;
 
     /**
      * A sub-identity was added to an identity and the deposit paid.
      **/
     SubIdentityAdded: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityAdded',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -198,7 +184,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An account's sub-identities were set (in bulk).
      **/
     SubIdentitiesSet: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentitiesSet',
       { main: AccountId32; numberOfSubs: number; newDeposit: bigint }
@@ -207,18 +192,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A given sub-account's associated name was changed by its super-identity.
      **/
-    SubIdentityRenamed: GenericPalletEvent<
-      Rv,
-      'Identity',
-      'SubIdentityRenamed',
-      { sub: AccountId32; main: AccountId32 }
-    >;
+    SubIdentityRenamed: GenericPalletEvent<'Identity', 'SubIdentityRenamed', { sub: AccountId32; main: AccountId32 }>;
 
     /**
      * A sub-identity was removed from an identity and the deposit freed.
      **/
     SubIdentityRemoved: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityRemoved',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -229,7 +208,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * main identity account to the sub-identity account.
      **/
     SubIdentityRevoked: GenericPalletEvent<
-      Rv,
       'Identity',
       'SubIdentityRevoked',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -238,23 +216,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A username authority was added.
      **/
-    AuthorityAdded: GenericPalletEvent<Rv, 'Identity', 'AuthorityAdded', { authority: AccountId32 }>;
+    AuthorityAdded: GenericPalletEvent<'Identity', 'AuthorityAdded', { authority: AccountId32 }>;
 
     /**
      * A username authority was removed.
      **/
-    AuthorityRemoved: GenericPalletEvent<Rv, 'Identity', 'AuthorityRemoved', { authority: AccountId32 }>;
+    AuthorityRemoved: GenericPalletEvent<'Identity', 'AuthorityRemoved', { authority: AccountId32 }>;
 
     /**
      * A username was set for `who`.
      **/
-    UsernameSet: GenericPalletEvent<Rv, 'Identity', 'UsernameSet', { who: AccountId32; username: Bytes }>;
+    UsernameSet: GenericPalletEvent<'Identity', 'UsernameSet', { who: AccountId32; username: Bytes }>;
 
     /**
      * A username was queued, but `who` must accept it prior to `expiration`.
      **/
     UsernameQueued: GenericPalletEvent<
-      Rv,
       'Identity',
       'UsernameQueued',
       { who: AccountId32; username: Bytes; expiration: number }
@@ -263,19 +240,18 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A queued username passed its expiration without being claimed and was removed.
      **/
-    PreapprovalExpired: GenericPalletEvent<Rv, 'Identity', 'PreapprovalExpired', { whose: AccountId32 }>;
+    PreapprovalExpired: GenericPalletEvent<'Identity', 'PreapprovalExpired', { whose: AccountId32 }>;
 
     /**
      * A username was set as a primary and can be looked up from `who`.
      **/
-    PrimaryUsernameSet: GenericPalletEvent<Rv, 'Identity', 'PrimaryUsernameSet', { who: AccountId32; username: Bytes }>;
+    PrimaryUsernameSet: GenericPalletEvent<'Identity', 'PrimaryUsernameSet', { who: AccountId32; username: Bytes }>;
 
     /**
      * A dangling username (as in, a username corresponding to an account that has removed its
      * identity) has been removed.
      **/
     DanglingUsernameRemoved: GenericPalletEvent<
-      Rv,
       'Identity',
       'DanglingUsernameRemoved',
       { who: AccountId32; username: Bytes }
@@ -284,22 +260,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A username has been unbound.
      **/
-    UsernameUnbound: GenericPalletEvent<Rv, 'Identity', 'UsernameUnbound', { username: Bytes }>;
+    UsernameUnbound: GenericPalletEvent<'Identity', 'UsernameUnbound', { username: Bytes }>;
 
     /**
      * A username has been removed.
      **/
-    UsernameRemoved: GenericPalletEvent<Rv, 'Identity', 'UsernameRemoved', { username: Bytes }>;
+    UsernameRemoved: GenericPalletEvent<'Identity', 'UsernameRemoved', { username: Bytes }>;
 
     /**
      * A username has been killed.
      **/
-    UsernameKilled: GenericPalletEvent<Rv, 'Identity', 'UsernameKilled', { username: Bytes }>;
+    UsernameKilled: GenericPalletEvent<'Identity', 'UsernameKilled', { username: Bytes }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Multisig`'s events
@@ -309,7 +285,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> }
@@ -319,7 +294,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> }
@@ -329,7 +303,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A multisig operation has been executed.
      **/
     MultisigExecuted: GenericPalletEvent<
-      Rv,
       'Multisig',
       'MultisigExecuted',
       {
@@ -345,7 +318,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> }
@@ -354,7 +326,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Proxy`'s events
@@ -363,14 +335,13 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proxy was executed correctly, with the given.
      **/
-    ProxyExecuted: GenericPalletEvent<Rv, 'Proxy', 'ProxyExecuted', { result: Result<[], DispatchError> }>;
+    ProxyExecuted: GenericPalletEvent<'Proxy', 'ProxyExecuted', { result: Result<[], DispatchError> }>;
 
     /**
      * A pure account has been created by new proxy with given
      * disambiguation index and proxy type.
      **/
     PureCreated: GenericPalletEvent<
-      Rv,
       'Proxy',
       'PureCreated',
       { pure: AccountId32; who: AccountId32; proxyType: AstarRuntimeProxyType; disambiguationIndex: number }
@@ -379,13 +350,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: AstarRuntimeProxyType; delay: number }
@@ -395,7 +365,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A proxy was removed.
      **/
     ProxyRemoved: GenericPalletEvent<
-      Rv,
       'Proxy',
       'ProxyRemoved',
       { delegator: AccountId32; delegatee: AccountId32; proxyType: AstarRuntimeProxyType; delay: number }
@@ -404,7 +373,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Scheduler`'s events
@@ -413,18 +382,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> }
@@ -434,7 +402,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 }
@@ -444,7 +411,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 }
@@ -454,7 +420,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 }
@@ -464,7 +429,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 }
@@ -475,7 +439,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 }
@@ -485,7 +448,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 }
@@ -494,7 +456,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `ParachainSystem`'s events
@@ -503,13 +465,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The validation function has been scheduled to apply.
      **/
-    ValidationFunctionStored: GenericPalletEvent<Rv, 'ParachainSystem', 'ValidationFunctionStored', null>;
+    ValidationFunctionStored: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionStored', null>;
 
     /**
      * The validation function was applied as of the contained relay chain block number.
      **/
     ValidationFunctionApplied: GenericPalletEvent<
-      Rv,
       'ParachainSystem',
       'ValidationFunctionApplied',
       { relayChainBlockNum: number }
@@ -518,18 +479,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The relay-chain aborted the upgrade process.
      **/
-    ValidationFunctionDiscarded: GenericPalletEvent<Rv, 'ParachainSystem', 'ValidationFunctionDiscarded', null>;
+    ValidationFunctionDiscarded: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionDiscarded', null>;
 
     /**
      * Some downward messages have been received and will be processed.
      **/
-    DownwardMessagesReceived: GenericPalletEvent<Rv, 'ParachainSystem', 'DownwardMessagesReceived', { count: number }>;
+    DownwardMessagesReceived: GenericPalletEvent<'ParachainSystem', 'DownwardMessagesReceived', { count: number }>;
 
     /**
      * Downward messages were processed using the given weight.
      **/
     DownwardMessagesProcessed: GenericPalletEvent<
-      Rv,
       'ParachainSystem',
       'DownwardMessagesProcessed',
       { weightUsed: SpWeightsWeightV2Weight; dmqHead: H256 }
@@ -539,7 +499,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An upward message was sent to the relay chain.
      **/
     UpwardMessageSent: GenericPalletEvent<
-      Rv,
       'ParachainSystem',
       'UpwardMessageSent',
       { messageHash?: FixedBytes<32> | undefined }
@@ -548,7 +507,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TransactionPayment`'s events
@@ -559,7 +518,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 }
@@ -568,7 +526,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Balances`'s events
@@ -577,40 +535,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 }
@@ -619,82 +576,82 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some amount was deposited (e.g. for transaction fees).
      **/
-    Deposit: GenericPalletEvent<Rv, 'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
+    Deposit: GenericPalletEvent<'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdraw: GenericPalletEvent<Rv, 'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
+    Withdraw: GenericPalletEvent<'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was removed from the account (e.g. for misbehavior).
      **/
-    Slashed: GenericPalletEvent<Rv, 'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was minted into an account.
      **/
-    Minted: GenericPalletEvent<Rv, 'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
+    Minted: GenericPalletEvent<'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was burned from an account.
      **/
-    Burned: GenericPalletEvent<Rv, 'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
+    Burned: GenericPalletEvent<'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was suspended from an account (it can be restored later).
      **/
-    Suspended: GenericPalletEvent<Rv, 'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
+    Suspended: GenericPalletEvent<'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was restored into an account.
      **/
-    Restored: GenericPalletEvent<Rv, 'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
+    Restored: GenericPalletEvent<'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
 
     /**
      * An account was upgraded.
      **/
-    Upgraded: GenericPalletEvent<Rv, 'Balances', 'Upgraded', { who: AccountId32 }>;
+    Upgraded: GenericPalletEvent<'Balances', 'Upgraded', { who: AccountId32 }>;
 
     /**
      * Total issuance was increased by `amount`, creating a credit to be balanced.
      **/
-    Issued: GenericPalletEvent<Rv, 'Balances', 'Issued', { amount: bigint }>;
+    Issued: GenericPalletEvent<'Balances', 'Issued', { amount: bigint }>;
 
     /**
      * Total issuance was decreased by `amount`, creating a debt to be balanced.
      **/
-    Rescinded: GenericPalletEvent<Rv, 'Balances', 'Rescinded', { amount: bigint }>;
+    Rescinded: GenericPalletEvent<'Balances', 'Rescinded', { amount: bigint }>;
 
     /**
      * Some balance was locked.
      **/
-    Locked: GenericPalletEvent<Rv, 'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
+    Locked: GenericPalletEvent<'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was unlocked.
      **/
-    Unlocked: GenericPalletEvent<Rv, 'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
+    Unlocked: GenericPalletEvent<'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
+    Frozen: GenericPalletEvent<'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
+    Thawed: GenericPalletEvent<'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
 
     /**
      * The `TotalIssuance` was forcefully changed.
      **/
-    TotalIssuanceForced: GenericPalletEvent<Rv, 'Balances', 'TotalIssuanceForced', { old: bigint; new: bigint }>;
+    TotalIssuanceForced: GenericPalletEvent<'Balances', 'TotalIssuanceForced', { old: bigint; new: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Vesting`'s events
@@ -704,17 +661,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The amount vested has been updated. This could indicate a change in funds available.
      * The balance given is the amount which is left unvested (and thus locked).
      **/
-    VestingUpdated: GenericPalletEvent<Rv, 'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
+    VestingUpdated: GenericPalletEvent<'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
 
     /**
      * An \[account\] has become fully vested.
      **/
-    VestingCompleted: GenericPalletEvent<Rv, 'Vesting', 'VestingCompleted', { account: AccountId32 }>;
+    VestingCompleted: GenericPalletEvent<'Vesting', 'VestingCompleted', { account: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Inflation`'s events
@@ -723,13 +680,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Inflation parameters have been force changed. This will have effect on the next inflation recalculation.
      **/
-    InflationParametersForceChanged: GenericPalletEvent<Rv, 'Inflation', 'InflationParametersForceChanged', null>;
+    InflationParametersForceChanged: GenericPalletEvent<'Inflation', 'InflationParametersForceChanged', null>;
 
     /**
      * Inflation recalculation has been forced.
      **/
     ForcedInflationRecalculation: GenericPalletEvent<
-      Rv,
       'Inflation',
       'ForcedInflationRecalculation',
       { config: PalletInflationInflationConfiguration }
@@ -739,7 +695,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * New inflation configuration has been set.
      **/
     NewInflationConfiguration: GenericPalletEvent<
-      Rv,
       'Inflation',
       'NewInflationConfiguration',
       { config: PalletInflationInflationConfiguration }
@@ -748,7 +703,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `DappStaking`'s events
@@ -757,18 +712,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Maintenance mode has been either enabled or disabled.
      **/
-    MaintenanceMode: GenericPalletEvent<Rv, 'DappStaking', 'MaintenanceMode', { enabled: boolean }>;
+    MaintenanceMode: GenericPalletEvent<'DappStaking', 'MaintenanceMode', { enabled: boolean }>;
 
     /**
      * New era has started.
      **/
-    NewEra: GenericPalletEvent<Rv, 'DappStaking', 'NewEra', { era: number }>;
+    NewEra: GenericPalletEvent<'DappStaking', 'NewEra', { era: number }>;
 
     /**
      * New subperiod has started.
      **/
     NewSubperiod: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'NewSubperiod',
       { subperiod: PalletDappStakingSubperiod; number: number }
@@ -778,7 +732,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A smart contract has been registered for dApp staking
      **/
     DAppRegistered: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'DAppRegistered',
       { owner: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; dappId: number }
@@ -788,7 +741,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dApp reward destination has been updated.
      **/
     DAppRewardDestinationUpdated: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'DAppRewardDestinationUpdated',
       { smartContract: AstarPrimitivesDappStakingSmartContract; beneficiary?: AccountId32 | undefined }
@@ -798,7 +750,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dApp owner has been changed.
      **/
     DAppOwnerChanged: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'DAppOwnerChanged',
       { smartContract: AstarPrimitivesDappStakingSmartContract; newOwner: AccountId32 }
@@ -808,7 +759,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dApp has been unregistered
      **/
     DAppUnregistered: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'DAppUnregistered',
       { smartContract: AstarPrimitivesDappStakingSmartContract; era: number }
@@ -817,28 +767,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Account has locked some amount into dApp staking.
      **/
-    Locked: GenericPalletEvent<Rv, 'DappStaking', 'Locked', { account: AccountId32; amount: bigint }>;
+    Locked: GenericPalletEvent<'DappStaking', 'Locked', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has started the unlocking process for some amount.
      **/
-    Unlocking: GenericPalletEvent<Rv, 'DappStaking', 'Unlocking', { account: AccountId32; amount: bigint }>;
+    Unlocking: GenericPalletEvent<'DappStaking', 'Unlocking', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has claimed unlocked amount, removing the lock from it.
      **/
-    ClaimedUnlocked: GenericPalletEvent<Rv, 'DappStaking', 'ClaimedUnlocked', { account: AccountId32; amount: bigint }>;
+    ClaimedUnlocked: GenericPalletEvent<'DappStaking', 'ClaimedUnlocked', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has relocked all of the unlocking chunks.
      **/
-    Relock: GenericPalletEvent<Rv, 'DappStaking', 'Relock', { account: AccountId32; amount: bigint }>;
+    Relock: GenericPalletEvent<'DappStaking', 'Relock', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has staked some amount on a smart contract.
      **/
     Stake: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'Stake',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; amount: bigint }
@@ -848,7 +797,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Account has unstaked some amount from a smart contract.
      **/
     Unstake: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'Unstake',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; amount: bigint }
@@ -857,13 +805,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Account has claimed some stake rewards.
      **/
-    Reward: GenericPalletEvent<Rv, 'DappStaking', 'Reward', { account: AccountId32; era: number; amount: bigint }>;
+    Reward: GenericPalletEvent<'DappStaking', 'Reward', { account: AccountId32; era: number; amount: bigint }>;
 
     /**
      * Bonus reward has been paid out to a staker with an eligible bonus status.
      **/
     BonusReward: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'BonusReward',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; period: number; amount: bigint }
@@ -873,7 +820,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dApp reward has been paid out to a beneficiary.
      **/
     DAppReward: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'DAppReward',
       {
@@ -890,7 +836,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Account has unstaked funds from an unregistered smart contract
      **/
     UnstakeFromUnregistered: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'UnstakeFromUnregistered',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; amount: bigint }
@@ -900,7 +845,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some expired stake entries have been removed from storage.
      **/
     ExpiredEntriesRemoved: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'ExpiredEntriesRemoved',
       { account: AccountId32; count: number }
@@ -909,13 +853,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Privileged origin has forced a new era and possibly a subperiod to start from next block.
      **/
-    Force: GenericPalletEvent<Rv, 'DappStaking', 'Force', { forcingType: PalletDappStakingForcingType }>;
+    Force: GenericPalletEvent<'DappStaking', 'Force', { forcingType: PalletDappStakingForcingType }>;
 
     /**
      * Account has moved some stake from a source smart contract to a destination smart contract.
      **/
     StakeMoved: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'StakeMoved',
       {
@@ -930,7 +873,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Tier parameters, used to calculate tier configuration, have been updated, and will be applicable from next era.
      **/
     NewTierParameters: GenericPalletEvent<
-      Rv,
       'DappStaking',
       'NewTierParameters',
       { params: PalletDappStakingTierParameters }
@@ -939,7 +881,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Assets`'s events
@@ -948,18 +890,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some asset class was created.
      **/
-    Created: GenericPalletEvent<Rv, 'Assets', 'Created', { assetId: bigint; creator: AccountId32; owner: AccountId32 }>;
+    Created: GenericPalletEvent<'Assets', 'Created', { assetId: bigint; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * Some assets were issued.
      **/
-    Issued: GenericPalletEvent<Rv, 'Assets', 'Issued', { assetId: bigint; owner: AccountId32; amount: bigint }>;
+    Issued: GenericPalletEvent<'Assets', 'Issued', { assetId: bigint; owner: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were transferred.
      **/
     Transferred: GenericPalletEvent<
-      Rv,
       'Assets',
       'Transferred',
       { assetId: bigint; from: AccountId32; to: AccountId32; amount: bigint }
@@ -968,13 +909,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some assets were destroyed.
      **/
-    Burned: GenericPalletEvent<Rv, 'Assets', 'Burned', { assetId: bigint; owner: AccountId32; balance: bigint }>;
+    Burned: GenericPalletEvent<'Assets', 'Burned', { assetId: bigint; owner: AccountId32; balance: bigint }>;
 
     /**
      * The management team changed.
      **/
     TeamChanged: GenericPalletEvent<
-      Rv,
       'Assets',
       'TeamChanged',
       { assetId: bigint; issuer: AccountId32; admin: AccountId32; freezer: AccountId32 }
@@ -983,33 +923,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<Rv, 'Assets', 'OwnerChanged', { assetId: bigint; owner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<'Assets', 'OwnerChanged', { assetId: bigint; owner: AccountId32 }>;
 
     /**
      * Some account `who` was frozen.
      **/
-    Frozen: GenericPalletEvent<Rv, 'Assets', 'Frozen', { assetId: bigint; who: AccountId32 }>;
+    Frozen: GenericPalletEvent<'Assets', 'Frozen', { assetId: bigint; who: AccountId32 }>;
 
     /**
      * Some account `who` was thawed.
      **/
-    Thawed: GenericPalletEvent<Rv, 'Assets', 'Thawed', { assetId: bigint; who: AccountId32 }>;
+    Thawed: GenericPalletEvent<'Assets', 'Thawed', { assetId: bigint; who: AccountId32 }>;
 
     /**
      * Some asset `asset_id` was frozen.
      **/
-    AssetFrozen: GenericPalletEvent<Rv, 'Assets', 'AssetFrozen', { assetId: bigint }>;
+    AssetFrozen: GenericPalletEvent<'Assets', 'AssetFrozen', { assetId: bigint }>;
 
     /**
      * Some asset `asset_id` was thawed.
      **/
-    AssetThawed: GenericPalletEvent<Rv, 'Assets', 'AssetThawed', { assetId: bigint }>;
+    AssetThawed: GenericPalletEvent<'Assets', 'AssetThawed', { assetId: bigint }>;
 
     /**
      * Accounts were destroyed for given asset.
      **/
     AccountsDestroyed: GenericPalletEvent<
-      Rv,
       'Assets',
       'AccountsDestroyed',
       { assetId: bigint; accountsDestroyed: number; accountsRemaining: number }
@@ -1019,7 +958,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Approvals were destroyed for given asset.
      **/
     ApprovalsDestroyed: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovalsDestroyed',
       { assetId: bigint; approvalsDestroyed: number; approvalsRemaining: number }
@@ -1028,23 +966,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset class is in the process of being destroyed.
      **/
-    DestructionStarted: GenericPalletEvent<Rv, 'Assets', 'DestructionStarted', { assetId: bigint }>;
+    DestructionStarted: GenericPalletEvent<'Assets', 'DestructionStarted', { assetId: bigint }>;
 
     /**
      * An asset class was destroyed.
      **/
-    Destroyed: GenericPalletEvent<Rv, 'Assets', 'Destroyed', { assetId: bigint }>;
+    Destroyed: GenericPalletEvent<'Assets', 'Destroyed', { assetId: bigint }>;
 
     /**
      * Some asset class was force-created.
      **/
-    ForceCreated: GenericPalletEvent<Rv, 'Assets', 'ForceCreated', { assetId: bigint; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<'Assets', 'ForceCreated', { assetId: bigint; owner: AccountId32 }>;
 
     /**
      * New metadata has been set for an asset.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Assets',
       'MetadataSet',
       { assetId: bigint; name: Bytes; symbol: Bytes; decimals: number; isFrozen: boolean }
@@ -1053,13 +990,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Metadata has been cleared for an asset.
      **/
-    MetadataCleared: GenericPalletEvent<Rv, 'Assets', 'MetadataCleared', { assetId: bigint }>;
+    MetadataCleared: GenericPalletEvent<'Assets', 'MetadataCleared', { assetId: bigint }>;
 
     /**
      * (Additional) funds have been approved for transfer to a destination account.
      **/
     ApprovedTransfer: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovedTransfer',
       { assetId: bigint; source: AccountId32; delegate: AccountId32; amount: bigint }
@@ -1069,7 +1005,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An approval for account `delegate` was cancelled by `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
-      Rv,
       'Assets',
       'ApprovalCancelled',
       { assetId: bigint; owner: AccountId32; delegate: AccountId32 }
@@ -1080,7 +1015,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * the approved `delegate`.
      **/
     TransferredApproved: GenericPalletEvent<
-      Rv,
       'Assets',
       'TransferredApproved',
       { assetId: bigint; owner: AccountId32; delegate: AccountId32; destination: AccountId32; amount: bigint }
@@ -1089,13 +1023,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An asset has had its attributes changed by the `Force` origin.
      **/
-    AssetStatusChanged: GenericPalletEvent<Rv, 'Assets', 'AssetStatusChanged', { assetId: bigint }>;
+    AssetStatusChanged: GenericPalletEvent<'Assets', 'AssetStatusChanged', { assetId: bigint }>;
 
     /**
      * The min_balance of an asset has been updated by the asset owner.
      **/
     AssetMinBalanceChanged: GenericPalletEvent<
-      Rv,
       'Assets',
       'AssetMinBalanceChanged',
       { assetId: bigint; newMinBalance: bigint }
@@ -1104,27 +1037,27 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Some account `who` was created with a deposit from `depositor`.
      **/
-    Touched: GenericPalletEvent<Rv, 'Assets', 'Touched', { assetId: bigint; who: AccountId32; depositor: AccountId32 }>;
+    Touched: GenericPalletEvent<'Assets', 'Touched', { assetId: bigint; who: AccountId32; depositor: AccountId32 }>;
 
     /**
      * Some account `who` was blocked.
      **/
-    Blocked: GenericPalletEvent<Rv, 'Assets', 'Blocked', { assetId: bigint; who: AccountId32 }>;
+    Blocked: GenericPalletEvent<'Assets', 'Blocked', { assetId: bigint; who: AccountId32 }>;
 
     /**
      * Some assets were deposited (e.g. for transaction fees).
      **/
-    Deposited: GenericPalletEvent<Rv, 'Assets', 'Deposited', { assetId: bigint; who: AccountId32; amount: bigint }>;
+    Deposited: GenericPalletEvent<'Assets', 'Deposited', { assetId: bigint; who: AccountId32; amount: bigint }>;
 
     /**
      * Some assets were withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdrawn: GenericPalletEvent<Rv, 'Assets', 'Withdrawn', { assetId: bigint; who: AccountId32; amount: bigint }>;
+    Withdrawn: GenericPalletEvent<'Assets', 'Withdrawn', { assetId: bigint; who: AccountId32; amount: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `PriceAggregator`'s events
@@ -1133,12 +1066,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New average native currency value has been calculated and pushed into the moving average buffer.
      **/
-    AverageAggregatedValue: GenericPalletEvent<Rv, 'PriceAggregator', 'AverageAggregatedValue', { value: FixedU128 }>;
+    AverageAggregatedValue: GenericPalletEvent<'PriceAggregator', 'AverageAggregatedValue', { value: FixedU128 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Oracle`'s events
@@ -1148,7 +1081,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * New feed data is submitted.
      **/
     NewFeedData: GenericPalletEvent<
-      Rv,
       'Oracle',
       'NewFeedData',
       { sender: AccountId32; values: Array<[AstarPrimitivesOracleCurrencyId, FixedU128]> }
@@ -1157,7 +1089,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `OracleMembership`'s events
@@ -1166,37 +1098,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The given member was added; see the transaction for who.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'OracleMembership', 'MemberAdded', undefined>;
+    MemberAdded: GenericPalletEvent<'OracleMembership', 'MemberAdded', undefined>;
 
     /**
      * The given member was removed; see the transaction for who.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'OracleMembership', 'MemberRemoved', undefined>;
+    MemberRemoved: GenericPalletEvent<'OracleMembership', 'MemberRemoved', undefined>;
 
     /**
      * Two members were swapped; see the transaction for who.
      **/
-    MembersSwapped: GenericPalletEvent<Rv, 'OracleMembership', 'MembersSwapped', undefined>;
+    MembersSwapped: GenericPalletEvent<'OracleMembership', 'MembersSwapped', undefined>;
 
     /**
      * The membership was reset; see the transaction for who the new set is.
      **/
-    MembersReset: GenericPalletEvent<Rv, 'OracleMembership', 'MembersReset', undefined>;
+    MembersReset: GenericPalletEvent<'OracleMembership', 'MembersReset', undefined>;
 
     /**
      * One of the members' keys changed.
      **/
-    KeyChanged: GenericPalletEvent<Rv, 'OracleMembership', 'KeyChanged', undefined>;
+    KeyChanged: GenericPalletEvent<'OracleMembership', 'KeyChanged', undefined>;
 
     /**
      * Phantom member, never used.
      **/
-    Dummy: GenericPalletEvent<Rv, 'OracleMembership', 'Dummy', undefined>;
+    Dummy: GenericPalletEvent<'OracleMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CollatorSelection`'s events
@@ -1205,38 +1137,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New invulnerables candidates were set.
      **/
-    NewInvulnerables: GenericPalletEvent<Rv, 'CollatorSelection', 'NewInvulnerables', Array<AccountId32>>;
+    NewInvulnerables: GenericPalletEvent<'CollatorSelection', 'NewInvulnerables', Array<AccountId32>>;
 
     /**
      * The number of desired candidates was set.
      **/
-    NewDesiredCandidates: GenericPalletEvent<Rv, 'CollatorSelection', 'NewDesiredCandidates', number>;
+    NewDesiredCandidates: GenericPalletEvent<'CollatorSelection', 'NewDesiredCandidates', number>;
 
     /**
      * The candidacy bond was set.
      **/
-    NewCandidacyBond: GenericPalletEvent<Rv, 'CollatorSelection', 'NewCandidacyBond', bigint>;
+    NewCandidacyBond: GenericPalletEvent<'CollatorSelection', 'NewCandidacyBond', bigint>;
 
     /**
      * A new candidate joined.
      **/
-    CandidateAdded: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateAdded', [AccountId32, bigint]>;
+    CandidateAdded: GenericPalletEvent<'CollatorSelection', 'CandidateAdded', [AccountId32, bigint]>;
 
     /**
      * A candidate was removed.
      **/
-    CandidateRemoved: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateRemoved', AccountId32>;
+    CandidateRemoved: GenericPalletEvent<'CollatorSelection', 'CandidateRemoved', AccountId32>;
 
     /**
      * A candidate was slashed.
      **/
-    CandidateSlashed: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateSlashed', AccountId32>;
+    CandidateSlashed: GenericPalletEvent<'CollatorSelection', 'CandidateSlashed', AccountId32>;
 
     /**
      * A new candidacy application was submitted.
      **/
     CandidacyApplicationSubmitted: GenericPalletEvent<
-      Rv,
       'CollatorSelection',
       'CandidacyApplicationSubmitted',
       [AccountId32, bigint]
@@ -1246,7 +1177,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A candidacy application was approved.
      **/
     CandidacyApplicationApproved: GenericPalletEvent<
-      Rv,
       'CollatorSelection',
       'CandidacyApplicationApproved',
       [AccountId32, bigint]
@@ -1255,17 +1185,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A candidacy application was closed.
      **/
-    CandidacyApplicationClosed: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidacyApplicationClosed', AccountId32>;
+    CandidacyApplicationClosed: GenericPalletEvent<'CollatorSelection', 'CandidacyApplicationClosed', AccountId32>;
 
     /**
      * A candidate was kicked.
      **/
-    CandidateKicked: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateKicked', AccountId32>;
+    CandidateKicked: GenericPalletEvent<'CollatorSelection', 'CandidateKicked', AccountId32>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Session`'s events
@@ -1275,12 +1205,12 @@ 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 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `XcmpQueue`'s events
@@ -1289,12 +1219,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An HRMP message was sent to a sibling parachain.
      **/
-    XcmpMessageSent: GenericPalletEvent<Rv, 'XcmpQueue', 'XcmpMessageSent', { messageHash: FixedBytes<32> }>;
+    XcmpMessageSent: GenericPalletEvent<'XcmpQueue', 'XcmpMessageSent', { messageHash: FixedBytes<32> }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `PolkadotXcm`'s events
@@ -1303,13 +1233,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Execution of an XCM message was attempted.
      **/
-    Attempted: GenericPalletEvent<Rv, 'PolkadotXcm', 'Attempted', { outcome: StagingXcmV5TraitsOutcome }>;
+    Attempted: GenericPalletEvent<'PolkadotXcm', 'Attempted', { outcome: StagingXcmV5TraitsOutcome }>;
 
     /**
      * A XCM message was sent.
      **/
     Sent: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'Sent',
       {
@@ -1326,7 +1255,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * because the query timed out.
      **/
     UnexpectedResponse: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'UnexpectedResponse',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -1337,7 +1265,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * no registered notification call.
      **/
     ResponseReady: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'ResponseReady',
       { queryId: bigint; response: StagingXcmV5Response }
@@ -1348,7 +1275,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * been dispatched and executed successfully.
      **/
     Notified: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'Notified',
       { queryId: bigint; palletIndex: number; callIndex: number }
@@ -1360,7 +1286,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * originally budgeted by this runtime for the query result.
      **/
     NotifyOverweight: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'NotifyOverweight',
       {
@@ -1377,7 +1302,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * dispatching the notification call.
      **/
     NotifyDispatchError: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'NotifyDispatchError',
       { queryId: bigint; palletIndex: number; callIndex: number }
@@ -1389,7 +1313,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * is not `(origin, QueryId, Response)`.
      **/
     NotifyDecodeFailed: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'NotifyDecodeFailed',
       { queryId: bigint; palletIndex: number; callIndex: number }
@@ -1401,7 +1324,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * be received and acted upon.
      **/
     InvalidResponder: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'InvalidResponder',
       { origin: StagingXcmV5Location; queryId: bigint; expectedLocation?: StagingXcmV5Location | undefined }
@@ -1417,7 +1339,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * needed.
      **/
     InvalidResponderVersion: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'InvalidResponderVersion',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -1426,13 +1347,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Received query response has been read and removed.
      **/
-    ResponseTaken: GenericPalletEvent<Rv, 'PolkadotXcm', 'ResponseTaken', { queryId: bigint }>;
+    ResponseTaken: GenericPalletEvent<'PolkadotXcm', 'ResponseTaken', { queryId: bigint }>;
 
     /**
      * Some assets have been placed in an asset trap.
      **/
     AssetsTrapped: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'AssetsTrapped',
       { hash: H256; origin: StagingXcmV5Location; assets: XcmVersionedAssets }
@@ -1444,7 +1364,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The cost of sending it (borne by the chain) is included.
      **/
     VersionChangeNotified: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'VersionChangeNotified',
       { destination: StagingXcmV5Location; result: number; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -1455,7 +1374,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * automatic notification or a manual intervention.
      **/
     SupportedVersionChanged: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'SupportedVersionChanged',
       { location: StagingXcmV5Location; version: number }
@@ -1466,7 +1384,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * sending the notification to it.
      **/
     NotifyTargetSendFail: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'NotifyTargetSendFail',
       { location: StagingXcmV5Location; queryId: bigint; error: XcmV5TraitsError }
@@ -1477,7 +1394,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * migrating the location to our new XCM format.
      **/
     NotifyTargetMigrationFail: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'NotifyTargetMigrationFail',
       { location: XcmVersionedLocation; queryId: bigint }
@@ -1493,7 +1409,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * needed.
      **/
     InvalidQuerierVersion: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'InvalidQuerierVersion',
       { origin: StagingXcmV5Location; queryId: bigint }
@@ -1505,7 +1420,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * be received and acted upon.
      **/
     InvalidQuerier: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'InvalidQuerier',
       {
@@ -1521,7 +1435,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,
       'PolkadotXcm',
       'VersionNotifyStarted',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -1531,7 +1444,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,
       'PolkadotXcm',
       'VersionNotifyRequested',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -1542,7 +1454,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * notifications.
      **/
     VersionNotifyUnrequested: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'VersionNotifyUnrequested',
       { destination: StagingXcmV5Location; cost: StagingXcmV5AssetAssets; messageId: FixedBytes<32> }
@@ -1552,7 +1463,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,
       'PolkadotXcm',
       'FeesPaid',
       { paying: StagingXcmV5Location; fees: StagingXcmV5AssetAssets }
@@ -1562,7 +1472,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some assets have been claimed from an asset trap
      **/
     AssetsClaimed: GenericPalletEvent<
-      Rv,
       'PolkadotXcm',
       'AssetsClaimed',
       { hash: H256; origin: StagingXcmV5Location; assets: XcmVersionedAssets }
@@ -1571,12 +1480,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A XCM version migration finished.
      **/
-    VersionMigrationFinished: GenericPalletEvent<Rv, 'PolkadotXcm', 'VersionMigrationFinished', { version: number }>;
+    VersionMigrationFinished: GenericPalletEvent<'PolkadotXcm', 'VersionMigrationFinished', { version: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CumulusXcm`'s events
@@ -1586,29 +1495,24 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Downward message is invalid XCM.
      * \[ id \]
      **/
-    InvalidFormat: GenericPalletEvent<Rv, 'CumulusXcm', 'InvalidFormat', FixedBytes<32>>;
+    InvalidFormat: GenericPalletEvent<'CumulusXcm', 'InvalidFormat', FixedBytes<32>>;
 
     /**
      * Downward message is unsupported version of XCM.
      * \[ id \]
      **/
-    UnsupportedVersion: GenericPalletEvent<Rv, 'CumulusXcm', 'UnsupportedVersion', FixedBytes<32>>;
+    UnsupportedVersion: GenericPalletEvent<'CumulusXcm', 'UnsupportedVersion', FixedBytes<32>>;
 
     /**
      * Downward message executed with the given outcome.
      * \[ id, outcome \]
      **/
-    ExecutedDownward: GenericPalletEvent<
-      Rv,
-      'CumulusXcm',
-      'ExecutedDownward',
-      [FixedBytes<32>, StagingXcmV5TraitsOutcome]
-    >;
+    ExecutedDownward: GenericPalletEvent<'CumulusXcm', 'ExecutedDownward', [FixedBytes<32>, StagingXcmV5TraitsOutcome]>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `XcAssetConfig`'s events
@@ -1618,7 +1522,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Registed mapping between asset type and asset Id.
      **/
     AssetRegistered: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'AssetRegistered',
       { assetLocation: XcmVersionedLocation; assetId: bigint }
@@ -1628,7 +1531,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Changed the amount of units we are charging per execution second for an asset
      **/
     UnitsPerSecondChanged: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'UnitsPerSecondChanged',
       { assetLocation: XcmVersionedLocation; unitsPerSecond: bigint }
@@ -1638,7 +1540,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Changed the asset type mapping for a given asset id
      **/
     AssetLocationChanged: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'AssetLocationChanged',
       { previousAssetLocation: XcmVersionedLocation; assetId: bigint; newAssetLocation: XcmVersionedLocation }
@@ -1648,7 +1549,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Supported asset type for fee payment removed.
      **/
     SupportedAssetRemoved: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'SupportedAssetRemoved',
       { assetLocation: XcmVersionedLocation }
@@ -1658,7 +1558,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Removed all information related to an asset Id
      **/
     AssetRemoved: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'AssetRemoved',
       { assetLocation: XcmVersionedLocation; assetId: bigint }
@@ -1668,7 +1567,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Notify when the migration step is updated.
      **/
     MigrationStepUpdated: GenericPalletEvent<
-      Rv,
       'XcAssetConfig',
       'MigrationStepUpdated',
       { newMigrationStep: PalletXcAssetConfigMigrationStep }
@@ -1677,7 +1575,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `XTokens`'s events
@@ -1687,7 +1585,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Transferred `Asset` with fee.
      **/
     TransferredAssets: GenericPalletEvent<
-      Rv,
       'XTokens',
       'TransferredAssets',
       { sender: AccountId32; assets: StagingXcmV5AssetAssets; fee: StagingXcmV5Asset; dest: StagingXcmV5Location }
@@ -1696,7 +1593,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MessageQueue`'s events
@@ -1706,7 +1603,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',
       {
@@ -1734,7 +1630,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message is processed.
      **/
     Processed: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'Processed',
       {
@@ -1769,7 +1664,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Message placed in overweight queue.
      **/
     OverweightEnqueued: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'OverweightEnqueued',
       {
@@ -1799,7 +1693,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This page was reaped.
      **/
     PageReaped: GenericPalletEvent<
-      Rv,
       'MessageQueue',
       'PageReaped',
       {
@@ -1818,7 +1711,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `EVM`'s events
@@ -1827,32 +1720,32 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Ethereum events from contracts.
      **/
-    Log: GenericPalletEvent<Rv, 'EVM', 'Log', { log: EthereumLog }>;
+    Log: GenericPalletEvent<'EVM', 'Log', { log: EthereumLog }>;
 
     /**
      * A contract has been created at given address.
      **/
-    Created: GenericPalletEvent<Rv, 'EVM', 'Created', { address: H160 }>;
+    Created: GenericPalletEvent<'EVM', 'Created', { address: H160 }>;
 
     /**
      * A contract was attempted to be created, but the execution failed.
      **/
-    CreatedFailed: GenericPalletEvent<Rv, 'EVM', 'CreatedFailed', { address: H160 }>;
+    CreatedFailed: GenericPalletEvent<'EVM', 'CreatedFailed', { address: H160 }>;
 
     /**
      * A contract has been executed successfully with states applied.
      **/
-    Executed: GenericPalletEvent<Rv, 'EVM', 'Executed', { address: H160 }>;
+    Executed: GenericPalletEvent<'EVM', 'Executed', { address: H160 }>;
 
     /**
      * A contract has been executed with errors. States are reverted with only gas fees applied.
      **/
-    ExecutedFailed: GenericPalletEvent<Rv, 'EVM', 'ExecutedFailed', { address: H160 }>;
+    ExecutedFailed: GenericPalletEvent<'EVM', 'ExecutedFailed', { address: H160 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Ethereum`'s events
@@ -1862,7 +1755,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * An ethereum transaction was successfully executed.
      **/
     Executed: GenericPalletEvent<
-      Rv,
       'Ethereum',
       'Executed',
       { from: H160; to: H160; transactionHash: H256; exitReason: EvmCoreErrorExitReason; extraData: Bytes }
@@ -1871,7 +1763,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `DynamicEvmBaseFee`'s events
@@ -1880,12 +1772,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New `base fee per gas` value has been force-set.
      **/
-    NewBaseFeePerGas: GenericPalletEvent<Rv, 'DynamicEvmBaseFee', 'NewBaseFeePerGas', { fee: U256 }>;
+    NewBaseFeePerGas: GenericPalletEvent<'DynamicEvmBaseFee', 'NewBaseFeePerGas', { fee: U256 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Contracts`'s events
@@ -1894,7 +1786,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Contract deployed by address at the specified address.
      **/
-    Instantiated: GenericPalletEvent<Rv, 'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
+    Instantiated: GenericPalletEvent<'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
 
     /**
      * Contract has been removed.
@@ -1905,7 +1797,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `seal_terminate`.
      **/
     Terminated: GenericPalletEvent<
-      Rv,
       'Contracts',
       'Terminated',
       {
@@ -1925,7 +1816,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Code with the specified hash has been stored.
      **/
     CodeStored: GenericPalletEvent<
-      Rv,
       'Contracts',
       'CodeStored',
       { codeHash: H256; depositHeld: bigint; uploader: AccountId32 }
@@ -1935,7 +1825,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A custom event emitted by the contract.
      **/
     ContractEmitted: GenericPalletEvent<
-      Rv,
       'Contracts',
       'ContractEmitted',
       {
@@ -1956,7 +1845,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A code with the specified hash was removed.
      **/
     CodeRemoved: GenericPalletEvent<
-      Rv,
       'Contracts',
       'CodeRemoved',
       { codeHash: H256; depositReleased: bigint; remover: AccountId32 }
@@ -1966,7 +1854,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A contract's code was updated.
      **/
     ContractCodeUpdated: GenericPalletEvent<
-      Rv,
       'Contracts',
       'ContractCodeUpdated',
       {
@@ -1997,7 +1884,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * rolled back.
      **/
     Called: GenericPalletEvent<
-      Rv,
       'Contracts',
       'Called',
       {
@@ -2023,7 +1909,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * rolled back.
      **/
     DelegateCalled: GenericPalletEvent<
-      Rv,
       'Contracts',
       'DelegateCalled',
       {
@@ -2044,7 +1929,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some funds have been transferred and held as storage deposit.
      **/
     StorageDepositTransferredAndHeld: GenericPalletEvent<
-      Rv,
       'Contracts',
       'StorageDepositTransferredAndHeld',
       { from: AccountId32; to: AccountId32; amount: bigint }
@@ -2054,7 +1938,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some storage deposit funds have been transferred and released.
      **/
     StorageDepositTransferredAndReleased: GenericPalletEvent<
-      Rv,
       'Contracts',
       'StorageDepositTransferredAndReleased',
       { from: AccountId32; to: AccountId32; amount: bigint }
@@ -2063,7 +1946,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Preimage`'s events
@@ -2072,22 +1955,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 `Sudo`'s events
@@ -2097,7 +1980,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A sudo call just took place.
      **/
     Sudid: GenericPalletEvent<
-      Rv,
       'Sudo',
       'Sudid',
       {
@@ -2112,7 +1994,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The sudo key has been updated.
      **/
     KeyChanged: GenericPalletEvent<
-      Rv,
       'Sudo',
       'KeyChanged',
       {
@@ -2131,13 +2012,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The key was permanently removed.
      **/
-    KeyRemoved: GenericPalletEvent<Rv, 'Sudo', 'KeyRemoved', null>;
+    KeyRemoved: GenericPalletEvent<'Sudo', 'KeyRemoved', null>;
 
     /**
      * A [sudo_as](Pallet::sudo_as) call just took place.
      **/
     SudoAsDone: GenericPalletEvent<
-      Rv,
       'Sudo',
       'SudoAsDone',
       {
@@ -2151,7 +2031,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CouncilMembership`'s events
@@ -2160,37 +2040,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The given member was added; see the transaction for who.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'CouncilMembership', 'MemberAdded', undefined>;
+    MemberAdded: GenericPalletEvent<'CouncilMembership', 'MemberAdded', undefined>;
 
     /**
      * The given member was removed; see the transaction for who.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'CouncilMembership', 'MemberRemoved', undefined>;
+    MemberRemoved: GenericPalletEvent<'CouncilMembership', 'MemberRemoved', undefined>;
 
     /**
      * Two members were swapped; see the transaction for who.
      **/
-    MembersSwapped: GenericPalletEvent<Rv, 'CouncilMembership', 'MembersSwapped', undefined>;
+    MembersSwapped: GenericPalletEvent<'CouncilMembership', 'MembersSwapped', undefined>;
 
     /**
      * The membership was reset; see the transaction for who the new set is.
      **/
-    MembersReset: GenericPalletEvent<Rv, 'CouncilMembership', 'MembersReset', undefined>;
+    MembersReset: GenericPalletEvent<'CouncilMembership', 'MembersReset', undefined>;
 
     /**
      * One of the members' keys changed.
      **/
-    KeyChanged: GenericPalletEvent<Rv, 'CouncilMembership', 'KeyChanged', undefined>;
+    KeyChanged: GenericPalletEvent<'CouncilMembership', 'KeyChanged', undefined>;
 
     /**
      * Phantom member, never used.
      **/
-    Dummy: GenericPalletEvent<Rv, 'CouncilMembership', 'Dummy', undefined>;
+    Dummy: GenericPalletEvent<'CouncilMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TechnicalCommitteeMembership`'s events
@@ -2199,37 +2079,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The given member was added; see the transaction for who.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'MemberAdded', undefined>;
+    MemberAdded: GenericPalletEvent<'TechnicalCommitteeMembership', 'MemberAdded', undefined>;
 
     /**
      * The given member was removed; see the transaction for who.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'MemberRemoved', undefined>;
+    MemberRemoved: GenericPalletEvent<'TechnicalCommitteeMembership', 'MemberRemoved', undefined>;
 
     /**
      * Two members were swapped; see the transaction for who.
      **/
-    MembersSwapped: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'MembersSwapped', undefined>;
+    MembersSwapped: GenericPalletEvent<'TechnicalCommitteeMembership', 'MembersSwapped', undefined>;
 
     /**
      * The membership was reset; see the transaction for who the new set is.
      **/
-    MembersReset: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'MembersReset', undefined>;
+    MembersReset: GenericPalletEvent<'TechnicalCommitteeMembership', 'MembersReset', undefined>;
 
     /**
      * One of the members' keys changed.
      **/
-    KeyChanged: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'KeyChanged', undefined>;
+    KeyChanged: GenericPalletEvent<'TechnicalCommitteeMembership', 'KeyChanged', undefined>;
 
     /**
      * Phantom member, never used.
      **/
-    Dummy: GenericPalletEvent<Rv, 'TechnicalCommitteeMembership', 'Dummy', undefined>;
+    Dummy: GenericPalletEvent<'TechnicalCommitteeMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CommunityCouncilMembership`'s events
@@ -2238,37 +2118,37 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The given member was added; see the transaction for who.
      **/
-    MemberAdded: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'MemberAdded', undefined>;
+    MemberAdded: GenericPalletEvent<'CommunityCouncilMembership', 'MemberAdded', undefined>;
 
     /**
      * The given member was removed; see the transaction for who.
      **/
-    MemberRemoved: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'MemberRemoved', undefined>;
+    MemberRemoved: GenericPalletEvent<'CommunityCouncilMembership', 'MemberRemoved', undefined>;
 
     /**
      * Two members were swapped; see the transaction for who.
      **/
-    MembersSwapped: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'MembersSwapped', undefined>;
+    MembersSwapped: GenericPalletEvent<'CommunityCouncilMembership', 'MembersSwapped', undefined>;
 
     /**
      * The membership was reset; see the transaction for who the new set is.
      **/
-    MembersReset: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'MembersReset', undefined>;
+    MembersReset: GenericPalletEvent<'CommunityCouncilMembership', 'MembersReset', undefined>;
 
     /**
      * One of the members' keys changed.
      **/
-    KeyChanged: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'KeyChanged', undefined>;
+    KeyChanged: GenericPalletEvent<'CommunityCouncilMembership', 'KeyChanged', undefined>;
 
     /**
      * Phantom member, never used.
      **/
-    Dummy: GenericPalletEvent<Rv, 'CommunityCouncilMembership', 'Dummy', undefined>;
+    Dummy: GenericPalletEvent<'CommunityCouncilMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Council`'s events
@@ -2279,7 +2159,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'Council',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -2290,7 +2169,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'Council',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -2299,23 +2177,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'Council', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'Council', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'Council', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'Council', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
-    Executed: GenericPalletEvent<Rv, 'Council', 'Executed', { proposalHash: H256; result: Result<[], DispatchError> }>;
+    Executed: GenericPalletEvent<'Council', 'Executed', { proposalHash: H256; result: Result<[], DispatchError> }>;
 
     /**
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'Council',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -2324,28 +2201,22 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'Council', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'Council', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'Council', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'Council', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
-    ProposalCostBurned: GenericPalletEvent<
-      Rv,
-      'Council',
-      'ProposalCostBurned',
-      { proposalHash: H256; who: AccountId32 }
-    >;
+    ProposalCostBurned: GenericPalletEvent<'Council', 'ProposalCostBurned', { proposalHash: H256; who: AccountId32 }>;
 
     /**
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'Council',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -2354,7 +2225,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TechnicalCommittee`'s events
@@ -2365,7 +2236,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -2376,7 +2246,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -2385,18 +2254,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'TechnicalCommittee', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'TechnicalCommittee', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
     Executed: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'Executed',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -2406,7 +2274,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -2415,18 +2282,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'TechnicalCommittee', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'TechnicalCommittee', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'TechnicalCommittee', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
     ProposalCostBurned: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'ProposalCostBurned',
       { proposalHash: H256; who: AccountId32 }
@@ -2436,7 +2302,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'TechnicalCommittee',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -2445,7 +2310,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CommunityCouncil`'s events
@@ -2456,7 +2321,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * `MemberCount`).
      **/
     Proposed: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'Proposed',
       { account: AccountId32; proposalIndex: number; proposalHash: H256; threshold: number }
@@ -2467,7 +2331,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * a tally (yes votes and no votes given respectively as `MemberCount`).
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'Voted',
       { account: AccountId32; proposalHash: H256; voted: boolean; yes: number; no: number }
@@ -2476,18 +2339,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion was approved by the required threshold.
      **/
-    Approved: GenericPalletEvent<Rv, 'CommunityCouncil', 'Approved', { proposalHash: H256 }>;
+    Approved: GenericPalletEvent<'CommunityCouncil', 'Approved', { proposalHash: H256 }>;
 
     /**
      * A motion was not approved by the required threshold.
      **/
-    Disapproved: GenericPalletEvent<Rv, 'CommunityCouncil', 'Disapproved', { proposalHash: H256 }>;
+    Disapproved: GenericPalletEvent<'CommunityCouncil', 'Disapproved', { proposalHash: H256 }>;
 
     /**
      * A motion was executed; result will be `Ok` if it returned without error.
      **/
     Executed: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'Executed',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -2497,7 +2359,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A single member did some action; result will be `Ok` if it returned without error.
      **/
     MemberExecuted: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'MemberExecuted',
       { proposalHash: H256; result: Result<[], DispatchError> }
@@ -2506,18 +2367,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was closed because its threshold was reached or after its duration was up.
      **/
-    Closed: GenericPalletEvent<Rv, 'CommunityCouncil', 'Closed', { proposalHash: H256; yes: number; no: number }>;
+    Closed: GenericPalletEvent<'CommunityCouncil', 'Closed', { proposalHash: H256; yes: number; no: number }>;
 
     /**
      * A proposal was killed.
      **/
-    Killed: GenericPalletEvent<Rv, 'CommunityCouncil', 'Killed', { proposalHash: H256 }>;
+    Killed: GenericPalletEvent<'CommunityCouncil', 'Killed', { proposalHash: H256 }>;
 
     /**
      * Some cost for storing a proposal was burned.
      **/
     ProposalCostBurned: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'ProposalCostBurned',
       { proposalHash: H256; who: AccountId32 }
@@ -2527,7 +2387,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Some cost for storing a proposal was released.
      **/
     ProposalCostReleased: GenericPalletEvent<
-      Rv,
       'CommunityCouncil',
       'ProposalCostReleased',
       { proposalHash: H256; who: AccountId32 }
@@ -2536,7 +2395,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Democracy`'s events
@@ -2545,68 +2404,62 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A motion has been proposed by a public account.
      **/
-    Proposed: GenericPalletEvent<Rv, 'Democracy', 'Proposed', { proposalIndex: number; deposit: bigint }>;
+    Proposed: GenericPalletEvent<'Democracy', 'Proposed', { proposalIndex: number; deposit: bigint }>;
 
     /**
      * A public proposal has been tabled for referendum vote.
      **/
-    Tabled: GenericPalletEvent<Rv, 'Democracy', 'Tabled', { proposalIndex: number; deposit: bigint }>;
+    Tabled: GenericPalletEvent<'Democracy', 'Tabled', { proposalIndex: number; deposit: bigint }>;
 
     /**
      * An external proposal has been tabled.
      **/
-    ExternalTabled: GenericPalletEvent<Rv, 'Democracy', 'ExternalTabled', null>;
+    ExternalTabled: GenericPalletEvent<'Democracy', 'ExternalTabled', null>;
 
     /**
      * A referendum has begun.
      **/
-    Started: GenericPalletEvent<
-      Rv,
-      'Democracy',
-      'Started',
-      { refIndex: number; threshold: PalletDemocracyVoteThreshold }
-    >;
+    Started: GenericPalletEvent<'Democracy', 'Started', { refIndex: number; threshold: PalletDemocracyVoteThreshold }>;
 
     /**
      * A proposal has been approved by referendum.
      **/
-    Passed: GenericPalletEvent<Rv, 'Democracy', 'Passed', { refIndex: number }>;
+    Passed: GenericPalletEvent<'Democracy', 'Passed', { refIndex: number }>;
 
     /**
      * A proposal has been rejected by referendum.
      **/
-    NotPassed: GenericPalletEvent<Rv, 'Democracy', 'NotPassed', { refIndex: number }>;
+    NotPassed: GenericPalletEvent<'Democracy', 'NotPassed', { refIndex: number }>;
 
     /**
      * A referendum has been cancelled.
      **/
-    Cancelled: GenericPalletEvent<Rv, 'Democracy', 'Cancelled', { refIndex: number }>;
+    Cancelled: GenericPalletEvent<'Democracy', 'Cancelled', { refIndex: number }>;
 
     /**
      * An account has delegated their vote to another account.
      **/
-    Delegated: GenericPalletEvent<Rv, 'Democracy', 'Delegated', { who: AccountId32; target: AccountId32 }>;
+    Delegated: GenericPalletEvent<'Democracy', 'Delegated', { who: AccountId32; target: AccountId32 }>;
 
     /**
      * An account has cancelled a previous delegation operation.
      **/
-    Undelegated: GenericPalletEvent<Rv, 'Democracy', 'Undelegated', { account: AccountId32 }>;
+    Undelegated: GenericPalletEvent<'Democracy', 'Undelegated', { account: AccountId32 }>;
 
     /**
      * An external proposal has been vetoed.
      **/
-    Vetoed: GenericPalletEvent<Rv, 'Democracy', 'Vetoed', { who: AccountId32; proposalHash: H256; until: number }>;
+    Vetoed: GenericPalletEvent<'Democracy', 'Vetoed', { who: AccountId32; proposalHash: H256; until: number }>;
 
     /**
      * A proposal_hash has been blacklisted permanently.
      **/
-    Blacklisted: GenericPalletEvent<Rv, 'Democracy', 'Blacklisted', { proposalHash: H256 }>;
+    Blacklisted: GenericPalletEvent<'Democracy', 'Blacklisted', { proposalHash: H256 }>;
 
     /**
      * An account has voted in a referendum
      **/
     Voted: GenericPalletEvent<
-      Rv,
       'Democracy',
       'Voted',
       { voter: AccountId32; refIndex: number; vote: PalletDemocracyVoteAccountVote }
@@ -2615,18 +2468,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * An account has seconded a proposal
      **/
-    Seconded: GenericPalletEvent<Rv, 'Democracy', 'Seconded', { seconder: AccountId32; propIndex: number }>;
+    Seconded: GenericPalletEvent<'Democracy', 'Seconded', { seconder: AccountId32; propIndex: number }>;
 
     /**
      * A proposal got canceled.
      **/
-    ProposalCanceled: GenericPalletEvent<Rv, 'Democracy', 'ProposalCanceled', { propIndex: number }>;
+    ProposalCanceled: GenericPalletEvent<'Democracy', 'ProposalCanceled', { propIndex: number }>;
 
     /**
      * Metadata for a proposal or a referendum has been set.
      **/
     MetadataSet: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataSet',
       {
@@ -2646,7 +2498,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata for a proposal or a referendum has been cleared.
      **/
     MetadataCleared: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataCleared',
       {
@@ -2666,7 +2517,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Metadata has been transferred to new owner.
      **/
     MetadataTransferred: GenericPalletEvent<
-      Rv,
       'Democracy',
       'MetadataTransferred',
       {
@@ -2690,7 +2540,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `Treasury`'s events
@@ -2699,58 +2549,48 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New proposal.
      **/
-    Proposed: GenericPalletEvent<Rv, 'Treasury', 'Proposed', { proposalIndex: number }>;
+    Proposed: GenericPalletEvent<'Treasury', 'Proposed', { proposalIndex: number }>;
 
     /**
      * 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 }>;
 
     /**
      * A proposal was rejected; funds were slashed.
      **/
-    Rejected: GenericPalletEvent<Rv, 'Treasury', 'Rejected', { proposalIndex: number; slashed: bigint }>;
+    Rejected: GenericPalletEvent<'Treasury', 'Rejected', { proposalIndex: number; slashed: bigint }>;
 
     /**
      * 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.
      * 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 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CommunityTreasury`'s events
@@ -2759,18 +2599,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * New proposal.
      **/
-    Proposed: GenericPalletEvent<Rv, 'CommunityTreasury', 'Proposed', { proposalIndex: number }>;
+    Proposed: GenericPalletEvent<'CommunityTreasury', 'Proposed', { proposalIndex: number }>;
 
     /**
      * We have ended a spend period and will now allocate funds.
      **/
-    Spending: GenericPalletEvent<Rv, 'CommunityTreasury', 'Spending', { budgetRemaining: bigint }>;
+    Spending: GenericPalletEvent<'CommunityTreasury', 'Spending', { budgetRemaining: bigint }>;
 
     /**
      * Some funds have been allocated.
      **/
     Awarded: GenericPalletEvent<
-      Rv,
       'CommunityTreasury',
       'Awarded',
       { proposalIndex: number; award: bigint; account: AccountId32 }
@@ -2779,29 +2618,28 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * A proposal was rejected; funds were slashed.
      **/
-    Rejected: GenericPalletEvent<Rv, 'CommunityTreasury', 'Rejected', { proposalIndex: number; slashed: bigint }>;
+    Rejected: GenericPalletEvent<'CommunityTreasury', 'Rejected', { proposalIndex: number; slashed: bigint }>;
 
     /**
      * Some of our funds have been burnt.
      **/
-    Burnt: GenericPalletEvent<Rv, 'CommunityTreasury', 'Burnt', { burntFunds: bigint }>;
+    Burnt: GenericPalletEvent<'CommunityTreasury', 'Burnt', { burntFunds: bigint }>;
 
     /**
      * Spending has finished; this is the amount that rolls over until next spend.
      **/
-    Rollover: GenericPalletEvent<Rv, 'CommunityTreasury', 'Rollover', { rolloverBalance: bigint }>;
+    Rollover: GenericPalletEvent<'CommunityTreasury', 'Rollover', { rolloverBalance: bigint }>;
 
     /**
      * Some funds have been deposited.
      **/
-    Deposit: GenericPalletEvent<Rv, 'CommunityTreasury', 'Deposit', { value: bigint }>;
+    Deposit: GenericPalletEvent<'CommunityTreasury', 'Deposit', { value: bigint }>;
 
     /**
      * A new spend proposal has been approved.
      * The inactive funds of the pallet have been updated.
      **/
     UpdatedInactive: GenericPalletEvent<
-      Rv,
       'CommunityTreasury',
       'UpdatedInactive',
       { reactivated: bigint; deactivated: bigint }
@@ -2810,7 +2648,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `CollectiveProxy`'s events
@@ -2820,7 +2658,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Community proxy call executed successfully.
      **/
     CollectiveProxyExecuted: GenericPalletEvent<
-      Rv,
       'CollectiveProxy',
       'CollectiveProxyExecuted',
       { result: Result<[], DispatchError> }
@@ -2829,7 +2666,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `SafeMode`'s events
@@ -2838,51 +2675,51 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * The safe-mode was entered until inclusively this block.
      **/
-    Entered: GenericPalletEvent<Rv, 'SafeMode', 'Entered', { until: number }>;
+    Entered: GenericPalletEvent<'SafeMode', 'Entered', { until: number }>;
 
     /**
      * The safe-mode was extended until inclusively this block.
      **/
-    Extended: GenericPalletEvent<Rv, 'SafeMode', 'Extended', { until: number }>;
+    Extended: GenericPalletEvent<'SafeMode', 'Extended', { until: number }>;
 
     /**
      * Exited the safe-mode for a specific reason.
      **/
-    Exited: GenericPalletEvent<Rv, 'SafeMode', 'Exited', { reason: PalletSafeModeExitReason }>;
+    Exited: GenericPalletEvent<'SafeMode', 'Exited', { reason: PalletSafeModeExitReason }>;
 
     /**
      * An account reserved funds for either entering or extending the safe-mode.
      **/
-    DepositPlaced: GenericPalletEvent<Rv, 'SafeMode', 'DepositPlaced', { account: AccountId32; amount: bigint }>;
+    DepositPlaced: GenericPalletEvent<'SafeMode', 'DepositPlaced', { account: AccountId32; amount: bigint }>;
 
     /**
      * An account had a reserve released that was reserved.
      **/
-    DepositReleased: GenericPalletEvent<Rv, 'SafeMode', 'DepositReleased', { account: AccountId32; amount: bigint }>;
+    DepositReleased: GenericPalletEvent<'SafeMode', 'DepositReleased', { account: AccountId32; amount: bigint }>;
 
     /**
      * An account had reserve slashed that was reserved.
      **/
-    DepositSlashed: GenericPalletEvent<Rv, 'SafeMode', 'DepositSlashed', { account: AccountId32; amount: bigint }>;
+    DepositSlashed: GenericPalletEvent<'SafeMode', 'DepositSlashed', { account: AccountId32; amount: bigint }>;
 
     /**
      * Could not hold funds for entering or extending the safe-mode.
      *
      * This error comes from the underlying `Currency`.
      **/
-    CannotDeposit: GenericPalletEvent<Rv, 'SafeMode', 'CannotDeposit', null>;
+    CannotDeposit: GenericPalletEvent<'SafeMode', 'CannotDeposit', null>;
 
     /**
      * Could not release funds for entering or extending the safe-mode.
      *
      * This error comes from the underlying `Currency`.
      **/
-    CannotRelease: GenericPalletEvent<Rv, 'SafeMode', 'CannotRelease', null>;
+    CannotRelease: GenericPalletEvent<'SafeMode', 'CannotRelease', null>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `TxPause`'s events
@@ -2891,17 +2728,17 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * This pallet, or a specific call is now paused.
      **/
-    CallPaused: GenericPalletEvent<Rv, 'TxPause', 'CallPaused', { fullName: [Bytes, Bytes] }>;
+    CallPaused: GenericPalletEvent<'TxPause', 'CallPaused', { fullName: [Bytes, Bytes] }>;
 
     /**
      * This pallet, or a specific call is now unpaused.
      **/
-    CallUnpaused: GenericPalletEvent<Rv, 'TxPause', 'CallUnpaused', { fullName: [Bytes, Bytes] }>;
+    CallUnpaused: GenericPalletEvent<'TxPause', 'CallUnpaused', { fullName: [Bytes, Bytes] }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
   /**
    * Pallet `MultiBlockMigrations`'s events
@@ -2913,7 +2750,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
      **/
     UpgradeStarted: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'UpgradeStarted',
       {
@@ -2932,20 +2768,19 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      *
      * This implies that all of its migrations completed successfully as well.
      **/
-    UpgradeCompleted: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeCompleted', null>;
+    UpgradeCompleted: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeCompleted', null>;
 
     /**
      * Runtime upgrade failed.
      *
      * This is very bad and will require governance intervention.
      **/
-    UpgradeFailed: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeFailed', null>;
+    UpgradeFailed: GenericPalletEvent<'MultiBlockMigrations', 'UpgradeFailed', null>;
 
     /**
      * A migration was skipped since it was already executed in the past.
      **/
     MigrationSkipped: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationSkipped',
       {
@@ -2960,7 +2795,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A migration progressed.
      **/
     MigrationAdvanced: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationAdvanced',
       {
@@ -2980,7 +2814,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * A Migration completed.
      **/
     MigrationCompleted: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationCompleted',
       {
@@ -3002,7 +2835,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * This implies that the whole upgrade failed and governance intervention is required.
      **/
     MigrationFailed: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'MigrationFailed',
       {
@@ -3022,7 +2854,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      * The set of historical migrations has been cleared.
      **/
     HistoricCleared: GenericPalletEvent<
-      Rv,
       'MultiBlockMigrations',
       'HistoricCleared',
       {
@@ -3036,6 +2867,6 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent<Rv>;
+    [prop: string]: GenericPalletEvent;
   };
 }