@dedot/chaintypes 0.0.1-next.f5bf4fc2.1 → 0.1.0

package/astar/events.d.ts

@@ -1,6 +1,6 @@
-// Generated by @dedot/codegen
+// Generated by dedot cli
 
-import type { GenericChainEvents, GenericPalletEvent } from '@dedot/types';
+import type { GenericChainEvents, GenericPalletEvent, RpcVersion } from 'dedot/types';
 import type {
   DispatchInfo,
   DispatchError,
@@ -9,10 +9,10 @@ import type {
   Result,
   FixedBytes,
   Bytes,
+  FixedU128,
   H160,
   U256,
-  FixedU64,
-} from '@dedot/codecs';
+} from 'dedot/codecs';
 import type {
   PalletMultisigTimepoint,
   AstarRuntimeProxyType,
@@ -22,10 +22,11 @@ import type {
   PalletDappStakingV3Subperiod,
   AstarPrimitivesDappStakingSmartContract,
   PalletDappStakingV3ForcingType,
+  AstarPrimitivesOracleCurrencyId,
   XcmV3TraitsError,
-  PolkadotParachainPrimitivesId,
+  PolkadotParachainPrimitivesPrimitivesId,
   XcmV3TraitsOutcome,
-  XcmV3MultilocationMultiLocation,
+  StagingXcmV3MultilocationMultiLocation,
   XcmV3Xcm,
   XcmV3Response,
   XcmVersionedMultiAssets,
@@ -35,10 +36,9 @@ import type {
   EthereumLog,
   EvmCoreErrorExitReason,
   PalletContractsOrigin,
-  PalletDappsStakingRewardDestination,
 } from './types';
 
-export interface ChainEvents extends GenericChainEvents {
+export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
   /**
    * Pallet `System`'s events
    **/
@@ -46,12 +46,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * An extrinsic completed successfully.
      **/
-    ExtrinsicSuccess: GenericPalletEvent<'System', 'ExtrinsicSuccess', { dispatchInfo: DispatchInfo }>;
+    ExtrinsicSuccess: GenericPalletEvent<Rv, 'System', 'ExtrinsicSuccess', { dispatchInfo: DispatchInfo }>;
 
     /**
      * An extrinsic failed.
      **/
     ExtrinsicFailed: GenericPalletEvent<
+      Rv,
       'System',
       'ExtrinsicFailed',
       { dispatchError: DispatchError; dispatchInfo: DispatchInfo }
@@ -60,27 +61,27 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * `:code` was updated.
      **/
-    CodeUpdated: GenericPalletEvent<'System', 'CodeUpdated', null>;
+    CodeUpdated: GenericPalletEvent<Rv, 'System', 'CodeUpdated', null>;
 
     /**
      * A new account was created.
      **/
-    NewAccount: GenericPalletEvent<'System', 'NewAccount', { account: AccountId32 }>;
+    NewAccount: GenericPalletEvent<Rv, 'System', 'NewAccount', { account: AccountId32 }>;
 
     /**
      * An account was reaped.
      **/
-    KilledAccount: GenericPalletEvent<'System', 'KilledAccount', { account: AccountId32 }>;
+    KilledAccount: GenericPalletEvent<Rv, 'System', 'KilledAccount', { account: AccountId32 }>;
 
     /**
      * On on-chain remark happened.
      **/
-    Remarked: GenericPalletEvent<'System', 'Remarked', { sender: AccountId32; hash: H256 }>;
+    Remarked: GenericPalletEvent<Rv, 'System', 'Remarked', { sender: AccountId32; hash: H256 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Utility`'s events
@@ -90,37 +91,37 @@ export interface ChainEvents extends GenericChainEvents {
      * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
      * well as the error.
      **/
-    BatchInterrupted: GenericPalletEvent<'Utility', 'BatchInterrupted', { index: number; error: DispatchError }>;
+    BatchInterrupted: GenericPalletEvent<Rv, 'Utility', 'BatchInterrupted', { index: number; error: DispatchError }>;
 
     /**
      * Batch of dispatches completed fully with no error.
      **/
-    BatchCompleted: GenericPalletEvent<'Utility', 'BatchCompleted', null>;
+    BatchCompleted: GenericPalletEvent<Rv, 'Utility', 'BatchCompleted', null>;
 
     /**
      * Batch of dispatches completed but has errors.
      **/
-    BatchCompletedWithErrors: GenericPalletEvent<'Utility', 'BatchCompletedWithErrors', null>;
+    BatchCompletedWithErrors: GenericPalletEvent<Rv, 'Utility', 'BatchCompletedWithErrors', null>;
 
     /**
      * A single item within a Batch of dispatches has completed with no error.
      **/
-    ItemCompleted: GenericPalletEvent<'Utility', 'ItemCompleted', null>;
+    ItemCompleted: GenericPalletEvent<Rv, 'Utility', 'ItemCompleted', null>;
 
     /**
      * A single item within a Batch of dispatches has completed with error.
      **/
-    ItemFailed: GenericPalletEvent<'Utility', 'ItemFailed', { error: DispatchError }>;
+    ItemFailed: GenericPalletEvent<Rv, 'Utility', 'ItemFailed', { error: DispatchError }>;
 
     /**
      * A call was dispatched.
      **/
-    DispatchedAs: GenericPalletEvent<'Utility', 'DispatchedAs', { result: Result<[], DispatchError> }>;
+    DispatchedAs: GenericPalletEvent<Rv, 'Utility', 'DispatchedAs', { result: Result<[], DispatchError> }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Identity`'s events
@@ -129,22 +130,23 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * A name was set or reset (which will remove all judgements).
      **/
-    IdentitySet: GenericPalletEvent<'Identity', 'IdentitySet', { who: AccountId32 }>;
+    IdentitySet: GenericPalletEvent<Rv, 'Identity', 'IdentitySet', { who: AccountId32 }>;
 
     /**
      * A name was cleared, and the given balance returned.
      **/
-    IdentityCleared: GenericPalletEvent<'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
+    IdentityCleared: GenericPalletEvent<Rv, 'Identity', 'IdentityCleared', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A name was removed and the given balance slashed.
      **/
-    IdentityKilled: GenericPalletEvent<'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
+    IdentityKilled: GenericPalletEvent<Rv, 'Identity', 'IdentityKilled', { who: AccountId32; deposit: bigint }>;
 
     /**
      * A judgement was asked from a registrar.
      **/
     JudgementRequested: GenericPalletEvent<
+      Rv,
       'Identity',
       'JudgementRequested',
       { who: AccountId32; registrarIndex: number }
@@ -154,6 +156,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A judgement request was retracted.
      **/
     JudgementUnrequested: GenericPalletEvent<
+      Rv,
       'Identity',
       'JudgementUnrequested',
       { who: AccountId32; registrarIndex: number }
@@ -162,17 +165,23 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * A judgement was given by a registrar.
      **/
-    JudgementGiven: GenericPalletEvent<'Identity', 'JudgementGiven', { target: AccountId32; registrarIndex: number }>;
+    JudgementGiven: GenericPalletEvent<
+      Rv,
+      'Identity',
+      'JudgementGiven',
+      { target: AccountId32; registrarIndex: number }
+    >;
 
     /**
      * A registrar was added.
      **/
-    RegistrarAdded: GenericPalletEvent<'Identity', 'RegistrarAdded', { registrarIndex: number }>;
+    RegistrarAdded: GenericPalletEvent<Rv, '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 }
@@ -182,6 +191,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A sub-identity was removed from an identity and the deposit freed.
      **/
     SubIdentityRemoved: GenericPalletEvent<
+      Rv,
       'Identity',
       'SubIdentityRemoved',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -192,6 +202,7 @@ export interface ChainEvents extends GenericChainEvents {
      * main identity account to the sub-identity account.
      **/
     SubIdentityRevoked: GenericPalletEvent<
+      Rv,
       'Identity',
       'SubIdentityRevoked',
       { sub: AccountId32; main: AccountId32; deposit: bigint }
@@ -200,7 +211,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Multisig`'s events
@@ -210,6 +221,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A new multisig operation has begun.
      **/
     NewMultisig: GenericPalletEvent<
+      Rv,
       'Multisig',
       'NewMultisig',
       { approving: AccountId32; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -219,6 +231,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A multisig operation has been approved by someone.
      **/
     MultisigApproval: GenericPalletEvent<
+      Rv,
       'Multisig',
       'MultisigApproval',
       { approving: AccountId32; timepoint: PalletMultisigTimepoint; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -228,6 +241,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A multisig operation has been executed.
      **/
     MultisigExecuted: GenericPalletEvent<
+      Rv,
       'Multisig',
       'MultisigExecuted',
       {
@@ -243,6 +257,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A multisig operation has been cancelled.
      **/
     MultisigCancelled: GenericPalletEvent<
+      Rv,
       'Multisig',
       'MultisigCancelled',
       { cancelling: AccountId32; timepoint: PalletMultisigTimepoint; multisig: AccountId32; callHash: FixedBytes<32> }
@@ -251,7 +266,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Proxy`'s events
@@ -260,13 +275,14 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * A proxy was executed correctly, with the given.
      **/
-    ProxyExecuted: GenericPalletEvent<'Proxy', 'ProxyExecuted', { result: Result<[], DispatchError> }>;
+    ProxyExecuted: GenericPalletEvent<Rv, '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 }
@@ -275,12 +291,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * An announcement was placed to make a call in the future.
      **/
-    Announced: GenericPalletEvent<'Proxy', 'Announced', { real: AccountId32; proxy: AccountId32; callHash: H256 }>;
+    Announced: GenericPalletEvent<Rv, '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 }
@@ -290,6 +307,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A proxy was removed.
      **/
     ProxyRemoved: GenericPalletEvent<
+      Rv,
       'Proxy',
       'ProxyRemoved',
       { delegator: AccountId32; delegatee: AccountId32; proxyType: AstarRuntimeProxyType; delay: number }
@@ -298,7 +316,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `ParachainSystem`'s events
@@ -307,12 +325,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * The validation function has been scheduled to apply.
      **/
-    ValidationFunctionStored: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionStored', null>;
+    ValidationFunctionStored: GenericPalletEvent<Rv, 'ParachainSystem', 'ValidationFunctionStored', null>;
 
     /**
      * The validation function was applied as of the contained relay chain block number.
      **/
     ValidationFunctionApplied: GenericPalletEvent<
+      Rv,
       'ParachainSystem',
       'ValidationFunctionApplied',
       { relayChainBlockNum: number }
@@ -321,22 +340,23 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * The relay-chain aborted the upgrade process.
      **/
-    ValidationFunctionDiscarded: GenericPalletEvent<'ParachainSystem', 'ValidationFunctionDiscarded', null>;
+    ValidationFunctionDiscarded: GenericPalletEvent<Rv, 'ParachainSystem', 'ValidationFunctionDiscarded', null>;
 
     /**
      * An upgrade has been authorized.
      **/
-    UpgradeAuthorized: GenericPalletEvent<'ParachainSystem', 'UpgradeAuthorized', { codeHash: H256 }>;
+    UpgradeAuthorized: GenericPalletEvent<Rv, 'ParachainSystem', 'UpgradeAuthorized', { codeHash: H256 }>;
 
     /**
      * Some downward messages have been received and will be processed.
      **/
-    DownwardMessagesReceived: GenericPalletEvent<'ParachainSystem', 'DownwardMessagesReceived', { count: number }>;
+    DownwardMessagesReceived: GenericPalletEvent<Rv, 'ParachainSystem', 'DownwardMessagesReceived', { count: number }>;
 
     /**
      * Downward messages were processed using the given weight.
      **/
     DownwardMessagesProcessed: GenericPalletEvent<
+      Rv,
       'ParachainSystem',
       'DownwardMessagesProcessed',
       { weightUsed: SpWeightsWeightV2Weight; dmqHead: H256 }
@@ -346,6 +366,7 @@ export interface ChainEvents extends GenericChainEvents {
      * An upward message was sent to the relay chain.
      **/
     UpwardMessageSent: GenericPalletEvent<
+      Rv,
       'ParachainSystem',
       'UpwardMessageSent',
       { messageHash?: FixedBytes<32> | undefined }
@@ -354,7 +375,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `TransactionPayment`'s events
@@ -365,6 +386,7 @@ export interface ChainEvents extends GenericChainEvents {
      * has been paid by `who`.
      **/
     TransactionFeePaid: GenericPalletEvent<
+      Rv,
       'TransactionPayment',
       'TransactionFeePaid',
       { who: AccountId32; actualFee: bigint; tip: bigint }
@@ -373,7 +395,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Balances`'s events
@@ -382,39 +404,40 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * An account was created with some free balance.
      **/
-    Endowed: GenericPalletEvent<'Balances', 'Endowed', { account: AccountId32; freeBalance: bigint }>;
+    Endowed: GenericPalletEvent<Rv, '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<'Balances', 'DustLost', { account: AccountId32; amount: bigint }>;
+    DustLost: GenericPalletEvent<Rv, 'Balances', 'DustLost', { account: AccountId32; amount: bigint }>;
 
     /**
      * Transfer succeeded.
      **/
-    Transfer: GenericPalletEvent<'Balances', 'Transfer', { from: AccountId32; to: AccountId32; amount: bigint }>;
+    Transfer: GenericPalletEvent<Rv, 'Balances', 'Transfer', { from: AccountId32; to: AccountId32; amount: bigint }>;
 
     /**
      * A balance was set by root.
      **/
-    BalanceSet: GenericPalletEvent<'Balances', 'BalanceSet', { who: AccountId32; free: bigint }>;
+    BalanceSet: GenericPalletEvent<Rv, 'Balances', 'BalanceSet', { who: AccountId32; free: bigint }>;
 
     /**
      * Some balance was reserved (moved from free to reserved).
      **/
-    Reserved: GenericPalletEvent<'Balances', 'Reserved', { who: AccountId32; amount: bigint }>;
+    Reserved: GenericPalletEvent<Rv, 'Balances', 'Reserved', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was unreserved (moved from reserved to free).
      **/
-    Unreserved: GenericPalletEvent<'Balances', 'Unreserved', { who: AccountId32; amount: bigint }>;
+    Unreserved: GenericPalletEvent<Rv, '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 }
@@ -423,77 +446,77 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Some amount was deposited (e.g. for transaction fees).
      **/
-    Deposit: GenericPalletEvent<'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
+    Deposit: GenericPalletEvent<Rv, 'Balances', 'Deposit', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was withdrawn from the account (e.g. for transaction fees).
      **/
-    Withdraw: GenericPalletEvent<'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
+    Withdraw: GenericPalletEvent<Rv, 'Balances', 'Withdraw', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was removed from the account (e.g. for misbehavior).
      **/
-    Slashed: GenericPalletEvent<'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
+    Slashed: GenericPalletEvent<Rv, 'Balances', 'Slashed', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was minted into an account.
      **/
-    Minted: GenericPalletEvent<'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
+    Minted: GenericPalletEvent<Rv, 'Balances', 'Minted', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was burned from an account.
      **/
-    Burned: GenericPalletEvent<'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
+    Burned: GenericPalletEvent<Rv, 'Balances', 'Burned', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was suspended from an account (it can be restored later).
      **/
-    Suspended: GenericPalletEvent<'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
+    Suspended: GenericPalletEvent<Rv, 'Balances', 'Suspended', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some amount was restored into an account.
      **/
-    Restored: GenericPalletEvent<'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
+    Restored: GenericPalletEvent<Rv, 'Balances', 'Restored', { who: AccountId32; amount: bigint }>;
 
     /**
      * An account was upgraded.
      **/
-    Upgraded: GenericPalletEvent<'Balances', 'Upgraded', { who: AccountId32 }>;
+    Upgraded: GenericPalletEvent<Rv, 'Balances', 'Upgraded', { who: AccountId32 }>;
 
     /**
      * Total issuance was increased by `amount`, creating a credit to be balanced.
      **/
-    Issued: GenericPalletEvent<'Balances', 'Issued', { amount: bigint }>;
+    Issued: GenericPalletEvent<Rv, 'Balances', 'Issued', { amount: bigint }>;
 
     /**
      * Total issuance was decreased by `amount`, creating a debt to be balanced.
      **/
-    Rescinded: GenericPalletEvent<'Balances', 'Rescinded', { amount: bigint }>;
+    Rescinded: GenericPalletEvent<Rv, 'Balances', 'Rescinded', { amount: bigint }>;
 
     /**
      * Some balance was locked.
      **/
-    Locked: GenericPalletEvent<'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
+    Locked: GenericPalletEvent<Rv, 'Balances', 'Locked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was unlocked.
      **/
-    Unlocked: GenericPalletEvent<'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
+    Unlocked: GenericPalletEvent<Rv, 'Balances', 'Unlocked', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was frozen.
      **/
-    Frozen: GenericPalletEvent<'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
+    Frozen: GenericPalletEvent<Rv, 'Balances', 'Frozen', { who: AccountId32; amount: bigint }>;
 
     /**
      * Some balance was thawed.
      **/
-    Thawed: GenericPalletEvent<'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
+    Thawed: GenericPalletEvent<Rv, 'Balances', 'Thawed', { who: AccountId32; amount: bigint }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Vesting`'s events
@@ -503,17 +526,17 @@ export interface ChainEvents extends GenericChainEvents {
      * 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<'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
+    VestingUpdated: GenericPalletEvent<Rv, 'Vesting', 'VestingUpdated', { account: AccountId32; unvested: bigint }>;
 
     /**
      * An \[account\] has become fully vested.
      **/
-    VestingCompleted: GenericPalletEvent<'Vesting', 'VestingCompleted', { account: AccountId32 }>;
+    VestingCompleted: GenericPalletEvent<Rv, 'Vesting', 'VestingCompleted', { account: AccountId32 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Inflation`'s events
@@ -522,12 +545,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Inflation parameters have been force changed. This will have effect on the next inflation recalculation.
      **/
-    InflationParametersForceChanged: GenericPalletEvent<'Inflation', 'InflationParametersForceChanged', null>;
+    InflationParametersForceChanged: GenericPalletEvent<Rv, 'Inflation', 'InflationParametersForceChanged', null>;
 
     /**
      * Inflation configuration has been force changed. This will have an immediate effect from this block.
      **/
     InflationConfigurationForceChanged: GenericPalletEvent<
+      Rv,
       'Inflation',
       'InflationConfigurationForceChanged',
       { config: PalletInflationInflationConfiguration }
@@ -537,6 +561,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Inflation recalculation has been forced.
      **/
     ForcedInflationRecalculation: GenericPalletEvent<
+      Rv,
       'Inflation',
       'ForcedInflationRecalculation',
       { config: PalletInflationInflationConfiguration }
@@ -546,6 +571,7 @@ export interface ChainEvents extends GenericChainEvents {
      * New inflation configuration has been set.
      **/
     NewInflationConfiguration: GenericPalletEvent<
+      Rv,
       'Inflation',
       'NewInflationConfiguration',
       { config: PalletInflationInflationConfiguration }
@@ -554,7 +580,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `DappStaking`'s events
@@ -563,17 +589,18 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Maintenance mode has been either enabled or disabled.
      **/
-    MaintenanceMode: GenericPalletEvent<'DappStaking', 'MaintenanceMode', { enabled: boolean }>;
+    MaintenanceMode: GenericPalletEvent<Rv, 'DappStaking', 'MaintenanceMode', { enabled: boolean }>;
 
     /**
      * New era has started.
      **/
-    NewEra: GenericPalletEvent<'DappStaking', 'NewEra', { era: number }>;
+    NewEra: GenericPalletEvent<Rv, 'DappStaking', 'NewEra', { era: number }>;
 
     /**
      * New subperiod has started.
      **/
     NewSubperiod: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'NewSubperiod',
       { subperiod: PalletDappStakingV3Subperiod; number: number }
@@ -583,6 +610,7 @@ export interface ChainEvents extends GenericChainEvents {
      * A smart contract has been registered for dApp staking
      **/
     DAppRegistered: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'DAppRegistered',
       { owner: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; dappId: number }
@@ -592,6 +620,7 @@ export interface ChainEvents extends GenericChainEvents {
      * dApp reward destination has been updated.
      **/
     DAppRewardDestinationUpdated: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'DAppRewardDestinationUpdated',
       { smartContract: AstarPrimitivesDappStakingSmartContract; beneficiary?: AccountId32 | undefined }
@@ -601,6 +630,7 @@ export interface ChainEvents extends GenericChainEvents {
      * dApp owner has been changed.
      **/
     DAppOwnerChanged: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'DAppOwnerChanged',
       { smartContract: AstarPrimitivesDappStakingSmartContract; newOwner: AccountId32 }
@@ -610,6 +640,7 @@ export interface ChainEvents extends GenericChainEvents {
      * dApp has been unregistered
      **/
     DAppUnregistered: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'DAppUnregistered',
       { smartContract: AstarPrimitivesDappStakingSmartContract; era: number }
@@ -618,27 +649,28 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Account has locked some amount into dApp staking.
      **/
-    Locked: GenericPalletEvent<'DappStaking', 'Locked', { account: AccountId32; amount: bigint }>;
+    Locked: GenericPalletEvent<Rv, 'DappStaking', 'Locked', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has started the unlocking process for some amount.
      **/
-    Unlocking: GenericPalletEvent<'DappStaking', 'Unlocking', { account: AccountId32; amount: bigint }>;
+    Unlocking: GenericPalletEvent<Rv, 'DappStaking', 'Unlocking', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has claimed unlocked amount, removing the lock from it.
      **/
-    ClaimedUnlocked: GenericPalletEvent<'DappStaking', 'ClaimedUnlocked', { account: AccountId32; amount: bigint }>;
+    ClaimedUnlocked: GenericPalletEvent<Rv, 'DappStaking', 'ClaimedUnlocked', { account: AccountId32; amount: bigint }>;
 
     /**
      * Account has relocked all of the unlocking chunks.
      **/
-    Relock: GenericPalletEvent<'DappStaking', 'Relock', { account: AccountId32; amount: bigint }>;
+    Relock: GenericPalletEvent<Rv, '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 }
@@ -648,6 +680,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Account has unstaked some amount from a smart contract.
      **/
     Unstake: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'Unstake',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; amount: bigint }
@@ -656,12 +689,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Account has claimed some stake rewards.
      **/
-    Reward: GenericPalletEvent<'DappStaking', 'Reward', { account: AccountId32; era: number; amount: bigint }>;
+    Reward: GenericPalletEvent<Rv, 'DappStaking', 'Reward', { account: AccountId32; era: number; amount: bigint }>;
 
     /**
      * Bonus reward has been paid out to a loyal staker.
      **/
     BonusReward: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'BonusReward',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; period: number; amount: bigint }
@@ -671,12 +705,14 @@ export interface ChainEvents extends GenericChainEvents {
      * dApp reward has been paid out to a beneficiary.
      **/
     DAppReward: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'DAppReward',
       {
         beneficiary: AccountId32;
         smartContract: AstarPrimitivesDappStakingSmartContract;
         tierId: number;
+        rank: number;
         era: number;
         amount: bigint;
       }
@@ -686,6 +722,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Account has unstaked funds from an unregistered smart contract
      **/
     UnstakeFromUnregistered: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'UnstakeFromUnregistered',
       { account: AccountId32; smartContract: AstarPrimitivesDappStakingSmartContract; amount: bigint }
@@ -695,6 +732,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Some expired stake entries have been removed from storage.
      **/
     ExpiredEntriesRemoved: GenericPalletEvent<
+      Rv,
       'DappStaking',
       'ExpiredEntriesRemoved',
       { account: AccountId32; count: number }
@@ -703,12 +741,12 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Privileged origin has forced a new era and possibly a subperiod to start from next block.
      **/
-    Force: GenericPalletEvent<'DappStaking', 'Force', { forcingType: PalletDappStakingV3ForcingType }>;
+    Force: GenericPalletEvent<Rv, 'DappStaking', 'Force', { forcingType: PalletDappStakingV3ForcingType }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Assets`'s events
@@ -717,17 +755,18 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Some asset class was created.
      **/
-    Created: GenericPalletEvent<'Assets', 'Created', { assetId: bigint; creator: AccountId32; owner: AccountId32 }>;
+    Created: GenericPalletEvent<Rv, 'Assets', 'Created', { assetId: bigint; creator: AccountId32; owner: AccountId32 }>;
 
     /**
      * Some assets were issued.
      **/
-    Issued: GenericPalletEvent<'Assets', 'Issued', { assetId: bigint; owner: AccountId32; amount: bigint }>;
+    Issued: GenericPalletEvent<Rv, '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 }
@@ -736,12 +775,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Some assets were destroyed.
      **/
-    Burned: GenericPalletEvent<'Assets', 'Burned', { assetId: bigint; owner: AccountId32; balance: bigint }>;
+    Burned: GenericPalletEvent<Rv, '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 }
@@ -750,32 +790,33 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * The owner changed.
      **/
-    OwnerChanged: GenericPalletEvent<'Assets', 'OwnerChanged', { assetId: bigint; owner: AccountId32 }>;
+    OwnerChanged: GenericPalletEvent<Rv, 'Assets', 'OwnerChanged', { assetId: bigint; owner: AccountId32 }>;
 
     /**
      * Some account `who` was frozen.
      **/
-    Frozen: GenericPalletEvent<'Assets', 'Frozen', { assetId: bigint; who: AccountId32 }>;
+    Frozen: GenericPalletEvent<Rv, 'Assets', 'Frozen', { assetId: bigint; who: AccountId32 }>;
 
     /**
      * Some account `who` was thawed.
      **/
-    Thawed: GenericPalletEvent<'Assets', 'Thawed', { assetId: bigint; who: AccountId32 }>;
+    Thawed: GenericPalletEvent<Rv, 'Assets', 'Thawed', { assetId: bigint; who: AccountId32 }>;
 
     /**
      * Some asset `asset_id` was frozen.
      **/
-    AssetFrozen: GenericPalletEvent<'Assets', 'AssetFrozen', { assetId: bigint }>;
+    AssetFrozen: GenericPalletEvent<Rv, 'Assets', 'AssetFrozen', { assetId: bigint }>;
 
     /**
      * Some asset `asset_id` was thawed.
      **/
-    AssetThawed: GenericPalletEvent<'Assets', 'AssetThawed', { assetId: bigint }>;
+    AssetThawed: GenericPalletEvent<Rv, 'Assets', 'AssetThawed', { assetId: bigint }>;
 
     /**
      * Accounts were destroyed for given asset.
      **/
     AccountsDestroyed: GenericPalletEvent<
+      Rv,
       'Assets',
       'AccountsDestroyed',
       { assetId: bigint; accountsDestroyed: number; accountsRemaining: number }
@@ -785,6 +826,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Approvals were destroyed for given asset.
      **/
     ApprovalsDestroyed: GenericPalletEvent<
+      Rv,
       'Assets',
       'ApprovalsDestroyed',
       { assetId: bigint; approvalsDestroyed: number; approvalsRemaining: number }
@@ -793,22 +835,23 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * An asset class is in the process of being destroyed.
      **/
-    DestructionStarted: GenericPalletEvent<'Assets', 'DestructionStarted', { assetId: bigint }>;
+    DestructionStarted: GenericPalletEvent<Rv, 'Assets', 'DestructionStarted', { assetId: bigint }>;
 
     /**
      * An asset class was destroyed.
      **/
-    Destroyed: GenericPalletEvent<'Assets', 'Destroyed', { assetId: bigint }>;
+    Destroyed: GenericPalletEvent<Rv, 'Assets', 'Destroyed', { assetId: bigint }>;
 
     /**
      * Some asset class was force-created.
      **/
-    ForceCreated: GenericPalletEvent<'Assets', 'ForceCreated', { assetId: bigint; owner: AccountId32 }>;
+    ForceCreated: GenericPalletEvent<Rv, '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 }
@@ -817,12 +860,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Metadata has been cleared for an asset.
      **/
-    MetadataCleared: GenericPalletEvent<'Assets', 'MetadataCleared', { assetId: bigint }>;
+    MetadataCleared: GenericPalletEvent<Rv, '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 }
@@ -832,6 +876,7 @@ export interface ChainEvents extends GenericChainEvents {
      * An approval for account `delegate` was cancelled by `owner`.
      **/
     ApprovalCancelled: GenericPalletEvent<
+      Rv,
       'Assets',
       'ApprovalCancelled',
       { assetId: bigint; owner: AccountId32; delegate: AccountId32 }
@@ -842,6 +887,7 @@ export interface ChainEvents extends GenericChainEvents {
      * the approved `delegate`.
      **/
     TransferredApproved: GenericPalletEvent<
+      Rv,
       'Assets',
       'TransferredApproved',
       { assetId: bigint; owner: AccountId32; delegate: AccountId32; destination: AccountId32; amount: bigint }
@@ -850,12 +896,13 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * An asset has had its attributes changed by the `Force` origin.
      **/
-    AssetStatusChanged: GenericPalletEvent<'Assets', 'AssetStatusChanged', { assetId: bigint }>;
+    AssetStatusChanged: GenericPalletEvent<Rv, '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 }
@@ -864,33 +911,105 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Some account `who` was created with a deposit from `depositor`.
      **/
-    Touched: GenericPalletEvent<'Assets', 'Touched', { assetId: bigint; who: AccountId32; depositor: AccountId32 }>;
+    Touched: GenericPalletEvent<Rv, 'Assets', 'Touched', { assetId: bigint; who: AccountId32; depositor: AccountId32 }>;
 
     /**
      * Some account `who` was blocked.
      **/
-    Blocked: GenericPalletEvent<'Assets', 'Blocked', { assetId: bigint; who: AccountId32 }>;
+    Blocked: GenericPalletEvent<Rv, 'Assets', 'Blocked', { assetId: bigint; who: AccountId32 }>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `PriceAggregator`'s events
+   **/
+  priceAggregator: {
+    /**
+     * New average native currency value has been calculated and pushed into the moving average buffer.
+     **/
+    AverageAggregatedValue: GenericPalletEvent<Rv, 'PriceAggregator', 'AverageAggregatedValue', { value: FixedU128 }>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `Oracle`'s events
+   **/
+  oracle: {
+    /**
+     * New feed data is submitted.
+     **/
+    NewFeedData: GenericPalletEvent<
+      Rv,
+      'Oracle',
+      'NewFeedData',
+      { sender: AccountId32; values: Array<[AstarPrimitivesOracleCurrencyId, FixedU128]> }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `OracleMembership`'s events
+   **/
+  oracleMembership: {
+    /**
+     * The given member was added; see the transaction for who.
+     **/
+    MemberAdded: GenericPalletEvent<Rv, 'OracleMembership', 'MemberAdded', undefined>;
+
+    /**
+     * The given member was removed; see the transaction for who.
+     **/
+    MemberRemoved: GenericPalletEvent<Rv, 'OracleMembership', 'MemberRemoved', undefined>;
+
+    /**
+     * Two members were swapped; see the transaction for who.
+     **/
+    MembersSwapped: GenericPalletEvent<Rv, 'OracleMembership', 'MembersSwapped', undefined>;
+
+    /**
+     * The membership was reset; see the transaction for who the new set is.
+     **/
+    MembersReset: GenericPalletEvent<Rv, 'OracleMembership', 'MembersReset', undefined>;
+
+    /**
+     * One of the members' keys changed.
+     **/
+    KeyChanged: GenericPalletEvent<Rv, 'OracleMembership', 'KeyChanged', undefined>;
+
+    /**
+     * Phantom member, never used.
+     **/
+    Dummy: GenericPalletEvent<Rv, 'OracleMembership', 'Dummy', undefined>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `CollatorSelection`'s events
    **/
   collatorSelection: {
-    NewInvulnerables: GenericPalletEvent<'CollatorSelection', 'NewInvulnerables', Array<AccountId32>>;
-    NewDesiredCandidates: GenericPalletEvent<'CollatorSelection', 'NewDesiredCandidates', number>;
-    NewCandidacyBond: GenericPalletEvent<'CollatorSelection', 'NewCandidacyBond', bigint>;
-    CandidateAdded: GenericPalletEvent<'CollatorSelection', 'CandidateAdded', [AccountId32, bigint]>;
-    CandidateRemoved: GenericPalletEvent<'CollatorSelection', 'CandidateRemoved', AccountId32>;
-    CandidateSlashed: GenericPalletEvent<'CollatorSelection', 'CandidateSlashed', AccountId32>;
+    NewInvulnerables: GenericPalletEvent<Rv, 'CollatorSelection', 'NewInvulnerables', Array<AccountId32>>;
+    NewDesiredCandidates: GenericPalletEvent<Rv, 'CollatorSelection', 'NewDesiredCandidates', number>;
+    NewCandidacyBond: GenericPalletEvent<Rv, 'CollatorSelection', 'NewCandidacyBond', bigint>;
+    CandidateAdded: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateAdded', [AccountId32, bigint]>;
+    CandidateRemoved: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateRemoved', AccountId32>;
+    CandidateSlashed: GenericPalletEvent<Rv, 'CollatorSelection', 'CandidateSlashed', AccountId32>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Session`'s events
@@ -900,12 +1019,12 @@ export interface ChainEvents extends GenericChainEvents {
      * New session has happened. Note that the argument is the session index, not the
      * block number as the type might suggest.
      **/
-    NewSession: GenericPalletEvent<'Session', 'NewSession', { sessionIndex: number }>;
+    NewSession: GenericPalletEvent<Rv, 'Session', 'NewSession', { sessionIndex: number }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `XcmpQueue`'s events
@@ -915,48 +1034,62 @@ export interface ChainEvents extends GenericChainEvents {
      * Some XCM was executed ok.
      **/
     Success: GenericPalletEvent<
+      Rv,
       'XcmpQueue',
       'Success',
-      { messageHash?: FixedBytes<32> | undefined; weight: SpWeightsWeightV2Weight }
+      { messageHash: FixedBytes<32>; messageId: FixedBytes<32>; weight: SpWeightsWeightV2Weight }
     >;
 
     /**
      * Some XCM failed.
      **/
     Fail: GenericPalletEvent<
+      Rv,
       'XcmpQueue',
       'Fail',
-      { messageHash?: FixedBytes<32> | undefined; error: XcmV3TraitsError; weight: SpWeightsWeightV2Weight }
+      {
+        messageHash: FixedBytes<32>;
+        messageId: FixedBytes<32>;
+        error: XcmV3TraitsError;
+        weight: SpWeightsWeightV2Weight;
+      }
     >;
 
     /**
      * Bad XCM version used.
      **/
-    BadVersion: GenericPalletEvent<'XcmpQueue', 'BadVersion', { messageHash?: FixedBytes<32> | undefined }>;
+    BadVersion: GenericPalletEvent<Rv, 'XcmpQueue', 'BadVersion', { messageHash: FixedBytes<32> }>;
 
     /**
      * Bad XCM format used.
      **/
-    BadFormat: GenericPalletEvent<'XcmpQueue', 'BadFormat', { messageHash?: FixedBytes<32> | undefined }>;
+    BadFormat: GenericPalletEvent<Rv, 'XcmpQueue', 'BadFormat', { messageHash: FixedBytes<32> }>;
 
     /**
      * An HRMP message was sent to a sibling parachain.
      **/
-    XcmpMessageSent: GenericPalletEvent<'XcmpQueue', 'XcmpMessageSent', { messageHash?: FixedBytes<32> | undefined }>;
+    XcmpMessageSent: GenericPalletEvent<Rv, 'XcmpQueue', 'XcmpMessageSent', { messageHash: FixedBytes<32> }>;
 
     /**
      * An XCM exceeded the individual message weight budget.
      **/
     OverweightEnqueued: GenericPalletEvent<
+      Rv,
       'XcmpQueue',
       'OverweightEnqueued',
-      { sender: PolkadotParachainPrimitivesId; sentAt: number; index: bigint; required: SpWeightsWeightV2Weight }
+      {
+        sender: PolkadotParachainPrimitivesPrimitivesId;
+        sentAt: number;
+        index: bigint;
+        required: SpWeightsWeightV2Weight;
+      }
     >;
 
     /**
      * An XCM from the overweight queue was executed with the given actual weight used.
      **/
     OverweightServiced: GenericPalletEvent<
+      Rv,
       'XcmpQueue',
       'OverweightServiced',
       { index: bigint; used: SpWeightsWeightV2Weight }
@@ -965,7 +1098,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `PolkadotXcm`'s events
@@ -973,92 +1106,108 @@ export interface ChainEvents extends GenericChainEvents {
   polkadotXcm: {
     /**
      * Execution of an XCM message was attempted.
-     *
-     * \[ outcome \]
      **/
-    Attempted: GenericPalletEvent<'PolkadotXcm', 'Attempted', XcmV3TraitsOutcome>;
+    Attempted: GenericPalletEvent<Rv, 'PolkadotXcm', 'Attempted', { outcome: XcmV3TraitsOutcome }>;
 
     /**
      * A XCM message was sent.
-     *
-     * \[ origin, destination, message \]
      **/
     Sent: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'Sent',
-      [XcmV3MultilocationMultiLocation, XcmV3MultilocationMultiLocation, XcmV3Xcm]
+      {
+        origin: StagingXcmV3MultilocationMultiLocation;
+        destination: StagingXcmV3MultilocationMultiLocation;
+        message: XcmV3Xcm;
+        messageId: FixedBytes<32>;
+      }
     >;
 
     /**
      * Query response received which does not match a registered query. This may be because a
      * matching query was never registered, it may be because it is a duplicate response, or
      * because the query timed out.
-     *
-     * \[ origin location, id \]
      **/
     UnexpectedResponse: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'UnexpectedResponse',
-      [XcmV3MultilocationMultiLocation, bigint]
+      { origin: StagingXcmV3MultilocationMultiLocation; queryId: bigint }
     >;
 
     /**
      * Query response has been received and is ready for taking with `take_response`. There is
      * no registered notification call.
-     *
-     * \[ id, response \]
      **/
-    ResponseReady: GenericPalletEvent<'PolkadotXcm', 'ResponseReady', [bigint, XcmV3Response]>;
+    ResponseReady: GenericPalletEvent<Rv, 'PolkadotXcm', 'ResponseReady', { queryId: bigint; response: XcmV3Response }>;
 
     /**
      * Query response has been received and query is removed. The registered notification has
      * been dispatched and executed successfully.
-     *
-     * \[ id, pallet index, call index \]
      **/
-    Notified: GenericPalletEvent<'PolkadotXcm', 'Notified', [bigint, number, number]>;
+    Notified: GenericPalletEvent<
+      Rv,
+      'PolkadotXcm',
+      'Notified',
+      { queryId: bigint; palletIndex: number; callIndex: number }
+    >;
 
     /**
-     * Query response has been received and query is removed. The registered notification could
-     * not be dispatched because the dispatch weight is greater than the maximum weight
+     * Query response has been received and query is removed. The registered notification
+     * could not be dispatched because the dispatch weight is greater than the maximum weight
      * originally budgeted by this runtime for the query result.
-     *
-     * \[ id, pallet index, call index, actual weight, max budgeted weight \]
      **/
     NotifyOverweight: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'NotifyOverweight',
-      [bigint, number, number, SpWeightsWeightV2Weight, SpWeightsWeightV2Weight]
+      {
+        queryId: bigint;
+        palletIndex: number;
+        callIndex: number;
+        actualWeight: SpWeightsWeightV2Weight;
+        maxBudgetedWeight: SpWeightsWeightV2Weight;
+      }
     >;
 
     /**
      * Query response has been received and query is removed. There was a general error with
      * dispatching the notification call.
-     *
-     * \[ id, pallet index, call index \]
      **/
-    NotifyDispatchError: GenericPalletEvent<'PolkadotXcm', 'NotifyDispatchError', [bigint, number, number]>;
+    NotifyDispatchError: GenericPalletEvent<
+      Rv,
+      'PolkadotXcm',
+      'NotifyDispatchError',
+      { queryId: bigint; palletIndex: number; callIndex: number }
+    >;
 
     /**
      * Query response has been received and query is removed. The dispatch was unable to be
      * decoded into a `Call`; this might be due to dispatch function having a signature which
      * is not `(origin, QueryId, Response)`.
-     *
-     * \[ id, pallet index, call index \]
      **/
-    NotifyDecodeFailed: GenericPalletEvent<'PolkadotXcm', 'NotifyDecodeFailed', [bigint, number, number]>;
+    NotifyDecodeFailed: GenericPalletEvent<
+      Rv,
+      'PolkadotXcm',
+      'NotifyDecodeFailed',
+      { queryId: bigint; palletIndex: number; callIndex: number }
+    >;
 
     /**
      * Expected query response has been received but the origin location of the response does
      * not match that expected. The query remains registered for a later, valid, response to
      * be received and acted upon.
-     *
-     * \[ origin location, id, expected location \]
      **/
     InvalidResponder: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'InvalidResponder',
-      [XcmV3MultilocationMultiLocation, bigint, XcmV3MultilocationMultiLocation | undefined]
+      {
+        origin: StagingXcmV3MultilocationMultiLocation;
+        queryId: bigint;
+        expectedLocation?: StagingXcmV3MultilocationMultiLocation | undefined;
+      }
     >;
 
     /**
@@ -1069,80 +1218,77 @@ export interface ChainEvents extends GenericChainEvents {
      * runtime should be readable prior to query timeout) and dangerous since the possibly
      * valid response will be dropped. Manual governance intervention is probably going to be
      * needed.
-     *
-     * \[ origin location, id \]
      **/
     InvalidResponderVersion: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'InvalidResponderVersion',
-      [XcmV3MultilocationMultiLocation, bigint]
+      { origin: StagingXcmV3MultilocationMultiLocation; queryId: bigint }
     >;
 
     /**
      * Received query response has been read and removed.
-     *
-     * \[ id \]
      **/
-    ResponseTaken: GenericPalletEvent<'PolkadotXcm', 'ResponseTaken', bigint>;
+    ResponseTaken: GenericPalletEvent<Rv, 'PolkadotXcm', 'ResponseTaken', { queryId: bigint }>;
 
     /**
      * Some assets have been placed in an asset trap.
-     *
-     * \[ hash, origin, assets \]
      **/
     AssetsTrapped: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'AssetsTrapped',
-      [H256, XcmV3MultilocationMultiLocation, XcmVersionedMultiAssets]
+      { hash: H256; origin: StagingXcmV3MultilocationMultiLocation; assets: XcmVersionedMultiAssets }
     >;
 
     /**
      * An XCM version change notification message has been attempted to be sent.
      *
      * The cost of sending it (borne by the chain) is included.
-     *
-     * \[ destination, result, cost \]
      **/
     VersionChangeNotified: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'VersionChangeNotified',
-      [XcmV3MultilocationMultiLocation, number, XcmV3MultiassetMultiAssets]
+      {
+        destination: StagingXcmV3MultilocationMultiLocation;
+        result: number;
+        cost: XcmV3MultiassetMultiAssets;
+        messageId: FixedBytes<32>;
+      }
     >;
 
     /**
      * The supported version of a location has been changed. This might be through an
      * automatic notification or a manual intervention.
-     *
-     * \[ location, XCM version \]
      **/
     SupportedVersionChanged: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'SupportedVersionChanged',
-      [XcmV3MultilocationMultiLocation, number]
+      { location: StagingXcmV3MultilocationMultiLocation; version: number }
     >;
 
     /**
      * A given location which had a version change subscription was dropped owing to an error
      * sending the notification to it.
-     *
-     * \[ location, query ID, error \]
      **/
     NotifyTargetSendFail: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'NotifyTargetSendFail',
-      [XcmV3MultilocationMultiLocation, bigint, XcmV3TraitsError]
+      { location: StagingXcmV3MultilocationMultiLocation; queryId: bigint; error: XcmV3TraitsError }
     >;
 
     /**
      * A given location which had a version change subscription was dropped owing to an error
      * migrating the location to our new XCM format.
-     *
-     * \[ location, query ID \]
      **/
     NotifyTargetMigrationFail: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'NotifyTargetMigrationFail',
-      [XcmVersionedMultiLocation, bigint]
+      { location: XcmVersionedMultiLocation; queryId: bigint }
     >;
 
     /**
@@ -1153,93 +1299,99 @@ export interface ChainEvents extends GenericChainEvents {
      * runtime should be readable prior to query timeout) and dangerous since the possibly
      * valid response will be dropped. Manual governance intervention is probably going to be
      * needed.
-     *
-     * \[ origin location, id \]
      **/
     InvalidQuerierVersion: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'InvalidQuerierVersion',
-      [XcmV3MultilocationMultiLocation, bigint]
+      { origin: StagingXcmV3MultilocationMultiLocation; queryId: bigint }
     >;
 
     /**
      * Expected query response has been received but the querier location of the response does
      * not match the expected. The query remains registered for a later, valid, response to
      * be received and acted upon.
-     *
-     * \[ origin location, id, expected querier, maybe actual querier \]
      **/
     InvalidQuerier: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'InvalidQuerier',
-      [
-        XcmV3MultilocationMultiLocation,
-        bigint,
-        XcmV3MultilocationMultiLocation,
-        XcmV3MultilocationMultiLocation | undefined,
-      ]
+      {
+        origin: StagingXcmV3MultilocationMultiLocation;
+        queryId: bigint;
+        expectedQuerier: StagingXcmV3MultilocationMultiLocation;
+        maybeActualQuerier?: StagingXcmV3MultilocationMultiLocation | undefined;
+      }
     >;
 
     /**
      * A remote has requested XCM version change notification from us and we have honored it.
      * A version information message is sent to them and its cost is included.
-     *
-     * \[ destination location, cost \]
      **/
     VersionNotifyStarted: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'VersionNotifyStarted',
-      [XcmV3MultilocationMultiLocation, XcmV3MultiassetMultiAssets]
+      {
+        destination: StagingXcmV3MultilocationMultiLocation;
+        cost: XcmV3MultiassetMultiAssets;
+        messageId: FixedBytes<32>;
+      }
     >;
 
     /**
-     * We have requested that a remote chain sends us XCM version change notifications.
-     *
-     * \[ destination location, cost \]
+     * We have requested that a remote chain send us XCM version change notifications.
      **/
     VersionNotifyRequested: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'VersionNotifyRequested',
-      [XcmV3MultilocationMultiLocation, XcmV3MultiassetMultiAssets]
+      {
+        destination: StagingXcmV3MultilocationMultiLocation;
+        cost: XcmV3MultiassetMultiAssets;
+        messageId: FixedBytes<32>;
+      }
     >;
 
     /**
-     * We have requested that a remote chain stops sending us XCM version change notifications.
-     *
-     * \[ destination location, cost \]
+     * We have requested that a remote chain stops sending us XCM version change
+     * notifications.
      **/
     VersionNotifyUnrequested: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'VersionNotifyUnrequested',
-      [XcmV3MultilocationMultiLocation, XcmV3MultiassetMultiAssets]
+      {
+        destination: StagingXcmV3MultilocationMultiLocation;
+        cost: XcmV3MultiassetMultiAssets;
+        messageId: FixedBytes<32>;
+      }
     >;
 
     /**
      * Fees were paid from a location for an operation (often for using `SendXcm`).
-     *
-     * \[ paying location, fees \]
      **/
     FeesPaid: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'FeesPaid',
-      [XcmV3MultilocationMultiLocation, XcmV3MultiassetMultiAssets]
+      { paying: StagingXcmV3MultilocationMultiLocation; fees: XcmV3MultiassetMultiAssets }
     >;
 
     /**
      * Some assets have been claimed from an asset trap
-     *
-     * \[ hash, origin, assets \]
      **/
     AssetsClaimed: GenericPalletEvent<
+      Rv,
       'PolkadotXcm',
       'AssetsClaimed',
-      [H256, XcmV3MultilocationMultiLocation, XcmVersionedMultiAssets]
+      { hash: H256; origin: StagingXcmV3MultilocationMultiLocation; assets: XcmVersionedMultiAssets }
     >;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `CumulusXcm`'s events
@@ -1249,24 +1401,24 @@ export interface ChainEvents extends GenericChainEvents {
      * Downward message is invalid XCM.
      * \[ id \]
      **/
-    InvalidFormat: GenericPalletEvent<'CumulusXcm', 'InvalidFormat', FixedBytes<32>>;
+    InvalidFormat: GenericPalletEvent<Rv, 'CumulusXcm', 'InvalidFormat', FixedBytes<32>>;
 
     /**
      * Downward message is unsupported version of XCM.
      * \[ id \]
      **/
-    UnsupportedVersion: GenericPalletEvent<'CumulusXcm', 'UnsupportedVersion', FixedBytes<32>>;
+    UnsupportedVersion: GenericPalletEvent<Rv, 'CumulusXcm', 'UnsupportedVersion', FixedBytes<32>>;
 
     /**
      * Downward message executed with the given outcome.
      * \[ id, outcome \]
      **/
-    ExecutedDownward: GenericPalletEvent<'CumulusXcm', 'ExecutedDownward', [FixedBytes<32>, XcmV3TraitsOutcome]>;
+    ExecutedDownward: GenericPalletEvent<Rv, 'CumulusXcm', 'ExecutedDownward', [FixedBytes<32>, XcmV3TraitsOutcome]>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `DmpQueue`'s events
@@ -1275,58 +1427,72 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Downward message is invalid XCM.
      **/
-    InvalidFormat: GenericPalletEvent<'DmpQueue', 'InvalidFormat', { messageId: FixedBytes<32> }>;
+    InvalidFormat: GenericPalletEvent<Rv, 'DmpQueue', 'InvalidFormat', { messageHash: FixedBytes<32> }>;
 
     /**
      * Downward message is unsupported version of XCM.
      **/
-    UnsupportedVersion: GenericPalletEvent<'DmpQueue', 'UnsupportedVersion', { messageId: FixedBytes<32> }>;
+    UnsupportedVersion: GenericPalletEvent<Rv, 'DmpQueue', 'UnsupportedVersion', { messageHash: FixedBytes<32> }>;
 
     /**
      * Downward message executed with the given outcome.
      **/
     ExecutedDownward: GenericPalletEvent<
+      Rv,
       'DmpQueue',
       'ExecutedDownward',
-      { messageId: FixedBytes<32>; outcome: XcmV3TraitsOutcome }
+      { messageHash: FixedBytes<32>; messageId: FixedBytes<32>; outcome: XcmV3TraitsOutcome }
     >;
 
     /**
      * The weight limit for handling downward messages was reached.
      **/
     WeightExhausted: GenericPalletEvent<
+      Rv,
       'DmpQueue',
       'WeightExhausted',
-      { messageId: FixedBytes<32>; remainingWeight: SpWeightsWeightV2Weight; requiredWeight: SpWeightsWeightV2Weight }
+      {
+        messageHash: FixedBytes<32>;
+        messageId: FixedBytes<32>;
+        remainingWeight: SpWeightsWeightV2Weight;
+        requiredWeight: SpWeightsWeightV2Weight;
+      }
     >;
 
     /**
      * Downward message is overweight and was placed in the overweight queue.
      **/
     OverweightEnqueued: GenericPalletEvent<
+      Rv,
       'DmpQueue',
       'OverweightEnqueued',
-      { messageId: FixedBytes<32>; overweightIndex: bigint; requiredWeight: SpWeightsWeightV2Weight }
+      {
+        messageHash: FixedBytes<32>;
+        messageId: FixedBytes<32>;
+        overweightIndex: bigint;
+        requiredWeight: SpWeightsWeightV2Weight;
+      }
     >;
 
     /**
      * Downward message from the overweight queue was executed.
      **/
     OverweightServiced: GenericPalletEvent<
+      Rv,
       'DmpQueue',
       'OverweightServiced',
       { overweightIndex: bigint; weightUsed: SpWeightsWeightV2Weight }
     >;
 
     /**
-     * The maximum number of downward messages was.
+     * The maximum number of downward messages was reached.
      **/
-    MaxMessagesExhausted: GenericPalletEvent<'DmpQueue', 'MaxMessagesExhausted', { messageId: FixedBytes<32> }>;
+    MaxMessagesExhausted: GenericPalletEvent<Rv, 'DmpQueue', 'MaxMessagesExhausted', { messageHash: FixedBytes<32> }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `XcAssetConfig`'s events
@@ -1336,6 +1502,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Registed mapping between asset type and asset Id.
      **/
     AssetRegistered: GenericPalletEvent<
+      Rv,
       'XcAssetConfig',
       'AssetRegistered',
       { assetLocation: XcmVersionedMultiLocation; assetId: bigint }
@@ -1345,6 +1512,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Changed the amount of units we are charging per execution second for an asset
      **/
     UnitsPerSecondChanged: GenericPalletEvent<
+      Rv,
       'XcAssetConfig',
       'UnitsPerSecondChanged',
       { assetLocation: XcmVersionedMultiLocation; unitsPerSecond: bigint }
@@ -1354,6 +1522,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Changed the asset type mapping for a given asset id
      **/
     AssetLocationChanged: GenericPalletEvent<
+      Rv,
       'XcAssetConfig',
       'AssetLocationChanged',
       { previousAssetLocation: XcmVersionedMultiLocation; assetId: bigint; newAssetLocation: XcmVersionedMultiLocation }
@@ -1363,6 +1532,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Supported asset type for fee payment removed.
      **/
     SupportedAssetRemoved: GenericPalletEvent<
+      Rv,
       'XcAssetConfig',
       'SupportedAssetRemoved',
       { assetLocation: XcmVersionedMultiLocation }
@@ -1372,6 +1542,7 @@ export interface ChainEvents extends GenericChainEvents {
      * Removed all information related to an asset Id
      **/
     AssetRemoved: GenericPalletEvent<
+      Rv,
       'XcAssetConfig',
       'AssetRemoved',
       { assetLocation: XcmVersionedMultiLocation; assetId: bigint }
@@ -1380,7 +1551,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `XTokens`'s events
@@ -1390,20 +1561,21 @@ export interface ChainEvents extends GenericChainEvents {
      * Transferred `MultiAsset` with fee.
      **/
     TransferredMultiAssets: GenericPalletEvent<
+      Rv,
       'XTokens',
       'TransferredMultiAssets',
       {
         sender: AccountId32;
         assets: XcmV3MultiassetMultiAssets;
         fee: XcmV3MultiassetMultiAsset;
-        dest: XcmV3MultilocationMultiLocation;
+        dest: StagingXcmV3MultilocationMultiLocation;
       }
     >;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `EVM`'s events
@@ -1412,32 +1584,32 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Ethereum events from contracts.
      **/
-    Log: GenericPalletEvent<'EVM', 'Log', { log: EthereumLog }>;
+    Log: GenericPalletEvent<Rv, 'EVM', 'Log', { log: EthereumLog }>;
 
     /**
      * A contract has been created at given address.
      **/
-    Created: GenericPalletEvent<'EVM', 'Created', { address: H160 }>;
+    Created: GenericPalletEvent<Rv, 'EVM', 'Created', { address: H160 }>;
 
     /**
      * A contract was attempted to be created, but the execution failed.
      **/
-    CreatedFailed: GenericPalletEvent<'EVM', 'CreatedFailed', { address: H160 }>;
+    CreatedFailed: GenericPalletEvent<Rv, 'EVM', 'CreatedFailed', { address: H160 }>;
 
     /**
      * A contract has been executed successfully with states applied.
      **/
-    Executed: GenericPalletEvent<'EVM', 'Executed', { address: H160 }>;
+    Executed: GenericPalletEvent<Rv, 'EVM', 'Executed', { address: H160 }>;
 
     /**
      * A contract has been executed with errors. States are reverted with only gas fees applied.
      **/
-    ExecutedFailed: GenericPalletEvent<'EVM', 'ExecutedFailed', { address: H160 }>;
+    ExecutedFailed: GenericPalletEvent<Rv, 'EVM', 'ExecutedFailed', { address: H160 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Ethereum`'s events
@@ -1447,6 +1619,7 @@ export interface ChainEvents extends GenericChainEvents {
      * An ethereum transaction was successfully executed.
      **/
     Executed: GenericPalletEvent<
+      Rv,
       'Ethereum',
       'Executed',
       { from: H160; to: H160; transactionHash: H256; exitReason: EvmCoreErrorExitReason; extraData: Bytes }
@@ -1455,7 +1628,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `DynamicEvmBaseFee`'s events
@@ -1464,12 +1637,12 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * New `base fee per gas` value has been force-set.
      **/
-    NewBaseFeePerGas: GenericPalletEvent<'DynamicEvmBaseFee', 'NewBaseFeePerGas', { fee: U256 }>;
+    NewBaseFeePerGas: GenericPalletEvent<Rv, 'DynamicEvmBaseFee', 'NewBaseFeePerGas', { fee: U256 }>;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
    * Pallet `Contracts`'s events
@@ -1478,7 +1651,7 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Contract deployed by address at the specified address.
      **/
-    Instantiated: GenericPalletEvent<'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
+    Instantiated: GenericPalletEvent<Rv, 'Contracts', 'Instantiated', { deployer: AccountId32; contract: AccountId32 }>;
 
     /**
      * Contract has been removed.
@@ -1489,6 +1662,7 @@ export interface ChainEvents extends GenericChainEvents {
      * `seal_terminate`.
      **/
     Terminated: GenericPalletEvent<
+      Rv,
       'Contracts',
       'Terminated',
       {
@@ -1507,12 +1681,18 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * Code with the specified hash has been stored.
      **/
-    CodeStored: GenericPalletEvent<'Contracts', 'CodeStored', { codeHash: H256 }>;
+    CodeStored: GenericPalletEvent<
+      Rv,
+      'Contracts',
+      'CodeStored',
+      { codeHash: H256; depositHeld: bigint; uploader: AccountId32 }
+    >;
 
     /**
      * A custom event emitted by the contract.
      **/
     ContractEmitted: GenericPalletEvent<
+      Rv,
       'Contracts',
       'ContractEmitted',
       {
@@ -1532,12 +1712,18 @@ export interface ChainEvents extends GenericChainEvents {
     /**
      * A code with the specified hash was removed.
      **/
-    CodeRemoved: GenericPalletEvent<'Contracts', 'CodeRemoved', { codeHash: H256 }>;
+    CodeRemoved: GenericPalletEvent<
+      Rv,
+      'Contracts',
+      'CodeRemoved',
+      { codeHash: H256; depositReleased: bigint; remover: AccountId32 }
+    >;
 
     /**
      * A contract's code was updated.
      **/
     ContractCodeUpdated: GenericPalletEvent<
+      Rv,
       'Contracts',
       'ContractCodeUpdated',
       {
@@ -1568,6 +1754,7 @@ export interface ChainEvents extends GenericChainEvents {
      * rolled back.
      **/
     Called: GenericPalletEvent<
+      Rv,
       'Contracts',
       'Called',
       {
@@ -1593,6 +1780,7 @@ export interface ChainEvents extends GenericChainEvents {
      * rolled back.
      **/
     DelegateCalled: GenericPalletEvent<
+      Rv,
       'Contracts',
       'DelegateCalled',
       {
@@ -1610,179 +1798,82 @@ export interface ChainEvents extends GenericChainEvents {
     >;
 
     /**
-     * Generic pallet event
-     **/
-    [prop: string]: GenericPalletEvent;
-  };
-  /**
-   * Pallet `Sudo`'s events
-   **/
-  sudo: {
-    /**
-     * A sudo just took place. \[result\]
-     **/
-    Sudid: GenericPalletEvent<'Sudo', 'Sudid', { sudoResult: Result<[], DispatchError> }>;
-
-    /**
-     * The \[sudoer\] just switched identity; the old key is supplied if one existed.
-     **/
-    KeyChanged: GenericPalletEvent<'Sudo', 'KeyChanged', { oldSudoer?: AccountId32 | undefined }>;
-
-    /**
-     * A sudo just took place. \[result\]
-     **/
-    SudoAsDone: GenericPalletEvent<'Sudo', 'SudoAsDone', { sudoResult: Result<[], DispatchError> }>;
-
-    /**
-     * Generic pallet event
-     **/
-    [prop: string]: GenericPalletEvent;
-  };
-  /**
-   * Pallet `StaticPriceProvider`'s events
-   **/
-  staticPriceProvider: {
-    /**
-     * New static native currency price has been set.
-     **/
-    PriceSet: GenericPalletEvent<'StaticPriceProvider', 'PriceSet', { price: FixedU64 }>;
-
-    /**
-     * Generic pallet event
-     **/
-    [prop: string]: GenericPalletEvent;
-  };
-  /**
-   * Pallet `DappStakingMigration`'s events
-   **/
-  dappStakingMigration: {
-    /**
-     * Number of entries migrated from v2 over to v3
+     * Some funds have been transferred and held as storage deposit.
      **/
-    EntriesMigrated: GenericPalletEvent<'DappStakingMigration', 'EntriesMigrated', number>;
+    StorageDepositTransferredAndHeld: GenericPalletEvent<
+      Rv,
+      'Contracts',
+      'StorageDepositTransferredAndHeld',
+      { from: AccountId32; to: AccountId32; amount: bigint }
+    >;
 
     /**
-     * Number of entries deleted from v2
+     * Some storage deposit funds have been transferred and released.
      **/
-    EntriesDeleted: GenericPalletEvent<'DappStakingMigration', 'EntriesDeleted', number>;
+    StorageDepositTransferredAndReleased: GenericPalletEvent<
+      Rv,
+      'Contracts',
+      'StorageDepositTransferredAndReleased',
+      { from: AccountId32; to: AccountId32; amount: bigint }
+    >;
 
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
   /**
-   * Pallet `DappsStaking`'s events
+   * Pallet `Sudo`'s events
    **/
-  dappsStaking: {
-    /**
-     * Account has bonded and staked funds on a smart contract.
-     **/
-    BondAndStake: GenericPalletEvent<
-      'DappsStaking',
-      'BondAndStake',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, bigint]
-    >;
-
-    /**
-     * Account has unbonded & unstaked some funds. Unbonding process begins.
-     **/
-    UnbondAndUnstake: GenericPalletEvent<
-      'DappsStaking',
-      'UnbondAndUnstake',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, bigint]
-    >;
-
-    /**
-     * Account has fully withdrawn all staked amount from an unregistered contract.
-     **/
-    WithdrawFromUnregistered: GenericPalletEvent<
-      'DappsStaking',
-      'WithdrawFromUnregistered',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, bigint]
-    >;
-
-    /**
-     * Account has withdrawn unbonded funds.
-     **/
-    Withdrawn: GenericPalletEvent<'DappsStaking', 'Withdrawn', [AccountId32, bigint]>;
-
-    /**
-     * New contract added for staking.
-     **/
-    NewContract: GenericPalletEvent<
-      'DappsStaking',
-      'NewContract',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract]
-    >;
-
-    /**
-     * Contract removed from dapps staking.
-     **/
-    ContractRemoved: GenericPalletEvent<
-      'DappsStaking',
-      'ContractRemoved',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract]
-    >;
-
-    /**
-     * New dapps staking era. Distribute era rewards to contracts.
-     **/
-    NewDappStakingEra: GenericPalletEvent<'DappsStaking', 'NewDappStakingEra', number>;
-
-    /**
-     * Reward paid to staker or developer.
-     **/
-    Reward: GenericPalletEvent<
-      'DappsStaking',
-      'Reward',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, number, bigint]
-    >;
-
-    /**
-     * Maintenance mode has been enabled or disabled
-     **/
-    MaintenanceMode: GenericPalletEvent<'DappsStaking', 'MaintenanceMode', boolean>;
-
+  sudo: {
     /**
-     * Reward handling modified
+     * A sudo call just took place.
      **/
-    RewardDestination: GenericPalletEvent<
-      'DappsStaking',
-      'RewardDestination',
-      [AccountId32, PalletDappsStakingRewardDestination]
+    Sudid: GenericPalletEvent<
+      Rv,
+      'Sudo',
+      'Sudid',
+      {
+        /**
+         * The result of the call made by the sudo user.
+         **/
+        sudoResult: Result<[], DispatchError>;
+      }
     >;
 
     /**
-     * Nomination part has been transfered from one contract to another.
-     *
-     * \(staker account, origin smart contract, amount, target smart contract\)
+     * The sudo key has been updated.
      **/
-    NominationTransfer: GenericPalletEvent<
-      'DappsStaking',
-      'NominationTransfer',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, bigint, AstarPrimitivesDappStakingSmartContract]
+    KeyChanged: GenericPalletEvent<
+      Rv,
+      'Sudo',
+      'KeyChanged',
+      {
+        /**
+         * The old sudo key if one was previously set.
+         **/
+        oldSudoer?: AccountId32 | undefined;
+      }
     >;
 
     /**
-     * Stale, unclaimed reward from an unregistered contract has been burned.
-     *
-     * \(developer account, smart contract, era, amount burned\)
+     * A [sudo_as](Pallet::sudo_as) call just took place.
      **/
-    StaleRewardBurned: GenericPalletEvent<
-      'DappsStaking',
-      'StaleRewardBurned',
-      [AccountId32, AstarPrimitivesDappStakingSmartContract, number, bigint]
+    SudoAsDone: GenericPalletEvent<
+      Rv,
+      'Sudo',
+      'SudoAsDone',
+      {
+        /**
+         * The result of the call made by the sudo user.
+         **/
+        sudoResult: Result<[], DispatchError>;
+      }
     >;
 
-    /**
-     * Pallet is being decommissioned.
-     **/
-    Decommission: GenericPalletEvent<'DappsStaking', 'Decommission', null>;
-
     /**
      * Generic pallet event
      **/
-    [prop: string]: GenericPalletEvent;
+    [prop: string]: GenericPalletEvent<Rv>;
   };
 }