@dedot/chaintypes 0.134.0 → 0.136.0

package/moonbeam/types.d.ts

@@ -16,10 +16,10 @@ import type {
   AccountId20Like,
   Data,
   U256,
+  Header,
   FixedI64,
   Era,
   UncheckedExtrinsic,
-  Header,
 } from 'dedot/codecs';
 
 export type FrameSystemAccountInfo = {
@@ -89,7 +89,11 @@ export type MoonbeamRuntimeRuntimeEvent =
   | { pallet: 'XcmWeightTrader'; palletEvent: PalletXcmWeightTraderEvent }
   | { pallet: 'EmergencyParaXcm'; palletEvent: PalletEmergencyParaXcmEvent }
   | { pallet: 'MultiBlockMigrations'; palletEvent: PalletMigrationsEvent002 }
-  | { pallet: 'Randomness'; palletEvent: PalletRandomnessEvent };
+  | { pallet: 'Randomness'; palletEvent: PalletRandomnessEvent }
+  | { pallet: 'BridgeKusamaGrandpa'; palletEvent: PalletBridgeGrandpaEvent }
+  | { pallet: 'BridgeKusamaParachains'; palletEvent: PalletBridgeParachainsEvent }
+  | { pallet: 'BridgeKusamaMessages'; palletEvent: PalletBridgeMessagesEvent }
+  | { pallet: 'BridgeXcmOverMoonriver'; palletEvent: PalletXcmBridgeHubEvent };
 
 /**
  * Event for the System pallet.
@@ -1450,7 +1454,11 @@ export type MoonbeamRuntimeRuntimeCall =
   | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCall }
   | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCall }
   | { pallet: 'MultiBlockMigrations'; palletCall: PalletMigrationsCall }
-  | { pallet: 'Randomness'; palletCall: PalletRandomnessCall };
+  | { pallet: 'Randomness'; palletCall: PalletRandomnessCall }
+  | { pallet: 'BridgeKusamaGrandpa'; palletCall: PalletBridgeGrandpaCall }
+  | { pallet: 'BridgeKusamaParachains'; palletCall: PalletBridgeParachainsCall }
+  | { pallet: 'BridgeKusamaMessages'; palletCall: PalletBridgeMessagesCall }
+  | { pallet: 'BridgeXcmOverMoonriver'; palletCall: PalletXcmBridgeHubCall };
 
 export type MoonbeamRuntimeRuntimeCallLike =
   | { pallet: 'System'; palletCall: FrameSystemCallLike }
@@ -1491,7 +1499,11 @@ export type MoonbeamRuntimeRuntimeCallLike =
   | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCallLike }
   | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCallLike }
   | { pallet: 'MultiBlockMigrations'; palletCall: PalletMigrationsCallLike }
-  | { pallet: 'Randomness'; palletCall: PalletRandomnessCallLike };
+  | { pallet: 'Randomness'; palletCall: PalletRandomnessCallLike }
+  | { pallet: 'BridgeKusamaGrandpa'; palletCall: PalletBridgeGrandpaCallLike }
+  | { pallet: 'BridgeKusamaParachains'; palletCall: PalletBridgeParachainsCallLike }
+  | { pallet: 'BridgeKusamaMessages'; palletCall: PalletBridgeMessagesCallLike }
+  | { pallet: 'BridgeXcmOverMoonriver'; palletCall: PalletXcmBridgeHubCallLike };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -3910,21 +3922,9 @@ export type PalletMultisigCallLike =
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
-export type PalletMoonbeamLazyMigrationsCall =
-  | { name: 'CreateContractMetadata'; params: { address: H160 } }
-  | { name: 'ApproveAssetsToMigrate'; params: { assets: Array<bigint> } }
-  | { name: 'StartForeignAssetsMigration'; params: { assetId: bigint } }
-  | { name: 'MigrateForeignAssetBalances'; params: { limit: number } }
-  | { name: 'MigrateForeignAssetApprovals'; params: { limit: number } }
-  | { name: 'FinishForeignAssetsMigration' };
-
-export type PalletMoonbeamLazyMigrationsCallLike =
-  | { name: 'CreateContractMetadata'; params: { address: H160 } }
-  | { name: 'ApproveAssetsToMigrate'; params: { assets: Array<bigint> } }
-  | { name: 'StartForeignAssetsMigration'; params: { assetId: bigint } }
-  | { name: 'MigrateForeignAssetBalances'; params: { limit: number } }
-  | { name: 'MigrateForeignAssetApprovals'; params: { limit: number } }
-  | { name: 'FinishForeignAssetsMigration' };
+export type PalletMoonbeamLazyMigrationsCall = { name: 'CreateContractMetadata'; params: { address: H160 } };
+
+export type PalletMoonbeamLazyMigrationsCallLike = { name: 'CreateContractMetadata'; params: { address: H160 } };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -8744,186 +8744,787 @@ export type PalletRandomnessCallLike =
    **/
   'SetBabeRandomnessResults';
 
-export type SpRuntimeBlakeTwo256 = {};
-
-export type PalletConvictionVotingTally = { ayes: bigint; nays: bigint; support: bigint };
-
-/**
- * The `Event` enum of this pallet
- **/
-export type PalletWhitelistEvent =
-  | { name: 'CallWhitelisted'; data: { callHash: H256 } }
-  | { name: 'WhitelistedCallRemoved'; data: { callHash: H256 } }
-  | {
-      name: 'WhitelistedCallDispatched';
-      data: {
-        callHash: H256;
-        result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
-      };
-    };
-
-export type FrameSupportDispatchPostDispatchInfo = {
-  actualWeight?: SpWeightsWeightV2Weight | undefined;
-  paysFee: FrameSupportDispatchPays;
-};
-
-export type SpRuntimeDispatchErrorWithPostInfo = {
-  postInfo: FrameSupportDispatchPostDispatchInfo;
-  error: DispatchError;
-};
-
 /**
- * The `Event` enum of this pallet
+ * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
-export type PalletCollectiveEvent =
-  /**
-   * A motion (given hash) has been proposed (by given account) with a threshold (given
-   * `MemberCount`).
-   **/
-  | { name: 'Proposed'; data: { account: AccountId20; proposalIndex: number; proposalHash: H256; threshold: number } }
+export type PalletBridgeGrandpaCall =
   /**
-   * A motion (given hash) has been voted on by given account, leaving
-   * a tally (yes votes and no votes given respectively as `MemberCount`).
+   * This call is deprecated and will be removed around May 2024. Use the
+   * `submit_finality_proof_ex` instead. Semantically, this call is an equivalent of the
+   * `submit_finality_proof_ex` call without current authority set id check.
    **/
-  | { name: 'Voted'; data: { account: AccountId20; proposalHash: H256; voted: boolean; yes: number; no: number } }
+  | {
+      name: 'SubmitFinalityProof';
+      params: { finalityTarget: Header; justification: BpHeaderChainJustificationGrandpaJustification };
+    }
   /**
-   * A motion was approved by the required threshold.
+   * Bootstrap the bridge pallet with an initial header and authority set from which to sync.
+   *
+   * The initial configuration provided does not need to be the genesis header of the bridged
+   * chain, it can be any arbitrary header. You can also provide the next scheduled set
+   * change if it is already know.
+   *
+   * This function is only allowed to be called from a trusted origin and writes to storage
+   * with practically no checks in terms of the validity of the data. It is important that
+   * you ensure that valid data is being passed in.
    **/
-  | { name: 'Approved'; data: { proposalHash: H256 } }
+  | { name: 'Initialize'; params: { initData: BpHeaderChainInitializationData } }
   /**
-   * A motion was not approved by the required threshold.
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'Disapproved'; data: { proposalHash: H256 } }
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20 | undefined } }
   /**
-   * A motion was executed; result will be `Ok` if it returned without error.
+   * Halt or resume all pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'Executed'; data: { proposalHash: H256; result: Result<[], DispatchError> } }
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpRuntimeBasicOperatingMode } }
   /**
-   * A single member did some action; result will be `Ok` if it returned without error.
+   * Verify a target header is finalized according to the given finality proof. The proof
+   * is assumed to be signed by GRANDPA authorities set with `current_set_id` id.
+   *
+   * It will use the underlying storage pallet to fetch information about the current
+   * authorities and best finalized header in order to verify that the header is finalized.
+   *
+   * If successful in verification, it will write the target header to the underlying storage
+   * pallet.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the pallet knows better header than the `finality_target`;
+   *
+   * - the id of best GRANDPA authority set, known to the pallet is not equal to the
+   * `current_set_id`;
+   *
+   * - verification is not optimized or invalid;
+   *
+   * - header contains forced authorities set change or change with non-zero delay.
+   *
+   * The `is_free_execution_expected` parameter is not really used inside the call. It is
+   * used by the transaction extension, which should be registered at the runtime level. If
+   * this parameter is `true`, the transaction will be treated as invalid, if the call won't
+   * be executed for free. If transaction extension is not used by the runtime, this
+   * parameter is not used at all.
    **/
-  | { name: 'MemberExecuted'; data: { proposalHash: H256; result: Result<[], DispatchError> } }
+  | {
+      name: 'SubmitFinalityProofEx';
+      params: {
+        finalityTarget: Header;
+        justification: BpHeaderChainJustificationGrandpaJustification;
+        currentSetId: bigint;
+        isFreeExecutionExpected: boolean;
+      };
+    }
   /**
-   * A proposal was closed because its threshold was reached or after its duration was up.
+   * Set current authorities set and best finalized bridged header to given values
+   * (almost) without any checks. This call can fail only if:
+   *
+   * - the call origin is not a root or a pallet owner;
+   *
+   * - there are too many authorities in the new set.
+   *
+   * No other checks are made. Previously imported headers stay in the storage and
+   * are still accessible after the call.
    **/
-  | { name: 'Closed'; data: { proposalHash: H256; yes: number; no: number } }
+  | {
+      name: 'ForceSetPalletState';
+      params: {
+        newCurrentSetId: bigint;
+        newAuthorities: Array<[SpConsensusGrandpaAppPublic, bigint]>;
+        newBestHeader: Header;
+      };
+    };
+
+export type PalletBridgeGrandpaCallLike =
   /**
-   * A proposal was killed.
+   * This call is deprecated and will be removed around May 2024. Use the
+   * `submit_finality_proof_ex` instead. Semantically, this call is an equivalent of the
+   * `submit_finality_proof_ex` call without current authority set id check.
    **/
-  | { name: 'Killed'; data: { proposalHash: H256 } }
+  | {
+      name: 'SubmitFinalityProof';
+      params: { finalityTarget: Header; justification: BpHeaderChainJustificationGrandpaJustification };
+    }
   /**
-   * Some cost for storing a proposal was burned.
+   * Bootstrap the bridge pallet with an initial header and authority set from which to sync.
+   *
+   * The initial configuration provided does not need to be the genesis header of the bridged
+   * chain, it can be any arbitrary header. You can also provide the next scheduled set
+   * change if it is already know.
+   *
+   * This function is only allowed to be called from a trusted origin and writes to storage
+   * with practically no checks in terms of the validity of the data. It is important that
+   * you ensure that valid data is being passed in.
    **/
-  | { name: 'ProposalCostBurned'; data: { proposalHash: H256; who: AccountId20 } }
+  | { name: 'Initialize'; params: { initData: BpHeaderChainInitializationData } }
   /**
-   * Some cost for storing a proposal was released.
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'ProposalCostReleased'; data: { proposalHash: H256; who: AccountId20 } };
-
-/**
- * The `Event` enum of this pallet
- **/
-export type PalletTreasuryEvent =
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20Like | undefined } }
   /**
-   * We have ended a spend period and will now allocate funds.
+   * Halt or resume all pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'Spending'; data: { budgetRemaining: bigint } }
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpRuntimeBasicOperatingMode } }
   /**
-   * Some funds have been allocated.
+   * Verify a target header is finalized according to the given finality proof. The proof
+   * is assumed to be signed by GRANDPA authorities set with `current_set_id` id.
+   *
+   * It will use the underlying storage pallet to fetch information about the current
+   * authorities and best finalized header in order to verify that the header is finalized.
+   *
+   * If successful in verification, it will write the target header to the underlying storage
+   * pallet.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the pallet knows better header than the `finality_target`;
+   *
+   * - the id of best GRANDPA authority set, known to the pallet is not equal to the
+   * `current_set_id`;
+   *
+   * - verification is not optimized or invalid;
+   *
+   * - header contains forced authorities set change or change with non-zero delay.
+   *
+   * The `is_free_execution_expected` parameter is not really used inside the call. It is
+   * used by the transaction extension, which should be registered at the runtime level. If
+   * this parameter is `true`, the transaction will be treated as invalid, if the call won't
+   * be executed for free. If transaction extension is not used by the runtime, this
+   * parameter is not used at all.
    **/
