@dedot/chaintypes 0.269.0 → 0.271.0

package/basilisk/consts.d.ts

@@ -1112,6 +1112,15 @@ export interface ChainConsts extends GenericChainConsts {
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `CollatorRotation`'s constants
+   **/
+  collatorRotation: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `EmaOracle`'s constants
    **/

package/basilisk/events.d.ts

@@ -2993,6 +2993,21 @@ export interface ChainEvents extends GenericChainEvents {
      **/
     [prop: string]: GenericPalletEvent;
   };
+  /**
+   * Pallet `CollatorRotation`'s events
+   **/
+  collatorRotation: {
+    CollatorBenched: GenericPalletEvent<
+      'CollatorRotation',
+      'CollatorBenched',
+      { who: AccountId32; sessionIndex: number }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent;
+  };
   /**
    * Pallet `EmaOracle`'s events
    **/

package/basilisk/index.d.ts

@@ -44,7 +44,7 @@ interface ChainKnownTypes extends GenericChainKnownTypes {
 
 /**
  * @name: BasiliskApi
- * @specVersion: 130
+ * @specVersion: 132
  **/
 export interface BasiliskApi extends GenericSubstrateApi {
   rpc: ChainJsonRpcApis;

package/basilisk/types.d.ts

@@ -8813,6 +8813,7 @@ export type BasiliskRuntimeRuntimeEvent =
   | { pallet: 'CollatorRewards'; palletEvent: PalletCollatorRewardsEvent }
   | { pallet: 'Broadcast'; palletEvent: PalletBroadcastEvent }
   | { pallet: 'MultiBlockMigrations'; palletEvent: PalletMigrationsEvent }
+  | { pallet: 'CollatorRotation'; palletEvent: PalletCollatorRotationEvent }
   | { pallet: 'EmaOracle'; palletEvent: PalletEmaOracleEvent }
   | { pallet: 'Currencies'; palletEvent: PalletCurrenciesModuleEvent }
   | { pallet: 'Tokens'; palletEvent: OrmlTokensModuleEvent }
@@ -11122,6 +11123,11 @@ export type PalletMigrationsEvent =
       };
     };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletCollatorRotationEvent = { name: 'CollatorBenched'; data: { who: AccountId32; sessionIndex: number } };
+
 /**
  * The `Event` enum of this pallet
  **/

package/hydration/consts.d.ts

@@ -1926,11 +1926,6 @@ export interface ChainConsts extends GenericChainConsts {
    * Pallet `EmaOracle`'s constants
    **/
   emaOracle: {
-    /**
-     * Maximum allowed percentage difference for bifrost oracle price update
-     **/
-    maxAllowedPriceDifference: Permill;
-
     /**
      * Maximum number of unique oracle entries expected in one block.
      **/

package/hydration/errors.d.ts

@@ -4209,9 +4209,24 @@ export interface ChainErrors extends GenericChainErrors {
     AssetNotFound: GenericPalletError;
 
     /**
-     * The new price is outside the max allowed range
+     * The external source is already registered.
      **/
-    PriceOutsideAllowedRange: GenericPalletError;
+    SourceAlreadyRegistered: GenericPalletError;
+
+    /**
+     * The external source was not found.
+     **/
+    SourceNotFound: GenericPalletError;
+
+    /**
+     * The caller is not authorized for the given (source, pair).
+     **/
+    NotAuthorized: GenericPalletError;
+
+    /**
+     * Price must not be zero.
+     **/
+    PriceIsZero: GenericPalletError;
 
     /**
      * Generic pallet error

package/hydration/events.d.ts

@@ -30,6 +30,7 @@ import type {
   PalletConvictionVotingTally,
   FrameSupportDispatchPostDispatchInfo,
   SpRuntimeDispatchErrorWithPostInfo,
+  PalletDispatcherHyperbridgeCleanupStage,
   PalletAssetRegistryAssetType,
   HydradxRuntimeXcmAssetLocation,
   PalletClaimsEthereumAddress,
@@ -1611,6 +1612,38 @@ export interface ChainEvents extends GenericChainEvents {
       { callHash: H256; result: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo> }
     >;
 
+    /**
+     * Emitted each block when cleanup deletes a batch of keys.
+     **/
+    HyperbridgeCleanupProgress: GenericPalletEvent<
+      'Dispatcher',
+      'HyperbridgeCleanupProgress',
+      { stage: PalletDispatcherHyperbridgeCleanupStage; keysDeleted: number }
+    >;
+
+    /**
+     * Emitted when all keys in a stage are removed and cleanup advances.
+     **/
+    HyperbridgeCleanupStageCompleted: GenericPalletEvent<
+      'Dispatcher',
+      'HyperbridgeCleanupStageCompleted',
+      { stage: PalletDispatcherHyperbridgeCleanupStage }
+    >;
+
+    /**
+     * Emitted when all three stages are done and cleanup disables itself.
+     **/
+    HyperbridgeCleanupCompleted: GenericPalletEvent<'Dispatcher', 'HyperbridgeCleanupCompleted', null>;
+
+    /**
+     * Emitted when cleanup is paused or resumed via extrinsic.
+     **/
+    HyperbridgeCleanupStatusChanged: GenericPalletEvent<
+      'Dispatcher',
+      'HyperbridgeCleanupStatusChanged',
+      { paused: boolean }
+    >;
+
     /**
      * Generic pallet event
      **/
@@ -4566,6 +4599,34 @@ export interface ChainEvents extends GenericChainEvents {
       }
     >;
 
+    /**
+     * An external oracle source was registered.
+     **/
+    ExternalSourceRegistered: GenericPalletEvent<'EmaOracle', 'ExternalSourceRegistered', { source: FixedBytes<8> }>;
+
+    /**
+     * An external oracle source was removed.
+     **/
+    ExternalSourceRemoved: GenericPalletEvent<'EmaOracle', 'ExternalSourceRemoved', { source: FixedBytes<8> }>;
+
+    /**
+     * An account was authorized to update the given (source, pair).
+     **/
+    AuthorizedAccountAdded: GenericPalletEvent<
+      'EmaOracle',
+      'AuthorizedAccountAdded',
+      { source: FixedBytes<8>; pair: [number, number]; account: AccountId32 }
+    >;
+
+    /**
+     * An authorization was removed for the given (source, pair, account).
+     **/
+    AuthorizedAccountRemoved: GenericPalletEvent<
+      'EmaOracle',
+      'AuthorizedAccountRemoved',
+      { source: FixedBytes<8>; pair: [number, number]; account: AccountId32 }
+    >;
+
     /**
      * Generic pallet event
      **/

package/hydration/index.d.ts

@@ -51,7 +51,7 @@ interface ChainKnownTypes extends GenericChainKnownTypes {
 
 /**
  * @name: HydrationApi
- * @specVersion: 405
+ * @specVersion: 411
  **/
 export interface HydrationApi extends GenericSubstrateApi {
   rpc: ChainJsonRpcApis;

package/hydration/query.d.ts

@@ -56,6 +56,7 @@ import type {
   PalletStateTrieMigrationMigrationLimits,
   PalletConvictionVotingVoteVoting,
   PalletReferendaReferendumInfo,
+  PalletDispatcherHyperbridgeCleanupStage,
   EvmCoreErrorExitReason,
   PalletAssetRegistryAssetDetails,
   HydradxRuntimeXcmAssetLocation,
@@ -1187,6 +1188,20 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     extraGas: GenericStorageQuery<() => bigint>;
 
+    /**
+     * Whether the background ISMP storage cleanup is active.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    cleanupEnabled: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Current stage of the background ISMP storage cleanup.
+     *
+     * @param {Callback<PalletDispatcherHyperbridgeCleanupStage | undefined> =} callback
+     **/
+    cleanupStage: GenericStorageQuery<() => PalletDispatcherHyperbridgeCleanupStage | undefined>;
+
     /**
      *
      * @param {Callback<EvmCoreErrorExitReason | undefined> =} callback
@@ -3386,6 +3401,29 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     whitelistedAssets: GenericStorageQuery<() => Array<[FixedBytes<8>, [number, number]]>>;
 
+    /**
+     * Registered external oracle sources.
+     *
+     * @param {FixedBytes<8>} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    externalSources: GenericStorageQuery<(arg: FixedBytes<8>) => [] | undefined, FixedBytes<8>>;
+
+    /**
+     * Authorized accounts per (external oracle source, asset pair).
+     *
+     * Authorization is scoped per-pair so that a compromised external oracle account can
+     * only update the specific pairs it was authorized for, limiting DDoS blast radius.
+     * The asset pair is stored in `ordered_pair` form.
+     *
+     * @param {[FixedBytes<8>, [number, number], AccountId32Like]} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    authorizedAccounts: GenericStorageQuery<
+      (arg: [FixedBytes<8>, [number, number], AccountId32Like]) => [] | undefined,
+      [FixedBytes<8>, [number, number], AccountId32]
+    >;
+
     /**
      * Generic pallet storage query
      **/

package/hydration/tx.d.ts

@@ -5451,6 +5451,42 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Enable/pause the background ISMP storage cleanup. If enabled for the first time,
+     * starting from the first stage.
+     *
+     * @param {boolean} doPause
+     **/
+    pauseHyperbridgeCleanup: GenericTxCall<
+      (doPause: boolean) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Dispatcher';
+          palletCall: {
+            name: 'PauseHyperbridgeCleanup';
+            params: { doPause: boolean };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     *
+     * @param {HydradxRuntimeRuntimeCallLike} call
+     **/
+    dispatchWithFeePayer: GenericTxCall<
+      (call: HydradxRuntimeRuntimeCallLike) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Dispatcher';
+          palletCall: {
+            name: 'DispatchWithFeePayer';
+            params: { call: HydradxRuntimeRuntimeCallLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -13454,6 +13490,14 @@ export interface ChainTx<
    **/
   emaOracle: {
     /**
+     * Add an oracle to the whitelist so it is tracked by the pallet.
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: data source identifier
+     * - `assets`: the asset pair to track
+     *
+     * Emits `AddedToWhitelist` event when successful.
      *
      * @param {FixedBytes<8>} source
      * @param {[number, number]} assets
@@ -13475,6 +13519,14 @@ export interface ChainTx<
     >;
 
     /**
+     * Remove an oracle from the whitelist and delete all its stored entries.
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: data source identifier
+     * - `assets`: the asset pair to stop tracking
+     *
+     * Emits `RemovedFromWhitelist` event when successful.
      *
      * @param {FixedBytes<8>} source
      * @param {[number, number]} assets
@@ -13496,10 +13548,21 @@ export interface ChainTx<
     >;
 
     /**
+     * Update an oracle entry for BIFROST_SOURCE. Thin wrapper around `set_external_oracle`.
+     *
+     * Parameters:
+     * - `origin`: signed origin — must be authorized for the specific `(BIFROST_SOURCE, pair)`
+     * - `asset_a`: XCM location of the first asset
+     * - `asset_b`: XCM location of the second asset
+     * - `price`: price as `(numerator, denominator)`
+     *
+     * Emits `OracleUpdated` event on the next `on_finalize`.
      *
      * @param {XcmVersionedLocation} assetA
      * @param {XcmVersionedLocation} assetB
      * @param {[bigint, bigint]} price
+     *
+     * @deprecated Use `set_external_oracle` instead. Kept only for backward compatibility with bifrost and will be removed in the future
      **/
     updateBifrostOracle: GenericTxCall<
       (
@@ -13518,6 +13581,208 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Submit an oracle price update for an external source.
+     *
+     * The call is feeless on success (`Pays::No`).
+     *
+     * Parameters:
+     * - `origin`: signed origin — must be authorized for the specific `(source, pair)` via
+     * `add_authorized_account`
+     * - `source`: external source identifier (must be registered via `register_external_source`)
+     * - `asset_a`: XCM location of the first asset
+     * - `asset_b`: XCM location of the second asset
+     * - `price`: price as `(numerator, denominator)` — both must be non-zero
+     *
+     * Emits `OracleUpdated` event on the next `on_finalize`.
+     *
+     * @param {FixedBytes<8>} source
+     * @param {XcmVersionedLocation} assetA
+     * @param {XcmVersionedLocation} assetB
+     * @param {[bigint, bigint]} price
+     **/
+    setExternalOracle: GenericTxCall<
+      (
+        source: FixedBytes<8>,
+        assetA: XcmVersionedLocation,
+        assetB: XcmVersionedLocation,
+        price: [bigint, bigint],
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'SetExternalOracle';
+            params: {
+              source: FixedBytes<8>;
+              assetA: XcmVersionedLocation;
+              assetB: XcmVersionedLocation;
+              price: [bigint, bigint];
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Update an external oracle entry using local `AssetId`s directly.
+     *
+     * Cheaper variant of `set_external_oracle` for callers that already know the local
+     * AssetIds — skips the `VersionedLocation` → `AssetId` conversion and the
+     * `AssetRegistry::LocationAssets` storage read. Authorization shares the same
+     * `AuthorizedAccounts` storage as the location variant.
+     *
+     * Parameters:
+     * - `origin`: signed origin — must be authorized for the specific `(source, pair)` via
+     * `add_authorized_account`
+     * - `source`: external source identifier (must be registered via `register_external_source`)
+     * - `asset_a`: local AssetId of the first asset
+     * - `asset_b`: local AssetId of the second asset
+     * - `price`: price as `(numerator, denominator)` — both must be non-zero
+     *
+     * The call is feeless on success (`Pays::No`).
+     *
+     * Emits `OracleUpdated` event on the next `on_finalize`.
+     *
+     * @param {FixedBytes<8>} source
+     * @param {number} assetA
+     * @param {number} assetB
+     * @param {[bigint, bigint]} price
+     **/
+    setExternalOracleByIds: GenericTxCall<
+      (
+        source: FixedBytes<8>,
+        assetA: number,
+        assetB: number,
+        price: [bigint, bigint],
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'SetExternalOracleByIds';
+            params: { source: FixedBytes<8>; assetA: number; assetB: number; price: [bigint, bigint] };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Register a new external oracle source.
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: 8-byte source identifier to register
+     *
+     * Emits `ExternalSourceRegistered` event when successful.
+     *
+     * @param {FixedBytes<8>} source
+     **/
+    registerExternalSource: GenericTxCall<
+      (source: FixedBytes<8>) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'RegisterExternalSource';
+            params: { source: FixedBytes<8> };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Remove an external oracle source, its per-pair authorizations, and ALL oracle data it
+     * ever wrote (both committed `Oracles` rows and any in-flight `Accumulator` entries).
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: source identifier to remove
+     *
+     * Emits `ExternalSourceRemoved` event when successful.
+     *
+     * @param {FixedBytes<8>} source
+     **/
+    removeExternalSource: GenericTxCall<
+      (source: FixedBytes<8>) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'RemoveExternalSource';
+            params: { source: FixedBytes<8> };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Authorize `account` to submit oracle updates for a specific `(source, pair)`.
+     *
+     * Authorization is scoped per-pair so a compromised account can only update the
+     * pairs it was explicitly granted, limiting DDoS blast radius.
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: external source identifier (must already be registered)
+     * - `assets`: the asset pair to authorize — stored in ordered form
+     * - `account`: the account to authorize
+     *
+     * Emits `AuthorizedAccountAdded` event when successful.
+     *
+     * @param {FixedBytes<8>} source
+     * @param {[number, number]} assets
+     * @param {AccountId32Like} account
+     **/
+    addAuthorizedAccount: GenericTxCall<
+      (
+        source: FixedBytes<8>,
+        assets: [number, number],
+        account: AccountId32Like,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'AddAuthorizedAccount';
+            params: { source: FixedBytes<8>; assets: [number, number]; account: AccountId32Like };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Revoke oracle-update authorization for `account` on a specific `(source, pair)`.
+     *
+     * Parameters:
+     * - `origin`: `AuthorityOrigin`
+     * - `source`: external source identifier (must already be registered)
+     * - `assets`: the asset pair to revoke — matched in ordered form
+     * - `account`: the account to revoke
+     *
+     * Emits `AuthorizedAccountRemoved` event when successful.
+     *
+     * @param {FixedBytes<8>} source
+     * @param {[number, number]} assets
+     * @param {AccountId32Like} account
+     **/
+    removeAuthorizedAccount: GenericTxCall<
+      (
+        source: FixedBytes<8>,
+        assets: [number, number],
+        account: AccountId32Like,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'EmaOracle';
+          palletCall: {
+            name: 'RemoveAuthorizedAccount';
+            params: { source: FixedBytes<8>; assets: [number, number]; account: AccountId32Like };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/