-  | { name: 'Awarded'; data: { proposalIndex: number; award: bigint; account: AccountId20 } }
+  | {
+      name: 'SubmitFinalityProofEx';
+      params: {
+        finalityTarget: Header;
+        justification: BpHeaderChainJustificationGrandpaJustification;
+        currentSetId: bigint;
+        isFreeExecutionExpected: boolean;
+      };
+    }
   /**
-   * Some of our funds have been burnt.
+   * Set current authorities set and best finalized bridged header to given values
+   * (almost) without any checks. This call can fail only if:
+   *
+   * - the call origin is not a root or a pallet owner;
+   *
+   * - there are too many authorities in the new set.
+   *
+   * No other checks are made. Previously imported headers stay in the storage and
+   * are still accessible after the call.
    **/
-  | { name: 'Burnt'; data: { burntFunds: bigint } }
+  | {
+      name: 'ForceSetPalletState';
+      params: {
+        newCurrentSetId: bigint;
+        newAuthorities: Array<[SpConsensusGrandpaAppPublic, bigint]>;
+        newBestHeader: Header;
+      };
+    };
+
+export type BpHeaderChainJustificationGrandpaJustification = {
+  round: bigint;
+  commit: FinalityGrandpaCommit;
+  votesAncestries: Array<Header>;
+};
+
+export type FinalityGrandpaCommit = {
+  targetHash: H256;
+  targetNumber: number;
+  precommits: Array<FinalityGrandpaSignedPrecommit>;
+};
+
+export type SpConsensusGrandpaAppSignature = FixedBytes<64>;
+
+export type SpConsensusGrandpaAppPublic = FixedBytes<32>;
+
+export type FinalityGrandpaSignedPrecommit = {
+  precommit: FinalityGrandpaPrecommit;
+  signature: SpConsensusGrandpaAppSignature;
+  id: SpConsensusGrandpaAppPublic;
+};
+
+export type FinalityGrandpaPrecommit = { targetHash: H256; targetNumber: number };
+
+export type BpHeaderChainInitializationData = {
+  header: Header;
+  authorityList: Array<[SpConsensusGrandpaAppPublic, bigint]>;
+  setId: bigint;
+  operatingMode: BpRuntimeBasicOperatingMode;
+};
+
+export type BpRuntimeBasicOperatingMode = 'Normal' | 'Halted';
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletBridgeParachainsCall =
   /**
-   * Spending has finished; this is the amount that rolls over until next spend.
+   * Submit proof of one or several parachain heads.
+   *
+   * The proof is supposed to be proof of some `Heads` entries from the
+   * `polkadot-runtime-parachains::paras` pallet instance, deployed at the bridged chain.
+   * The proof is supposed to be crafted at the `relay_header_hash` that must already be
+   * imported by corresponding GRANDPA pallet at this chain.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the relay chain block `at_relay_block` is not imported by the associated bridge
+   * GRANDPA pallet.
+   *
+   * The call may succeed, but some heads may not be updated e.g. because pallet knows
+   * better head or it isn't tracked by the pallet.
    **/
-  | { name: 'Rollover'; data: { rolloverBalance: bigint } }
+  | {
+      name: 'SubmitParachainHeads';
+      params: {
+        atRelayBlock: [number, H256];
+        parachains: Array<[BpPolkadotCoreParachainsParaId, H256]>;
+        parachainHeadsProof: BpPolkadotCoreParachainsParaHeadsProof;
+      };
+    }
   /**
-   * Some funds have been deposited.
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'Deposit'; data: { value: bigint } }
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20 | undefined } }
   /**
-   * A new spend proposal has been approved.
+   * Halt or resume all pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'SpendApproved'; data: { proposalIndex: number; amount: bigint; beneficiary: AccountId20 } }
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpRuntimeBasicOperatingMode } }
   /**
-   * The inactive funds of the pallet have been updated.
+   * Submit proof of one or several parachain heads.
+   *
+   * The proof is supposed to be proof of some `Heads` entries from the
+   * `polkadot-runtime-parachains::paras` pallet instance, deployed at the bridged chain.
+   * The proof is supposed to be crafted at the `relay_header_hash` that must already be
+   * imported by corresponding GRANDPA pallet at this chain.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the relay chain block `at_relay_block` is not imported by the associated bridge
+   * GRANDPA pallet.
+   *
+   * The call may succeed, but some heads may not be updated e.g. because pallet knows
+   * better head or it isn't tracked by the pallet.
+   *
+   * The `is_free_execution_expected` parameter is not really used inside the call. It is
+   * used by the transaction extension, which should be registered at the runtime level. If
+   * this parameter is `true`, the transaction will be treated as invalid, if the call won't
+   * be executed for free. If transaction extension is not used by the runtime, this
+   * parameter is not used at all.
    **/
-  | { name: 'UpdatedInactive'; data: { reactivated: bigint; deactivated: bigint } }
+  | {
+      name: 'SubmitParachainHeadsEx';
+      params: {
+        atRelayBlock: [number, H256];
+        parachains: Array<[BpPolkadotCoreParachainsParaId, H256]>;
+        parachainHeadsProof: BpPolkadotCoreParachainsParaHeadsProof;
+        isFreeExecutionExpected: boolean;
+      };
+    };
+
+export type PalletBridgeParachainsCallLike =
   /**
-   * A new asset spend proposal has been approved.
+   * Submit proof of one or several parachain heads.
+   *
+   * The proof is supposed to be proof of some `Heads` entries from the
+   * `polkadot-runtime-parachains::paras` pallet instance, deployed at the bridged chain.
+   * The proof is supposed to be crafted at the `relay_header_hash` that must already be
+   * imported by corresponding GRANDPA pallet at this chain.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the relay chain block `at_relay_block` is not imported by the associated bridge
+   * GRANDPA pallet.
+   *
+   * The call may succeed, but some heads may not be updated e.g. because pallet knows
+   * better head or it isn't tracked by the pallet.
    **/
   | {
-      name: 'AssetSpendApproved';
-      data: {
-        index: number;
-        assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
-        amount: bigint;
-        beneficiary: AccountId20;
-        validFrom: number;
-        expireAt: number;
+      name: 'SubmitParachainHeads';
+      params: {
+        atRelayBlock: [number, H256];
+        parachains: Array<[BpPolkadotCoreParachainsParaId, H256]>;
+        parachainHeadsProof: BpPolkadotCoreParachainsParaHeadsProof;
       };
     }
   /**
-   * An approved spend was voided.
-   **/
-  | { name: 'AssetSpendVoided'; data: { index: number } }
-  /**
-   * A payment happened.
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'Paid'; data: { index: number; paymentId: [] } }
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20Like | undefined } }
   /**
-   * A payment failed and can be retried.
+   * Halt or resume all pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'PaymentFailed'; data: { index: number; paymentId: [] } }
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpRuntimeBasicOperatingMode } }
   /**
-   * A spend was processed and removed from the storage. It might have been successfully
-   * paid or it may have expired.
+   * Submit proof of one or several parachain heads.
+   *
+   * The proof is supposed to be proof of some `Heads` entries from the
+   * `polkadot-runtime-parachains::paras` pallet instance, deployed at the bridged chain.
+   * The proof is supposed to be crafted at the `relay_header_hash` that must already be
+   * imported by corresponding GRANDPA pallet at this chain.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the relay chain block `at_relay_block` is not imported by the associated bridge
+   * GRANDPA pallet.
+   *
+   * The call may succeed, but some heads may not be updated e.g. because pallet knows
+   * better head or it isn't tracked by the pallet.
+   *
+   * The `is_free_execution_expected` parameter is not really used inside the call. It is
+   * used by the transaction extension, which should be registered at the runtime level. If
+   * this parameter is `true`, the transaction will be treated as invalid, if the call won't
+   * be executed for free. If transaction extension is not used by the runtime, this
+   * parameter is not used at all.
    **/
-  | { name: 'SpendProcessed'; data: { index: number } };
+  | {
+      name: 'SubmitParachainHeadsEx';
+      params: {
+        atRelayBlock: [number, H256];
+        parachains: Array<[BpPolkadotCoreParachainsParaId, H256]>;
+        parachainHeadsProof: BpPolkadotCoreParachainsParaHeadsProof;
+        isFreeExecutionExpected: boolean;
+      };
+    };
+
+export type BpPolkadotCoreParachainsParaId = number;
+
+export type BpPolkadotCoreParachainsParaHeadsProof = { storageProof: Array<Bytes> };
 
 /**
- * The `Event` enum of this pallet
+ * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
-export type PalletCrowdloanRewardsEvent =
+export type PalletBridgeMessagesCall =
   /**
-   * The initial payment of InitializationPayment % was paid
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'InitialPaymentMade'; data: [AccountId20, bigint] }
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20 | undefined } }
   /**
-   * Someone has proven they made a contribution and associated a native identity with it.
-   * Data is the relay account, native account and the total amount of _rewards_ that will be paid
+   * Halt or resume all/some pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'NativeIdentityAssociated'; data: [FixedBytes<32>, AccountId20, bigint] }
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpMessagesMessagesOperatingMode } }
   /**
-   * A contributor has claimed some rewards.
-   * Data is the account getting paid and the amount of rewards paid.
+   * Receive messages proof from bridged chain.
+   *
+   * The weight of the call assumes that the transaction always brings outbound lane
+   * state update. Because of that, the submitter (relayer) has no benefit of not including
+   * this data in the transaction, so reward confirmations lags should be minimal.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the call origin is not `Signed(_)`;
+   *
+   * - there are too many messages in the proof;
+   *
+   * - the proof verification procedure returns an error - e.g. because header used to craft
+   * proof is not imported by the associated finality pallet;
+   *
+   * - the `dispatch_weight` argument is not sufficient to dispatch all bundled messages.
+   *
+   * The call may succeed, but some messages may not be delivered e.g. if they are not fit
+   * into the unrewarded relayers vector.
    **/
-  | { name: 'RewardsPaid'; data: [AccountId20, bigint] }
+  | {
+      name: 'ReceiveMessagesProof';
+      params: {
+        relayerIdAtBridgedChain: AccountId20;
+        proof: BpMessagesTargetChainFromBridgedChainMessagesProof;
+        messagesCount: number;
+        dispatchWeight: SpWeightsWeightV2Weight;
+      };
+    }
   /**
-   * A contributor has updated the reward address.
+   * Receive messages delivery proof from bridged chain.
    **/
-  | { name: 'RewardAddressUpdated'; data: [AccountId20, AccountId20] }
+  | {
+      name: 'ReceiveMessagesDeliveryProof';
+      params: {
+        proof: BpMessagesSourceChainFromBridgedChainMessagesDeliveryProof;
+        relayersState: BpMessagesUnrewardedRelayersState;
+      };
+    };
+
+export type PalletBridgeMessagesCallLike =
   /**
-   * When initializing the reward vec an already initialized account was found
+   * Change `PalletOwner`.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'InitializedAlreadyInitializedAccount'; data: [FixedBytes<32>, AccountId20 | undefined, bigint] }
+  | { name: 'SetOwner'; params: { newOwner?: AccountId20Like | undefined } }
   /**
-   * When initializing the reward vec an already initialized account was found
+   * Halt or resume all/some pallet operations.
+   *
+   * May only be called either by root, or by `PalletOwner`.
    **/
-  | { name: 'InitializedAccountWithNotEnoughContribution'; data: [FixedBytes<32>, AccountId20 | undefined, bigint] };
-
-/**
- * The `Event` enum of this pallet
- **/
-export type CumulusPalletXcmpQueueEvent =
+  | { name: 'SetOperatingMode'; params: { operatingMode: BpMessagesMessagesOperatingMode } }
   /**
-   * An HRMP message was sent to a sibling parachain.
-   **/
-  { name: 'XcmpMessageSent'; data: { messageHash: FixedBytes<32> } };
-
-/**
+   * Receive messages proof from bridged chain.
+   *
+   * The weight of the call assumes that the transaction always brings outbound lane
+   * state update. Because of that, the submitter (relayer) has no benefit of not including
+   * this data in the transaction, so reward confirmations lags should be minimal.
+   *
+   * The call fails if:
+   *
+   * - the pallet is halted;
+   *
+   * - the call origin is not `Signed(_)`;
+   *
+   * - there are too many messages in the proof;
+   *
+   * - the proof verification procedure returns an error - e.g. because header used to craft
+   * proof is not imported by the associated finality pallet;
+   *
+   * - the `dispatch_weight` argument is not sufficient to dispatch all bundled messages.
+   *
+   * The call may succeed, but some messages may not be delivered e.g. if they are not fit
+   * into the unrewarded relayers vector.
+   **/
+  | {
+      name: 'ReceiveMessagesProof';
+      params: {
+        relayerIdAtBridgedChain: AccountId20Like;
+        proof: BpMessagesTargetChainFromBridgedChainMessagesProof;
+        messagesCount: number;
+        dispatchWeight: SpWeightsWeightV2Weight;
+      };
+    }
+  /**
+   * Receive messages delivery proof from bridged chain.
+   **/
+  | {
+      name: 'ReceiveMessagesDeliveryProof';
+      params: {
+        proof: BpMessagesSourceChainFromBridgedChainMessagesDeliveryProof;
+        relayersState: BpMessagesUnrewardedRelayersState;
+      };
+    };
+
+export type BpMessagesMessagesOperatingMode =
+  | { type: 'Basic'; value: BpRuntimeBasicOperatingMode }
+  | { type: 'RejectingOutboundMessages' };
+
+export type BpMessagesTargetChainFromBridgedChainMessagesProof = {
+  bridgedHeaderHash: H256;
+  storageProof: Array<Bytes>;
+  lane: BpMessagesLaneHashedLaneId;
+  noncesStart: bigint;
+  noncesEnd: bigint;
+};
+
+export type BpMessagesLaneHashedLaneId = H256;
+
+export type BpMessagesSourceChainFromBridgedChainMessagesDeliveryProof = {
+  bridgedHeaderHash: H256;
+  storageProof: Array<Bytes>;
+  lane: BpMessagesLaneHashedLaneId;
+};
+
+export type BpMessagesUnrewardedRelayersState = {
+  unrewardedRelayerEntries: bigint;
+  messagesInOldestEntry: bigint;
+  totalMessages: bigint;
+  lastDeliveredNonce: bigint;
+};
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletXcmBridgeHubCall =
+  /**
+   * Open a bridge between two locations.
+   *
+   * The caller must be within the `T::OpenBridgeOrigin` filter (presumably: a sibling
+   * parachain or a parent relay chain). The `bridge_destination_universal_location` must be
+   * a destination within the consensus of the `T::BridgedNetwork` network.
+   *
+   * The `BridgeDeposit` amount is reserved on the caller account. This deposit
+   * is unreserved after bridge is closed.
+   *
+   * The states after this call: bridge is `Opened`, outbound lane is `Opened`, inbound lane
+   * is `Opened`.
+   **/
+  | { name: 'OpenBridge'; params: { bridgeDestinationUniversalLocation: XcmVersionedInteriorLocation } }
+  /**
+   * Try to close the bridge.
+   *
+   * Can only be called by the "owner" of this side of the bridge, meaning that the
+   * inbound XCM channel with the local origin chain is working.
+   *
+   * Closed bridge is a bridge without any traces in the runtime storage. So this method
+   * first tries to prune all queued messages at the outbound lane. When there are no
+   * outbound messages left, outbound and inbound lanes are purged. After that, funds
+   * are returned back to the owner of this side of the bridge.
+   *
+   * The number of messages that we may prune in a single call is limited by the
+   * `may_prune_messages` argument. If there are more messages in the queue, the method
+   * prunes exactly `may_prune_messages` and exits early. The caller may call it again
+   * until outbound queue is depleted and get his funds back.
+   *
+   * The states after this call: everything is either `Closed`, or purged from the
+   * runtime storage.
+   **/
+  | {
+      name: 'CloseBridge';
+      params: { bridgeDestinationUniversalLocation: XcmVersionedInteriorLocation; mayPruneMessages: bigint };
+    };
+
+export type PalletXcmBridgeHubCallLike =
+  /**
+   * Open a bridge between two locations.
+   *
+   * The caller must be within the `T::OpenBridgeOrigin` filter (presumably: a sibling
+   * parachain or a parent relay chain). The `bridge_destination_universal_location` must be
+   * a destination within the consensus of the `T::BridgedNetwork` network.
+   *
+   * The `BridgeDeposit` amount is reserved on the caller account. This deposit
+   * is unreserved after bridge is closed.
+   *
+   * The states after this call: bridge is `Opened`, outbound lane is `Opened`, inbound lane
+   * is `Opened`.
+   **/
+  | { name: 'OpenBridge'; params: { bridgeDestinationUniversalLocation: XcmVersionedInteriorLocation } }
+  /**
+   * Try to close the bridge.
+   *
+   * Can only be called by the "owner" of this side of the bridge, meaning that the
+   * inbound XCM channel with the local origin chain is working.
+   *
+   * Closed bridge is a bridge without any traces in the runtime storage. So this method
+   * first tries to prune all queued messages at the outbound lane. When there are no
+   * outbound messages left, outbound and inbound lanes are purged. After that, funds
+   * are returned back to the owner of this side of the bridge.
+   *
+   * The number of messages that we may prune in a single call is limited by the
+   * `may_prune_messages` argument. If there are more messages in the queue, the method
+   * prunes exactly `may_prune_messages` and exits early. The caller may call it again
+   * until outbound queue is depleted and get his funds back.
+   *
+   * The states after this call: everything is either `Closed`, or purged from the
+   * runtime storage.
+   **/
+  | {
+      name: 'CloseBridge';
+      params: { bridgeDestinationUniversalLocation: XcmVersionedInteriorLocation; mayPruneMessages: bigint };
+    };
+
+export type XcmVersionedInteriorLocation =
+  | { type: 'V3'; value: XcmV3Junctions }
+  | { type: 'V4'; value: StagingXcmV4Junctions }
+  | { type: 'V5'; value: StagingXcmV5Junctions };
+
+export type SpRuntimeBlakeTwo256 = {};
+
+export type PalletConvictionVotingTally = { ayes: bigint; nays: bigint; support: bigint };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletWhitelistEvent =
+  | { name: 'CallWhitelisted'; data: { callHash: H256 } }
+  | { name: 'WhitelistedCallRemoved'; data: { callHash: H256 } }
+  | {
+      name: 'WhitelistedCallDispatched';
+      data: {
+        callHash: H256;
+        result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
+      };
+    };
+
+export type FrameSupportDispatchPostDispatchInfo = {
+  actualWeight?: SpWeightsWeightV2Weight | undefined;
+  paysFee: FrameSupportDispatchPays;
+};
+
+export type SpRuntimeDispatchErrorWithPostInfo = {
+  postInfo: FrameSupportDispatchPostDispatchInfo;
+  error: DispatchError;
+};
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletCollectiveEvent =
+  /**
+   * A motion (given hash) has been proposed (by given account) with a threshold (given
+   * `MemberCount`).
+   **/
+  | { name: 'Proposed'; data: { account: AccountId20; proposalIndex: number; proposalHash: H256; threshold: number } }
+  /**
+   * A motion (given hash) has been voted on by given account, leaving
+   * a tally (yes votes and no votes given respectively as `MemberCount`).
+   **/
+  | { name: 'Voted'; data: { account: AccountId20; proposalHash: H256; voted: boolean; yes: number; no: number } }
+  /**
+   * A motion was approved by the required threshold.
+   **/
+  | { name: 'Approved'; data: { proposalHash: H256 } }
+  /**
+   * A motion was not approved by the required threshold.
+   **/
+  | { name: 'Disapproved'; data: { proposalHash: H256 } }
+  /**
+   * A motion was executed; result will be `Ok` if it returned without error.
+   **/
+  | { name: 'Executed'; data: { proposalHash: H256; result: Result<[], DispatchError> } }
+  /**
+   * A single member did some action; result will be `Ok` if it returned without error.
+   **/
+  | { name: 'MemberExecuted'; data: { proposalHash: H256; result: Result<[], DispatchError> } }
+  /**
+   * A proposal was closed because its threshold was reached or after its duration was up.
+   **/
+  | { name: 'Closed'; data: { proposalHash: H256; yes: number; no: number } }
+  /**
+   * A proposal was killed.
+   **/
+  | { name: 'Killed'; data: { proposalHash: H256 } }
+  /**
+   * Some cost for storing a proposal was burned.
+   **/
+  | { name: 'ProposalCostBurned'; data: { proposalHash: H256; who: AccountId20 } }
+  /**
+   * Some cost for storing a proposal was released.
+   **/
+  | { name: 'ProposalCostReleased'; data: { proposalHash: H256; who: AccountId20 } };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletTreasuryEvent =
+  /**
+   * We have ended a spend period and will now allocate funds.
+   **/
+  | { name: 'Spending'; data: { budgetRemaining: bigint } }
+  /**
+   * Some funds have been allocated.
+   **/
+  | { name: 'Awarded'; data: { proposalIndex: number; award: bigint; account: AccountId20 } }
+  /**
+   * Some of our funds have been burnt.
+   **/
+  | { name: 'Burnt'; data: { burntFunds: bigint } }
+  /**
+   * Spending has finished; this is the amount that rolls over until next spend.
+   **/
+  | { name: 'Rollover'; data: { rolloverBalance: bigint } }
+  /**
+   * Some funds have been deposited.
+   **/
+  | { name: 'Deposit'; data: { value: bigint } }
+  /**
+   * A new spend proposal has been approved.
+   **/
+  | { name: 'SpendApproved'; data: { proposalIndex: number; amount: bigint; beneficiary: AccountId20 } }
+  /**
+   * The inactive funds of the pallet have been updated.
+   **/
+  | { name: 'UpdatedInactive'; data: { reactivated: bigint; deactivated: bigint } }
+  /**
+   * A new asset spend proposal has been approved.
+   **/
+  | {
+      name: 'AssetSpendApproved';
+      data: {
+        index: number;
+        assetKind: FrameSupportTokensFungibleUnionOfNativeOrWithId;
+        amount: bigint;
+        beneficiary: AccountId20;
+        validFrom: number;
+        expireAt: number;
+      };
+    }
+  /**
+   * An approved spend was voided.
+   **/
+  | { name: 'AssetSpendVoided'; data: { index: number } }
+  /**
+   * A payment happened.
+   **/
+  | { name: 'Paid'; data: { index: number; paymentId: [] } }
+  /**
+   * A payment failed and can be retried.
+   **/
+  | { name: 'PaymentFailed'; data: { index: number; paymentId: [] } }
+  /**
+   * A spend was processed and removed from the storage. It might have been successfully
+   * paid or it may have expired.
+   **/
+  | { name: 'SpendProcessed'; data: { index: number } };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletCrowdloanRewardsEvent =
+  /**
+   * The initial payment of InitializationPayment % was paid
+   **/
+  | { name: 'InitialPaymentMade'; data: [AccountId20, bigint] }
+  /**
+   * Someone has proven they made a contribution and associated a native identity with it.
+   * Data is the relay account, native account and the total amount of _rewards_ that will be paid
+   **/
+  | { name: 'NativeIdentityAssociated'; data: [FixedBytes<32>, AccountId20, bigint] }
+  /**
+   * A contributor has claimed some rewards.
+   * Data is the account getting paid and the amount of rewards paid.
+   **/
+  | { name: 'RewardsPaid'; data: [AccountId20, bigint] }
+  /**
+   * A contributor has updated the reward address.
+   **/
+  | { name: 'RewardAddressUpdated'; data: [AccountId20, AccountId20] }
+  /**
+   * When initializing the reward vec an already initialized account was found
+   **/
+  | { name: 'InitializedAlreadyInitializedAccount'; data: [FixedBytes<32>, AccountId20 | undefined, bigint] }
+  /**
+   * When initializing the reward vec an already initialized account was found
+   **/
+  | { name: 'InitializedAccountWithNotEnoughContribution'; data: [FixedBytes<32>, AccountId20 | undefined, bigint] };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type CumulusPalletXcmpQueueEvent =
+  /**
+   * An HRMP message was sent to a sibling parachain.
+   **/
+  { name: 'XcmpMessageSent'; data: { messageHash: FixedBytes<32> } };
+
+/**
  * The `Event` enum of this pallet
  **/
 export type CumulusPalletXcmEvent =
@@ -9571,108 +10172,411 @@ export type PalletMigrationsEvent002 =
         /**
          * The index of the skipped migration within the [`Config::Migrations`] list.
          **/
-        index: number;
+        index: number;
+      };
+    }
+  /**
+   * A migration progressed.
+   **/
+  | {
+      name: 'MigrationAdvanced';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * A Migration completed.
+   **/
+  | {
+      name: 'MigrationCompleted';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * A Migration failed.
+   *
+   * This implies that the whole upgrade failed and governance intervention is required.
+   **/
+  | {
+      name: 'MigrationFailed';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * The set of historical migrations has been cleared.
+   **/
+  | {
+      name: 'HistoricCleared';
+      data: {
+        /**
+         * Should be passed to `clear_historic` in a successive call.
+         **/
+        nextCursor?: Bytes | undefined;
+      };
+    };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletRandomnessEvent =
+  | {
+      name: 'RandomnessRequestedBabeEpoch';
+      data: {
+        id: bigint;
+        refundAddress: H160;
+        contractAddress: H160;
+        fee: bigint;
+        gasLimit: bigint;
+        numWords: number;
+        salt: H256;
+        earliestEpoch: bigint;
+      };
+    }
+  | {
+      name: 'RandomnessRequestedLocal';
+      data: {
+        id: bigint;
+        refundAddress: H160;
+        contractAddress: H160;
+        fee: bigint;
+        gasLimit: bigint;
+        numWords: number;
+        salt: H256;
+        earliestBlock: number;
+      };
+    }
+  | { name: 'RequestFulfilled'; data: { id: bigint } }
+  | { name: 'RequestFeeIncreased'; data: { id: bigint; newFee: bigint } }
+  | { name: 'RequestExpirationExecuted'; data: { id: bigint } };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletBridgeGrandpaEvent =
+  /**
+   * Best finalized chain header has been updated to the header with given number and hash.
+   **/
+  {
+    name: 'UpdatedBestFinalizedHeader';
+    data: {
+      /**
+       * Number of the new best finalized header.
+       **/
+      number: number;
+
+      /**
+       * Hash of the new best finalized header.
+       **/
+      hash: H256;
+
+      /**
+       * The Grandpa info associated to the new best finalized header.
+       **/
+      grandpaInfo: BpHeaderChainHeaderFinalityInfo;
+    };
+  };
+
+export type BpHeaderChainHeaderFinalityInfo = {
+  finalityProof: BpHeaderChainJustificationGrandpaJustification;
+  newVerificationContext?: BpHeaderChainAuthoritySet | undefined;
+};
+
+export type BpHeaderChainAuthoritySet = { authorities: Array<[SpConsensusGrandpaAppPublic, bigint]>; setId: bigint };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletBridgeParachainsEvent =
+  /**
+   * The caller has provided head of parachain that the pallet is not configured to track.
+   **/
+  | {
+      name: 'UntrackedParachainRejected';
+      data: {
+        /**
+         * Identifier of the parachain that is not tracked by the pallet.
+         **/
+        parachain: BpPolkadotCoreParachainsParaId;
+      };
+    }
+  /**
+   * The caller has declared that he has provided given parachain head, but it is missing
+   * from the storage proof.
+   **/
+  | {
+      name: 'MissingParachainHead';
+      data: {
+        /**
+         * Identifier of the parachain with missing head.
+         **/
+        parachain: BpPolkadotCoreParachainsParaId;
+      };
+    }
+  /**
+   * The caller has provided parachain head hash that is not matching the hash read from the
+   * storage proof.
+   **/
+  | {
+      name: 'IncorrectParachainHeadHash';
+      data: {
+        /**
+         * Identifier of the parachain with incorrect head hast.
+         **/
+        parachain: BpPolkadotCoreParachainsParaId;
+
+        /**
+         * Specified parachain head hash.
+         **/
+        parachainHeadHash: H256;
+
+        /**
+         * Actual parachain head hash.
+         **/
+        actualParachainHeadHash: H256;
+      };
+    }
+  /**
+   * The caller has provided obsolete parachain head, which is already known to the pallet.
+   **/
+  | {
+      name: 'RejectedObsoleteParachainHead';
+      data: {
+        /**
+         * Identifier of the parachain with obsolete head.
+         **/
+        parachain: BpPolkadotCoreParachainsParaId;
+
+        /**
+         * Obsolete parachain head hash.
+         **/
+        parachainHeadHash: H256;
       };
     }
   /**
-   * A migration progressed.
+   * The caller has provided parachain head that exceeds the maximal configured head size.
    **/
   | {
-      name: 'MigrationAdvanced';
+      name: 'RejectedLargeParachainHead';
       data: {
         /**
-         * The index of the migration within the [`Config::Migrations`] list.
+         * Identifier of the parachain with rejected head.
          **/
-        index: number;
+        parachain: BpPolkadotCoreParachainsParaId;
 
         /**
-         * The number of blocks that this migration took so far.
+         * Parachain head hash.
          **/
-        took: number;
+        parachainHeadHash: H256;
+
+        /**
+         * Parachain head size.
+         **/
+        parachainHeadSize: number;
       };
     }
   /**
-   * A Migration completed.
+   * Parachain head has been updated.
    **/
   | {
-      name: 'MigrationCompleted';
+      name: 'UpdatedParachainHead';
       data: {
         /**
-         * The index of the migration within the [`Config::Migrations`] list.
+         * Identifier of the parachain that has been updated.
          **/
-        index: number;
+        parachain: BpPolkadotCoreParachainsParaId;
 
         /**
-         * The number of blocks that this migration took so far.
+         * Parachain head hash.
          **/
-        took: number;
+        parachainHeadHash: H256;
       };
-    }
+    };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletBridgeMessagesEvent =
   /**
-   * A Migration failed.
-   *
-   * This implies that the whole upgrade failed and governance intervention is required.
+   * Message has been accepted and is waiting to be delivered.
    **/
   | {
-      name: 'MigrationFailed';
+      name: 'MessageAccepted';
       data: {
         /**
-         * The index of the migration within the [`Config::Migrations`] list.
+         * Lane, which has accepted the message.
          **/
-        index: number;
+        laneId: BpMessagesLaneHashedLaneId;
 
         /**
-         * The number of blocks that this migration took so far.
+         * Nonce of accepted message.
          **/
-        took: number;
+        nonce: bigint;
       };
     }
   /**
-   * The set of historical migrations has been cleared.
+   * Messages have been received from the bridged chain.
+   **/
+  | { name: 'MessagesReceived'; data: BpMessagesReceivedMessages }
+  /**
+   * Messages in the inclusive range have been delivered to the bridged chain.
    **/
   | {
-      name: 'HistoricCleared';
+      name: 'MessagesDelivered';
       data: {
         /**
-         * Should be passed to `clear_historic` in a successive call.
+         * Lane for which the delivery has been confirmed.
          **/
-        nextCursor?: Bytes | undefined;
+        laneId: BpMessagesLaneHashedLaneId;
+
+        /**
+         * Delivered messages.
+         **/
+        messages: BpMessagesDeliveredMessages;
       };
     };
 
+export type BpMessagesReceivedMessages = {
+  lane: BpMessagesLaneHashedLaneId;
+  receiveResults: Array<[bigint, BpMessagesReceptionResult]>;
+};
+
+export type PalletXcmBridgeHubDispatcherXcmBlobMessageDispatchResult =
+  | 'InvalidPayload'
+  | 'Dispatched'
+  | 'NotDispatched';
+
+export type BpMessagesReceptionResult =
+  | { type: 'Dispatched'; value: BpRuntimeMessagesMessageDispatchResult }
+  | { type: 'InvalidNonce' }
+  | { type: 'TooManyUnrewardedRelayers' }
+  | { type: 'TooManyUnconfirmedMessages' };
+
+export type BpRuntimeMessagesMessageDispatchResult = {
+  unspentWeight: SpWeightsWeightV2Weight;
+  dispatchLevelResult: PalletXcmBridgeHubDispatcherXcmBlobMessageDispatchResult;
+};
+
+export type BpMessagesDeliveredMessages = { begin: bigint; end: bigint };
+
 /**
  * The `Event` enum of this pallet
  **/
-export type PalletRandomnessEvent =
+export type PalletXcmBridgeHubEvent =
+  /**
+   * The bridge between two locations has been opened.
+   **/
   | {
-      name: 'RandomnessRequestedBabeEpoch';
+      name: 'BridgeOpened';
       data: {
-        id: bigint;
-        refundAddress: H160;
-        contractAddress: H160;
-        fee: bigint;
-        gasLimit: bigint;
-        numWords: number;
-        salt: H256;
-        earliestEpoch: bigint;
+        /**
+         * Bridge identifier.
+         **/
+        bridgeId: BpXcmBridgeHubBridgeId;
+
+        /**
+         * Amount of deposit held.
+         **/
+        bridgeDeposit: bigint;
+
+        /**
+         * Universal location of local bridge endpoint.
+         **/
+        localEndpoint: StagingXcmV5Junctions;
+
+        /**
+         * Universal location of remote bridge endpoint.
+         **/
+        remoteEndpoint: StagingXcmV5Junctions;
+
+        /**
+         * Lane identifier.
+         **/
+        laneId: BpMessagesLaneHashedLaneId;
       };
     }
+  /**
+   * Bridge is going to be closed, but not yet fully pruned from the runtime storage.
+   **/
   | {
-      name: 'RandomnessRequestedLocal';
+      name: 'ClosingBridge';
       data: {
-        id: bigint;
-        refundAddress: H160;
-        contractAddress: H160;
-        fee: bigint;
-        gasLimit: bigint;
-        numWords: number;
-        salt: H256;
-        earliestBlock: number;
+        /**
+         * Bridge identifier.
+         **/
+        bridgeId: BpXcmBridgeHubBridgeId;
+
+        /**
+         * Lane identifier.
+         **/
+        laneId: BpMessagesLaneHashedLaneId;
+
+        /**
+         * Number of pruned messages during the close call.
+         **/
+        prunedMessages: bigint;
+
+        /**
+         * Number of enqueued messages that need to be pruned in follow up calls.
+         **/
+        enqueuedMessages: bigint;
       };
     }
-  | { name: 'RequestFulfilled'; data: { id: bigint } }
-  | { name: 'RequestFeeIncreased'; data: { id: bigint; newFee: bigint } }
-  | { name: 'RequestExpirationExecuted'; data: { id: bigint } };
+  /**
+   * Bridge has been closed and pruned from the runtime storage. It now may be reopened
+   * again by any participant.
+   **/
+  | {
+      name: 'BridgePruned';
+      data: {
+        /**
+         * Bridge identifier.
+         **/
+        bridgeId: BpXcmBridgeHubBridgeId;
+
+        /**
+         * Lane identifier.
+         **/
+        laneId: BpMessagesLaneHashedLaneId;
+
+        /**
+         * Amount of deposit released.
+         **/
+        bridgeDeposit: bigint;
+
+        /**
+         * Number of pruned messages during the close call.
+         **/
+        prunedMessages: bigint;
+      };
+    };
+
+export type BpXcmBridgeHubBridgeId = H256;
 
 export type FrameSystemLastRuntimeUpgradeInfo = { specVersion: number; specName: string };
 
@@ -9866,10 +10770,14 @@ export type PalletBalancesReserveData = { id: FixedBytes<4>; amount: bigint };
 
 export type FrameSupportTokensMiscIdAmount = { id: MoonbeamRuntimeRuntimeHoldReason; amount: bigint };
 
-export type MoonbeamRuntimeRuntimeHoldReason = { type: 'Preimage'; value: PalletPreimageHoldReason };
+export type MoonbeamRuntimeRuntimeHoldReason =
+  | { type: 'Preimage'; value: PalletPreimageHoldReason }
+  | { type: 'BridgeXcmOverMoonriver'; value: PalletXcmBridgeHubHoldReason };
 
 export type PalletPreimageHoldReason = 'Preimage';
 
+export type PalletXcmBridgeHubHoldReason = 'BridgeDeposit';
+
 export type FrameSupportTokensMiscIdAmount002 = { id: []; amount: bigint };
 
 /**
@@ -10464,24 +11372,10 @@ export type PalletMultisigError =
    **/
   | 'AlreadyStored';
 
-export type PalletMoonbeamLazyMigrationsForeignAssetForeignAssetMigrationStatus =
-  | { type: 'Idle' }
-  | { type: 'Migrating'; value: PalletMoonbeamLazyMigrationsForeignAssetForeignAssetMigrationInfo };
-
-export type PalletMoonbeamLazyMigrationsForeignAssetForeignAssetMigrationInfo = {
-  assetId: bigint;
-  remainingBalances: number;
-  remainingApprovals: number;
-};
-
 /**
  * The `Error` enum of this pallet.
  **/
 export type PalletMoonbeamLazyMigrationsError =
-  /**
-   * The limit cannot be zero
-   **/
-  | 'LimitCannotBeZero'
   /**
    * The contract already have metadata
    **/
@@ -10489,43 +11383,7 @@ export type PalletMoonbeamLazyMigrationsError =
   /**
    * Contract not exist
    **/
-  | 'ContractNotExist'
-  /**
-   * The symbol length exceeds the maximum allowed
-   **/
-  | 'SymbolTooLong'
-  /**
-   * The name length exceeds the maximum allowed
-   **/
-  | 'NameTooLong'
-  /**
-   * The asset type was not found
-   **/
-  | 'AssetTypeNotFound'
-  /**
-   * Asset not found
-   **/
-  | 'AssetNotFound'
-  /**
-   * The location of the asset was not found
-   **/
-  | 'LocationNotFound'
-  /**
-   * Migration is not finished yet
-   **/
-  | 'MigrationNotFinished'
-  /**
-   * No migration in progress
-   **/
-  | 'NoMigrationInProgress'
-  /**
-   * Fail to mint the foreign asset
-   **/
-  | 'MintFailed'
-  /**
-   * Fail to add an approval
-   **/
-  | 'ApprovalFailed';
+  | 'ContractNotExist';
 
 export type PalletEvmCodeMetadata = { size: bigint; hash: H256 };
 
@@ -11736,6 +12594,275 @@ export type PalletRandomnessError =
   | 'RandomnessResultDNE'
   | 'RandomnessResultNotFilled';
 
+export type BpRuntimeHeaderId = [number, H256];
+
+export type BpHeaderChainStoredHeaderData = { number: number; stateRoot: H256 };
+
+export type PalletBridgeGrandpaStorageTypesStoredAuthoritySet = {
+  authorities: Array<[SpConsensusGrandpaAppPublic, bigint]>;
+  setId: bigint;
+};
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletBridgeGrandpaError =
+  /**
+   * The given justification is invalid for the given header.
+   **/
+  | { name: 'InvalidJustification' }
+  /**
+   * The authority set from the underlying header chain is invalid.
+   **/
+  | { name: 'InvalidAuthoritySet' }
+  /**
+   * The header being imported is older than the best finalized header known to the pallet.
+   **/
+  | { name: 'OldHeader' }
+  /**
+   * The scheduled authority set change found in the header is unsupported by the pallet.
+   *
+   * This is the case for non-standard (e.g forced) authority set changes.
+   **/
+  | { name: 'UnsupportedScheduledChange' }
+  /**
+   * The pallet is not yet initialized.
+   **/
+  | { name: 'NotInitialized' }
+  /**
+   * The pallet has already been initialized.
+   **/
+  | { name: 'AlreadyInitialized' }
+  /**
+   * Too many authorities in the set.
+   **/
+  | { name: 'TooManyAuthoritiesInSet' }
+  /**
+   * Error generated by the `OwnedBridgeModule` trait.
+   **/
+  | { name: 'BridgeModule'; data: BpRuntimeOwnedBridgeModuleError }
+  /**
+   * The `current_set_id` argument of the `submit_finality_proof_ex` doesn't match
+   * the id of the current set, known to the pallet.
+   **/
+  | { name: 'InvalidAuthoritySetId' }
+  /**
+   * The submitter wanted free execution, but we can't fit more free transactions
+   * to the block.
+   **/
+  | { name: 'FreeHeadersLimitExceded' }
+  /**
+   * The submitter wanted free execution, but the difference between best known and
+   * bundled header numbers is below the `FreeHeadersInterval`.
+   **/
+  | { name: 'BelowFreeHeaderInterval' }
+  /**
+   * The header (and its finality) submission overflows hardcoded chain limits: size
+   * and/or weight are larger than expected.
+   **/
+  | { name: 'HeaderOverflowLimits' };
+
+export type BpRuntimeOwnedBridgeModuleError = 'Halted';
+
+export type BpParachainsParaInfo = { bestHeadHash: BpParachainsBestParaHeadHash; nextImportedHashPosition: number };
+
+export type BpParachainsBestParaHeadHash = { atRelayBlockNumber: number; headHash: H256 };
+
+export type BpParachainsParaStoredHeaderData = Bytes;
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletBridgeParachainsError =
+  /**
+   * Relay chain block hash is unknown to us.
+   **/
+  | { name: 'UnknownRelayChainBlock' }
+  /**
+   * The number of stored relay block is different from what the relayer has provided.
+   **/
+  | { name: 'InvalidRelayChainBlockNumber' }
+  /**
+   * Parachain heads storage proof is invalid.
+   **/
+  | { name: 'HeaderChainStorageProof'; data: BpHeaderChainHeaderChainError }
+  /**
+   * Error generated by the `OwnedBridgeModule` trait.
+   **/
+  | { name: 'BridgeModule'; data: BpRuntimeOwnedBridgeModuleError };
+
+export type BpHeaderChainHeaderChainError =
+  | { type: 'UnknownHeader' }
+  | { type: 'StorageProof'; value: BpRuntimeStorageProofStorageProofError };
+
+export type BpRuntimeStorageProofStorageProofError =
+  | 'UnableToGenerateTrieProof'
+  | 'InvalidProof'
+  | 'UnsortedEntries'
+  | 'UnavailableKey'
+  | 'EmptyVal'
+  | 'DecodeError'
+  | 'UnusedKey'
+  | 'StorageRootMismatch'
+  | 'StorageValueUnavailable'
+  | 'DuplicateNodes';
+
+export type BpMessagesInboundLaneData = {
+  relayers: Array<BpMessagesUnrewardedRelayer>;
+  lastConfirmedNonce: bigint;
+  state: BpMessagesLaneLaneState;
+};
+
+export type BpMessagesUnrewardedRelayer = { relayer: AccountId20; messages: BpMessagesDeliveredMessages };
+
+export type BpMessagesLaneLaneState = 'Opened' | 'Closed';
+
+export type BpMessagesOutboundLaneData = {
+  oldestUnprunedNonce: bigint;
+  latestReceivedNonce: bigint;
+  latestGeneratedNonce: bigint;
+  state: BpMessagesLaneLaneState;
+};
+
+export type BpMessagesMessageKey = { laneId: BpMessagesLaneHashedLaneId; nonce: bigint };
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletBridgeMessagesError =
+  /**
+   * Pallet is not in Normal operating mode.
+   **/
+  | { name: 'NotOperatingNormally' }
+  /**
+   * Error that is reported by the lanes manager.
+   **/
+  | { name: 'LanesManager'; data: PalletBridgeMessagesLanesManagerLanesManagerError }
+  /**
+   * Message has been treated as invalid by the pallet logic.
+   **/
+  | { name: 'MessageRejectedByPallet'; data: BpMessagesVerificationError }
+  /**
+   * The transaction brings too many messages.
+   **/
+  | { name: 'TooManyMessagesInTheProof' }
+  /**
+   * Invalid messages has been submitted.
+   **/
+  | { name: 'InvalidMessagesProof' }
+  /**
+   * Invalid messages delivery proof has been submitted.
+   **/
+  | { name: 'InvalidMessagesDeliveryProof' }
+  /**
+   * The relayer has declared invalid unrewarded relayers state in the
+   * `receive_messages_delivery_proof` call.
+   **/
+  | { name: 'InvalidUnrewardedRelayersState' }
+  /**
+   * The cumulative dispatch weight, passed by relayer is not enough to cover dispatch
+   * of all bundled messages.
+   **/
+  | { name: 'InsufficientDispatchWeight' }
+  /**
+   * Error confirming messages receival.
+   **/
+  | { name: 'ReceptionConfirmation'; data: PalletBridgeMessagesOutboundLaneReceptionConfirmationError }
+  /**
+   * Error generated by the `OwnedBridgeModule` trait.
+   **/
+  | { name: 'BridgeModule'; data: BpRuntimeOwnedBridgeModuleError };
+
+export type PalletBridgeMessagesLanesManagerLanesManagerError =
+  | 'InboundLaneAlreadyExists'
+  | 'OutboundLaneAlreadyExists'
+  | 'UnknownInboundLane'
+  | 'UnknownOutboundLane'
+  | 'ClosedInboundLane'
+  | 'ClosedOutboundLane'
+  | 'LaneDispatcherInactive';
+
+export type BpMessagesVerificationError =
+  | { type: 'EmptyMessageProof' }
+  | { type: 'HeaderChain'; value: BpHeaderChainHeaderChainError }
+  | { type: 'InboundLaneStorage'; value: BpRuntimeStorageProofStorageProofError }
+  | { type: 'InvalidMessageWeight' }
+  | { type: 'MessagesCountMismatch' }
+  | { type: 'MessageStorage'; value: BpRuntimeStorageProofStorageProofError }
+  | { type: 'MessageTooLarge' }
+  | { type: 'OutboundLaneStorage'; value: BpRuntimeStorageProofStorageProofError }
+  | { type: 'StorageProof'; value: BpRuntimeStorageProofStorageProofError }
+  | { type: 'Other' };
+
+export type PalletBridgeMessagesOutboundLaneReceptionConfirmationError =
+  | 'FailedToConfirmFutureMessages'
+  | 'EmptyUnrewardedRelayerEntry'
+  | 'NonConsecutiveUnrewardedRelayerEntries'
+  | 'TryingToConfirmMoreMessagesThanExpected';
+
+export type BpXcmBridgeHubBridge = {
+  bridgeOriginRelativeLocation: XcmVersionedLocation;
+  bridgeOriginUniversalLocation: XcmVersionedInteriorLocation;
+  bridgeDestinationUniversalLocation: XcmVersionedInteriorLocation;
+  state: BpXcmBridgeHubBridgeState;
+  bridgeOwnerAccount: AccountId20;
+  deposit: bigint;
+  laneId: BpMessagesLaneHashedLaneId;
+};
+
+export type BpXcmBridgeHubBridgeState = 'Opened' | 'Suspended' | 'Closed';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletXcmBridgeHubError =
+  /**
+   * Bridge locations error.
+   **/
+  | { name: 'BridgeLocations'; data: BpXcmBridgeHubBridgeLocationsError }
+  /**
+   * Invalid local bridge origin account.
+   **/
+  | { name: 'InvalidBridgeOriginAccount' }
+  /**
+   * The bridge is already registered in this pallet.
+   **/
+  | { name: 'BridgeAlreadyExists' }
+  /**
+   * The local origin already owns a maximal number of bridges.
+   **/
+  | { name: 'TooManyBridgesForLocalOrigin' }
+  /**
+   * Trying to close already closed bridge.
+   **/
+  | { name: 'BridgeAlreadyClosed' }
+  /**
+   * Lanes manager error.
+   **/
+  | { name: 'LanesManager'; data: PalletBridgeMessagesLanesManagerLanesManagerError }
+  /**
+   * Trying to access unknown bridge.
+   **/
+  | { name: 'UnknownBridge' }
+  /**
+   * The bridge origin can't pay the required amount for opening the bridge.
+   **/
+  | { name: 'FailedToReserveBridgeDeposit' }
+  /**
+   * The version of XCM location argument is unsupported.
+   **/
+  | { name: 'UnsupportedXcmVersion' };
+
+export type BpXcmBridgeHubBridgeLocationsError =
+  | 'NonUniversalLocation'
+  | 'InvalidBridgeOrigin'
+  | 'InvalidBridgeDestination'
+  | 'DestinationIsLocal'
+  | 'UnreachableDestination'
+  | 'UnsupportedDestinationLocation'
+  | 'UnsupportedXcmVersion'
+  | 'UnsupportedLaneIdType';
+
 export type FrameSystemExtensionsCheckNonZeroSender = {};
 
 export type FrameSystemExtensionsCheckSpecVersion = {};
@@ -11752,6 +12879,8 @@ export type FrameSystemExtensionsCheckWeight = {};
 
 export type PalletTransactionPaymentChargeTransactionPayment = bigint;
 
+export type MoonbeamRuntimeBridgeRejectObsoleteHeadersAndMessages = {};
+
 export type FrameMetadataHashExtensionCheckMetadataHash = { mode: FrameMetadataHashExtensionMode };
 
 export type FrameMetadataHashExtensionMode = 'Disabled' | 'Enabled';
@@ -11794,6 +12923,10 @@ export type SpRuntimeTransactionValidityUnknownTransaction =
   | { type: 'NoUnsignedValidator' }
   | { type: 'Custom'; value: number };
 
+export type BpMessagesOutboundMessageDetails = { nonce: bigint; dispatchWeight: SpWeightsWeightV2Weight; size: number };
+
+export type BpMessagesInboundMessageDetails = { dispatchWeight: SpWeightsWeightV2Weight };
+
 export type SpRuntimeBlock = { header: Header; extrinsics: Array<FpSelfContainedUncheckedExtrinsic> };
 
 export type SpRuntimeExtrinsicInclusionMode = 'AllExtrinsics' | 'OnlyInherents';
@@ -11925,4 +13058,8 @@ export type MoonbeamRuntimeRuntimeError =
   | { pallet: 'EmergencyParaXcm'; palletError: PalletEmergencyParaXcmError }
   | { pallet: 'MultiBlockMigrations'; palletError: PalletMigrationsError002 }
   | { pallet: 'PrecompileBenchmarks'; palletError: PalletPrecompileBenchmarksError }
-  | { pallet: 'Randomness'; palletError: PalletRandomnessError };
+  | { pallet: 'Randomness'; palletError: PalletRandomnessError }
+  | { pallet: 'BridgeKusamaGrandpa'; palletError: PalletBridgeGrandpaError }
+  | { pallet: 'BridgeKusamaParachains'; palletError: PalletBridgeParachainsError }
+  | { pallet: 'BridgeKusamaMessages'; palletError: PalletBridgeMessagesError }
+  | { pallet: 'BridgeXcmOverMoonriver'; palletError: PalletXcmBridgeHubError };