@dedot/chaintypes 0.279.0 → 0.280.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.279.0",
+  "version": "0.280.0",
   "description": "Types for substrate-based chains",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -25,7 +25,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "cc2448886a0bc935ad98c02f313c8190dfec824d",
+  "gitHead": "ab270266c830f6227d3077e8a64d57543c39f6fd",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/westend-asset-hub/consts.d.ts

@@ -651,6 +651,27 @@ export interface ChainConsts extends GenericChainConsts {
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `Recovery`'s constants
+   **/
+  recovery: {
+    /**
+     * Security deposit taken for each attempt that the initiator needs to place.
+     **/
+    securityDeposit: bigint;
+
+    /**
+     * DO NOT REDUCE THIS VALUE. Maximum number of friends per account config.
+     *
+     * Reducing this value can cause decoding errors in the bounded vectors.
+     **/
+    maxFriendsPerConfig: number;
+
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `Assets`'s constants
    **/
@@ -1148,6 +1169,15 @@ export interface ChainConsts extends GenericChainConsts {
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `AssetsHolder`'s constants
+   **/
+  assetsHolder: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `AssetRewards`'s constants
    **/

package/westend-asset-hub/errors.d.ts

@@ -989,6 +989,130 @@ export interface ChainErrors extends GenericChainErrors {
      **/
     [error: string]: GenericPalletError;
   };
+  /**
+   * Pallet `Recovery`'s errors
+   **/
+  recovery: {
+    /**
+     * This attempt is already fully approved and does not need any more votes.
+     **/
+    AlreadyApproved: GenericPalletError;
+
+    /**
+     * The recovery attempt has already been initiated.
+     **/
+    AlreadyInitiated: GenericPalletError;
+
+    /**
+     * The friend already voted for this attempt.
+     **/
+    AlreadyVoted: GenericPalletError;
+
+    /**
+     * The lost account has ongoing recovery attempts.
+     **/
+    HasOngoingAttempts: GenericPalletError;
+
+    /**
+     * The lost account cannot be a friend of itself.
+     **/
+    LostAccountInFriendGroup: GenericPalletError;
+
+    /**
+     * The account was already recovered by a group of equal or higher priority.
+     **/
+    HigherPriorityRecovered: GenericPalletError;
+
+    /**
+     * Cancel delay must be at least 1.
+     **/
+    NoCancelDelay: GenericPalletError;
+
+    /**
+     * This account does not have any friend groups.
+     **/
+    NoFriendGroups: GenericPalletError;
+
+    /**
+     * The friend group has no friends.
+     **/
+    NoFriends: GenericPalletError;
+
+    /**
+     * The lost account does not have any inheritor.
+     **/
+    NoInheritor: GenericPalletError;
+
+    /**
+     * Not enough friends approved this attempt.
+     **/
+    NotApproved: GenericPalletError;
+
+    /**
+     * The referenced recovery attempt was not found.
+     **/
+    NotAttempt: GenericPalletError;
+
+    /**
+     * The caller is not the initiator or the lost account.
+     **/
+    NotCanceller: GenericPalletError;
+
+    /**
+     * The caller is not a friend of the lost account.
+     **/
+    NotFriend: GenericPalletError;
+
+    /**
+     * A specific referenced friend group was not found.
+     **/
+    NotFriendGroup: GenericPalletError;
+
+    /**
+     * The caller is not the inheritor of the lost account.
+     **/
+    NotInheritor: GenericPalletError;
+
+    /**
+     * The cancel delay since the last approval or initialization has not yet passed.
+     **/
+    NotYetCancelable: GenericPalletError;
+
+    /**
+     * The inheritance delay of this attempt has not yet passed.
+     **/
+    NotYetInheritable: GenericPalletError;
+
+    /**
+     * Too many friend groups.
+     **/
+    TooManyFriendGroups: GenericPalletError;
+
+    /**
+     * The number of friends needed is greater than the number of friends.
+     **/
+    TooManyFriendsNeeded: GenericPalletError;
+
+    /**
+     * The number of friends needed is zero.
+     **/
+    NoFriendsNeeded: GenericPalletError;
+
+    /**
+     * The friends of a friend group are not sorted or not unique.
+     **/
+    FriendsNotSortedOrUnique: GenericPalletError;
+
+    /**
+     * Two friend groups have the same set of friends.
+     **/
+    DuplicateFriendGroups: GenericPalletError;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
+  };
   /**
    * Pallet `Assets`'s errors
    **/
@@ -2259,6 +2383,27 @@ export interface ChainErrors extends GenericChainErrors {
      **/
     AutoMappingEnabled: GenericPalletError;
 
+    /**
+     * A contract cannot be created at this address: it still has uncleared
+     * [`NativeDepositOf`] entries from a previously terminated contract that the deletion
+     * queue has not yet drained.
+     **/
+    PendingDepositCleanup: GenericPalletError;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
+  };
+  /**
+   * Pallet `AssetsHolder`'s errors
+   **/
+  assetsHolder: {
+    /**
+     * Number of holds on an account would exceed the count of `RuntimeHoldReason`.
+     **/
+    TooManyHolds: GenericPalletError;
+
     /**
      * Generic pallet error
      **/

package/westend-asset-hub/events.d.ts

@@ -1675,6 +1675,97 @@ export interface ChainEvents extends GenericChainEvents {
      **/
     [prop: string]: GenericPalletEvent;
   };
+  /**
+   * Pallet `Recovery`'s events
+   **/
+  recovery: {
+    /**
+     * A recovery attempt was approved by a friend.
+     **/
+    AttemptApproved: GenericPalletEvent<
+      'Recovery',
+      'AttemptApproved',
+      { lost: AccountId32; friendGroupIndex: number; friend: AccountId32 }
+    >;
+
+    /**
+     * A recovery attempt was canceled by either the lost account or the initiator.
+     **/
+    AttemptCanceled: GenericPalletEvent<
+      'Recovery',
+      'AttemptCanceled',
+      { lost: AccountId32; friendGroupIndex: number; canceler: AccountId32 }
+    >;
+
+    /**
+     * A recovery attempt was initiated by a friend.
+     **/
+    AttemptInitiated: GenericPalletEvent<
+      'Recovery',
+      'AttemptInitiated',
+      { lost: AccountId32; friendGroupIndex: number; initiator: AccountId32 }
+    >;
+
+    /**
+     * A recovery attempt was finished.
+     **/
+    AttemptFinished: GenericPalletEvent<
+      'Recovery',
+      'AttemptFinished',
+      {
+        lost: AccountId32;
+        friendGroupIndex: number;
+        inheritor: AccountId32;
+        previousInheritor?: AccountId32 | undefined;
+      }
+    >;
+
+    /**
+     * A recovery attempt was discarded because the account was already recovered by a
+     * friend group of equal or higher priority.
+     *
+     * The attempt is consumed (removed from storage) and its deposits are released, but
+     * the existing inheritor remains unchanged.
+     **/
+    AttemptDiscarded: GenericPalletEvent<
+      'Recovery',
+      'AttemptDiscarded',
+      { lost: AccountId32; friendGroupIndex: number; existingInheritor: AccountId32 }
+    >;
+
+    /**
+     * A recovery attempt was slashed by the lost account.
+     *
+     * The initiator will lose their security deposit.
+     **/
+    AttemptSlashed: GenericPalletEvent<'Recovery', 'AttemptSlashed', { lost: AccountId32; friendGroupIndex: number }>;
+
+    /**
+     * The friend groups of an account have been changed.
+     **/
+    FriendGroupsChanged: GenericPalletEvent<'Recovery', 'FriendGroupsChanged', { lost: AccountId32 }>;
+
+    /**
+     * The inheritor of a lost account was revoked by the lost account.
+     **/
+    InheritorRevoked: GenericPalletEvent<'Recovery', 'InheritorRevoked', { lost: AccountId32 }>;
+
+    /**
+     * A recovered account was controlled by its inheritor.
+     *
+     * Check the `call_result` to see if it was successful.
+     **/
+    RecoveredAccountControlled: GenericPalletEvent<
+      'Recovery',
+      'RecoveredAccountControlled',
+      { recovered: AccountId32; inheritor: AccountId32; callHash: H256; callResult: Result<[], DispatchError> }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent;
+  };
   /**
    * Pallet `Assets`'s events
    **/
@@ -3191,6 +3282,42 @@ export interface ChainEvents extends GenericChainEvents {
      **/
     [prop: string]: GenericPalletEvent;
   };
+  /**
+   * Pallet `AssetsHolder`'s events
+   **/
+  assetsHolder: {
+    /**
+     * `who`s balance on hold was increased by `amount`.
+     **/
+    Held: GenericPalletEvent<
+      'AssetsHolder',
+      'Held',
+      { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint }
+    >;
+
+    /**
+     * `who`s balance on hold was decreased by `amount`.
+     **/
+    Released: GenericPalletEvent<
+      'AssetsHolder',
+      'Released',
+      { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint }
+    >;
+
+    /**
+     * `who`s balance on hold was burned by `amount`.
+     **/
+    Burned: GenericPalletEvent<
+      'AssetsHolder',
+      'Burned',
+      { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent;
+  };
   /**
    * Pallet `AssetRewards`'s events
    **/

package/westend-asset-hub/index.d.ts

@@ -54,7 +54,7 @@ interface ChainKnownTypes extends GenericChainKnownTypes {
 
 /**
  * @name: WestendAssetHubApi
- * @specVersion: 1022005
+ * @specVersion: 1022006
  **/
 export interface WestendAssetHubApi extends GenericSubstrateApi {
   rpc: ChainJsonRpcApis;

package/westend-asset-hub/query.d.ts

@@ -77,6 +77,10 @@ import type {
   PalletProxyAnnouncement,
   AssetHubWestendRuntimeRuntimeParametersValue,
   AssetHubWestendRuntimeRuntimeParametersKey,
+  PalletRecoveryFriendGroup,
+  FrameSupportTokensFungibleHoldConsideration,
+  PalletRecoveryAttempt,
+  PalletRecoveryIdentifiedConsideration,
   PalletAssetsAssetDetails,
   PalletAssetsAssetAccount,
   PalletAssetsApproval,
@@ -101,6 +105,7 @@ import type {
   PalletAssetConversionPoolInfo,
   PalletReviveVmCodeInfo,
   PalletReviveStorageAccountInfo,
+  PalletReviveStorageDeletionQueueItem,
   PalletReviveStorageDeletionQueueManager,
   PalletReviveEvmApiRpcTypesGenBlock,
   PalletReviveEvmBlockHashReceiptGasInfo,
@@ -108,7 +113,6 @@ import type {
   PalletReviveDebugDebugSettings,
   PalletAssetRewardsPoolStakerInfo,
   PalletAssetRewardsPoolInfo,
-  FrameSupportTokensFungibleHoldConsideration,
   PalletPsmCircuitBreakerLevel,
   PalletStateTrieMigrationMigrationTask,
   PalletStateTrieMigrationMigrationLimits,
@@ -1563,6 +1567,58 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     [storage: string]: GenericStorageQuery;
   };
+  /**
+   * Pallet `Recovery`'s storage queries
+   **/
+  recovery: {
+    /**
+     * The friend groups of an account that can conduct recovery attempts.
+     *
+     * Modifying this storage is not possible while an account has ongoing recovery attempts.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[Array<PalletRecoveryFriendGroup>, FrameSupportTokensFungibleHoldConsideration] | undefined> =} callback
+     **/
+    friendGroups: GenericStorageQuery<
+      (
+        arg: AccountId32Like,
+      ) => [Array<PalletRecoveryFriendGroup>, FrameSupportTokensFungibleHoldConsideration] | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Ongoing recovery attempts of a lost account indexed by `(lost, friend_group)`.
+     *
+     * @param {[AccountId32Like, number]} arg
+     * @param {Callback<[PalletRecoveryAttempt, PalletRecoveryIdentifiedConsideration, bigint] | undefined> =} callback
+     **/
+    attempt: GenericStorageQuery<
+      (
+        arg: [AccountId32Like, number],
+      ) => [PalletRecoveryAttempt, PalletRecoveryIdentifiedConsideration, bigint] | undefined,
+      [AccountId32, number]
+    >;
+
+    /**
+     * The account that inherited full access to a lost account after successful recovery.
+     *
+     * The key is the lost account and the value is the inheritor account.
+     *
+     * NOTE: This could be a multisig or proxy account
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[number, AccountId32, PalletRecoveryIdentifiedConsideration] | undefined> =} callback
+     **/
+    inheritor: GenericStorageQuery<
+      (arg: AccountId32Like) => [number, AccountId32, PalletRecoveryIdentifiedConsideration] | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
   /**
    * Pallet `Assets`'s storage queries
    **/
@@ -2203,6 +2259,26 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     accountInfoOf: GenericStorageQuery<(arg: H160) => PalletReviveStorageAccountInfo | undefined, H160>;
 
+    /**
+     * Native currency storage deposit contributed by a user into a contract.
+     *
+     * Bounds how much native value the user can receive back from that contract's
+     * storage deposit.
+     *
+     * Keys: `(holder, contributor) -> amount`
+     * - `holder`: account on which the deposit is held (a contract, or the pallet's own account
+     * for code-upload deposits).
+     * - `contributor`: user that funded the deposit. Receives the native portion on refund, capped
+     * at this entry's `amount`.
+     *
+     * @param {[AccountId32Like, AccountId32Like]} arg
+     * @param {Callback<bigint> =} callback
+     **/
+    nativeDepositOf: GenericStorageQuery<
+      (arg: [AccountId32Like, AccountId32Like]) => bigint,
+      [AccountId32, AccountId32]
+    >;
+
     /**
      * The immutable data associated with a given account.
      *
@@ -2212,15 +2288,16 @@ export interface ChainStorage extends GenericChainStorage {
     immutableDataOf: GenericStorageQuery<(arg: H160) => Bytes | undefined, H160>;
 
     /**
-     * Evicted contracts that await child trie deletion.
+     * Terminated contracts that await lazy cleanup.
      *
-     * Child trie deletion is a heavy operation depending on the amount of storage items
-     * stored in said trie. Therefore this operation is performed lazily in `on_idle`.
+     * Each entry pairs a child trie ID with the contract account so that `on_idle` can
+     * drain both the child trie and any [`NativeDepositOf`] entries that named the contract
+     * as `holder`. Both can be arbitrarily large, so cleanup runs lazily in `on_idle`.
      *
      * @param {number} arg
-     * @param {Callback<Bytes | undefined> =} callback
+     * @param {Callback<PalletReviveStorageDeletionQueueItem | undefined> =} callback
      **/
-    deletionQueue: GenericStorageQuery<(arg: number) => Bytes | undefined, number>;
+    deletionQueue: GenericStorageQuery<(arg: number) => PalletReviveStorageDeletionQueueItem | undefined, number>;
 
     /**
      * A pair of monotonic counters used to track the latest contract marked for deletion
@@ -2309,6 +2386,34 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     [storage: string]: GenericStorageQuery;
   };
+  /**
+   * Pallet `AssetsHolder`'s storage queries
+   **/
+  assetsHolder: {
+    /**
+     * A map that stores holds applied on an account for a given AssetId.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<Array<FrameSupportTokensMiscIdAmount>> =} callback
+     **/
+    holds: GenericStorageQuery<
+      (arg: [number, AccountId32Like]) => Array<FrameSupportTokensMiscIdAmount>,
+      [number, AccountId32]
+    >;
+
+    /**
+     * A map that stores the current total balance on hold for every account on a given AssetId.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    balancesOnHold: GenericStorageQuery<(arg: [number, AccountId32Like]) => bigint | undefined, [number, AccountId32]>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
   /**
    * Pallet `AssetRewards`'s storage queries
    **/

package/westend-asset-hub/tx.d.ts

@@ -51,6 +51,7 @@ import type {
   AssetHubWestendRuntimeProxyType,
   PalletMetaTxMetaTx,
   AssetHubWestendRuntimeRuntimeParameters,
+  PalletRecoveryFriendGroup,
   PalletUniquesDestroyWitness,
   PalletNftsCollectionConfig,
   PalletNftsDestroyWitness,
@@ -3954,6 +3955,209 @@ export interface ChainTx<
      **/
     [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
   };
+  /**
+   * Pallet `Recovery`'s transaction calls
+   **/
+  recovery: {
+    /**
+     * Allows the inheritor of a recovered account to control it.
+     *
+     * The controller is not allowed to dispatch calls of the recovery pallet. Otherwise they
+     * could mess with the recovery configuration and possibly cancel or slash attempts from
+     * higher-priority friend groups.
+     *
+     * @param {MultiAddressLike} recovered
+     * @param {AssetHubWestendRuntimeRuntimeCallLike} call
+     **/
+    controlInheritedAccount: GenericTxCall<
+      (
+        recovered: MultiAddressLike,
+        call: AssetHubWestendRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'ControlInheritedAccount';
+            params: { recovered: MultiAddressLike; call: AssetHubWestendRuntimeRuntimeCallLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Revoke the inheritor of the calling (lost) account.
+     *
+     * This removes the inheritor entry and refunds the inheritor deposit. Can only be called
+     * by the lost account itself after it regains access.
+     *
+     **/
+    revokeInheritor: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'RevokeInheritor';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the friend groups of the calling account before it lost access.
+     *
+     * Cannot be used while there are ongoing recovery attempts. The friends of each group
+     * MUST be sorted and unique. Trying to insert two friend groups with the same set of
+     * friends will result in an error.
+     *
+     * A `FriendGroupsChanged` event is emitted only when the new friends groups differed from
+     * the old ones.
+     *
+     * @param {Array<PalletRecoveryFriendGroup>} friendGroups
+     **/
+    setFriendGroups: GenericTxCall<
+      (friendGroups: Array<PalletRecoveryFriendGroup>) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'SetFriendGroups';
+            params: { friendGroups: Array<PalletRecoveryFriendGroup> };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Attempt to recover a lost account by a friend within the given friend group.
+     *
+     * The initiator's approval is recorded automatically, so they do not need to call
+     * `approve_attempt` themselves.
+     *
+     * Once an account has been recovered by a friend group, no friend group of equal or lower
+     * priority can open a new attempt: it will fail with [`Error::HigherPriorityRecovered`].
+     * Only a strictly higher-priority group (lower numerical
+     * [`FriendGroup::inheritance_priority`]) can take over the inheritor.
+     *
+     * @param {MultiAddressLike} lost
+     * @param {number} friendGroupIndex
+     **/
+    initiateAttempt: GenericTxCall<
+      (
+        lost: MultiAddressLike,
+        friendGroupIndex: number,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'InitiateAttempt';
+            params: { lost: MultiAddressLike; friendGroupIndex: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Approve the recovery for a lost account.
+     *
+     * Must be called by a friend of the friend group that the recovery attempt belongs to that
+     * did not yet vote. Voting is only allowed until the threshold is reached.
+     * `finish_attempt` should be called after the last friend voted.
+     *
+     * @param {MultiAddressLike} lost
+     * @param {number} friendGroupIndex
+     **/
+    approveAttempt: GenericTxCall<
+      (
+        lost: MultiAddressLike,
+        friendGroupIndex: number,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'ApproveAttempt';
+            params: { lost: MultiAddressLike; friendGroupIndex: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Finish a recovery attempt and make the lost account accessible from the inheritor.
+     *
+     * Can be called by anyone who is willing to pay for the inheritor deposit.
+     *
+     * @param {MultiAddressLike} lost
+     * @param {number} friendGroupIndex
+     **/
+    finishAttempt: GenericTxCall<
+      (
+        lost: MultiAddressLike,
+        friendGroupIndex: number,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'FinishAttempt';
+            params: { lost: MultiAddressLike; friendGroupIndex: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * The lost account can cancel an attempt at any moment; the initiator, only after a delay.
+     *
+     * This will release the security deposit back to the initiator. The cancel delay must be
+     * respected if the initiator calls it to prevent it from front-running the lost account
+     * from slashing the attempt.
+     *
+     * @param {MultiAddressLike} lost
+     * @param {number} friendGroupIndex
+     **/
+    cancelAttempt: GenericTxCall<
+      (
+        lost: MultiAddressLike,
+        friendGroupIndex: number,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'CancelAttempt';
+            params: { lost: MultiAddressLike; friendGroupIndex: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Slash a malicious recovery attempt and burn the security deposit of the initiator.
+     *
+     * @param {number} friendGroupIndex
+     **/
+    slashAttempt: GenericTxCall<
+      (friendGroupIndex: number) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Recovery';
+          palletCall: {
+            name: 'SlashAttempt';
+            params: { friendGroupIndex: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
+  };
   /**
    * Pallet `Assets`'s transaction calls
    **/
@@ -12534,7 +12738,8 @@ export interface ChainTx<
      * for eras older than the active era.
      *
      * ## Parameters
-     * - `slash_era`: The staking era in which the slash was originally scheduled.
+     * - `slash_era`: The application era (`offence_era + SlashDeferDuration`), i.e. the key
+     * into [`UnappliedSlashes`].
      * - `slash_key`: A unique identifier for the slash, represented as a tuple:
      * - `stash`: The stash account of the validator being slashed.
      * - `slash_fraction`: The fraction of the stake that was slashed.

package/westend-asset-hub/types.d.ts

@@ -51,6 +51,7 @@ export type AssetHubWestendRuntimeRuntimeCall =
   | { pallet: 'Indices'; palletCall: PalletIndicesCall }
   | { pallet: 'MetaTx'; palletCall: PalletMetaTxCall }
   | { pallet: 'Parameters'; palletCall: PalletParametersCall }
+  | { pallet: 'Recovery'; palletCall: PalletRecoveryCall }
   | { pallet: 'Assets'; palletCall: PalletAssetsCall }
   | { pallet: 'Uniques'; palletCall: PalletUniquesCall }
   | { pallet: 'Nfts'; palletCall: PalletNftsCall }
@@ -105,6 +106,7 @@ export type AssetHubWestendRuntimeRuntimeCallLike =
   | { pallet: 'Indices'; palletCall: PalletIndicesCallLike }
   | { pallet: 'MetaTx'; palletCall: PalletMetaTxCallLike }
   | { pallet: 'Parameters'; palletCall: PalletParametersCallLike }
+  | { pallet: 'Recovery'; palletCall: PalletRecoveryCallLike }
   | { pallet: 'Assets'; palletCall: PalletAssetsCallLike }
   | { pallet: 'Uniques'; palletCall: PalletUniquesCallLike }
   | { pallet: 'Nfts'; palletCall: PalletNftsCallLike }
@@ -4462,6 +4464,153 @@ export type AssetHubWestendRuntimeDynamicParamsPusdParameters = {
 
 export type AssetHubWestendRuntimeDynamicParamsPusdMaximumIssuance = {};
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletRecoveryCall =
+  /**
+   * Allows the inheritor of a recovered account to control it.
+   *
+   * The controller is not allowed to dispatch calls of the recovery pallet. Otherwise they
+   * could mess with the recovery configuration and possibly cancel or slash attempts from
+   * higher-priority friend groups.
+   **/
+  | { name: 'ControlInheritedAccount'; params: { recovered: MultiAddress; call: AssetHubWestendRuntimeRuntimeCall } }
+  /**
+   * Revoke the inheritor of the calling (lost) account.
+   *
+   * This removes the inheritor entry and refunds the inheritor deposit. Can only be called
+   * by the lost account itself after it regains access.
+   **/
+  | { name: 'RevokeInheritor' }
+  /**
+   * Set the friend groups of the calling account before it lost access.
+   *
+   * Cannot be used while there are ongoing recovery attempts. The friends of each group
+   * MUST be sorted and unique. Trying to insert two friend groups with the same set of
+   * friends will result in an error.
+   *
+   * A `FriendGroupsChanged` event is emitted only when the new friends groups differed from
+   * the old ones.
+   **/
+  | { name: 'SetFriendGroups'; params: { friendGroups: Array<PalletRecoveryFriendGroup> } }
+  /**
+   * Attempt to recover a lost account by a friend within the given friend group.
+   *
+   * The initiator's approval is recorded automatically, so they do not need to call
+   * `approve_attempt` themselves.
+   *
+   * Once an account has been recovered by a friend group, no friend group of equal or lower
+   * priority can open a new attempt: it will fail with [`Error::HigherPriorityRecovered`].
+   * Only a strictly higher-priority group (lower numerical
+   * [`FriendGroup::inheritance_priority`]) can take over the inheritor.
+   **/
+  | { name: 'InitiateAttempt'; params: { lost: MultiAddress; friendGroupIndex: number } }
+  /**
+   * Approve the recovery for a lost account.
+   *
+   * Must be called by a friend of the friend group that the recovery attempt belongs to that
+   * did not yet vote. Voting is only allowed until the threshold is reached.
+   * `finish_attempt` should be called after the last friend voted.
+   **/
+  | { name: 'ApproveAttempt'; params: { lost: MultiAddress; friendGroupIndex: number } }
+  /**
+   * Finish a recovery attempt and make the lost account accessible from the inheritor.
+   *
+   * Can be called by anyone who is willing to pay for the inheritor deposit.
+   **/
+  | { name: 'FinishAttempt'; params: { lost: MultiAddress; friendGroupIndex: number } }
+  /**
+   * The lost account can cancel an attempt at any moment; the initiator, only after a delay.
+   *
+   * This will release the security deposit back to the initiator. The cancel delay must be
+   * respected if the initiator calls it to prevent it from front-running the lost account
+   * from slashing the attempt.
+   **/
+  | { name: 'CancelAttempt'; params: { lost: MultiAddress; friendGroupIndex: number } }
+  /**
+   * Slash a malicious recovery attempt and burn the security deposit of the initiator.
+   **/
+  | { name: 'SlashAttempt'; params: { friendGroupIndex: number } };
+
+export type PalletRecoveryCallLike =
+  /**
+   * Allows the inheritor of a recovered account to control it.
+   *
+   * The controller is not allowed to dispatch calls of the recovery pallet. Otherwise they
+   * could mess with the recovery configuration and possibly cancel or slash attempts from
+   * higher-priority friend groups.
+   **/
+  | {
+      name: 'ControlInheritedAccount';
+      params: { recovered: MultiAddressLike; call: AssetHubWestendRuntimeRuntimeCallLike };
+    }
+  /**
+   * Revoke the inheritor of the calling (lost) account.
+   *
+   * This removes the inheritor entry and refunds the inheritor deposit. Can only be called
+   * by the lost account itself after it regains access.
+   **/
+  | { name: 'RevokeInheritor' }
+  /**
+   * Set the friend groups of the calling account before it lost access.
+   *
+   * Cannot be used while there are ongoing recovery attempts. The friends of each group
+   * MUST be sorted and unique. Trying to insert two friend groups with the same set of
+   * friends will result in an error.
+   *
+   * A `FriendGroupsChanged` event is emitted only when the new friends groups differed from
+   * the old ones.
+   **/
+  | { name: 'SetFriendGroups'; params: { friendGroups: Array<PalletRecoveryFriendGroup> } }
+  /**
+   * Attempt to recover a lost account by a friend within the given friend group.
+   *
+   * The initiator's approval is recorded automatically, so they do not need to call
+   * `approve_attempt` themselves.
+   *
+   * Once an account has been recovered by a friend group, no friend group of equal or lower
+   * priority can open a new attempt: it will fail with [`Error::HigherPriorityRecovered`].
+   * Only a strictly higher-priority group (lower numerical
+   * [`FriendGroup::inheritance_priority`]) can take over the inheritor.
+   **/
+  | { name: 'InitiateAttempt'; params: { lost: MultiAddressLike; friendGroupIndex: number } }
+  /**
+   * Approve the recovery for a lost account.
+   *
+   * Must be called by a friend of the friend group that the recovery attempt belongs to that
+   * did not yet vote. Voting is only allowed until the threshold is reached.
+   * `finish_attempt` should be called after the last friend voted.
+   **/
+  | { name: 'ApproveAttempt'; params: { lost: MultiAddressLike; friendGroupIndex: number } }
+  /**
+   * Finish a recovery attempt and make the lost account accessible from the inheritor.
+   *
+   * Can be called by anyone who is willing to pay for the inheritor deposit.
+   **/
+  | { name: 'FinishAttempt'; params: { lost: MultiAddressLike; friendGroupIndex: number } }
+  /**
+   * The lost account can cancel an attempt at any moment; the initiator, only after a delay.
+   *
+   * This will release the security deposit back to the initiator. The cancel delay must be
+   * respected if the initiator calls it to prevent it from front-running the lost account
+   * from slashing the attempt.
+   **/
+  | { name: 'CancelAttempt'; params: { lost: MultiAddressLike; friendGroupIndex: number } }
+  /**
+   * Slash a malicious recovery attempt and burn the security deposit of the initiator.
+   **/
+  | { name: 'SlashAttempt'; params: { friendGroupIndex: number } };
+
+export type PalletRecoveryFriendGroup = {
+  friends: Array<AccountId32>;
+  friendsNeeded: number;
+  inheritor: AccountId32;
+  inheritanceDelay: number;
+  inheritancePriority: number;
+  cancelDelay: number;
+};
+
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
@@ -12451,7 +12600,8 @@ export type PalletStakingAsyncPalletCall =
    * for eras older than the active era.
    *
    * ## Parameters
-   * - `slash_era`: The staking era in which the slash was originally scheduled.
+   * - `slash_era`: The application era (`offence_era + SlashDeferDuration`), i.e. the key
+   * into [`UnappliedSlashes`].
    * - `slash_key`: A unique identifier for the slash, represented as a tuple:
    * - `stash`: The stash account of the validator being slashed.
    * - `slash_fraction`: The fraction of the stake that was slashed.
@@ -12933,7 +13083,8 @@ export type PalletStakingAsyncPalletCallLike =
    * for eras older than the active era.
    *
    * ## Parameters
-   * - `slash_era`: The staking era in which the slash was originally scheduled.
+   * - `slash_era`: The application era (`offence_era + SlashDeferDuration`), i.e. the key
+   * into [`UnappliedSlashes`].
    * - `slash_key`: A unique identifier for the slash, represented as a tuple:
    * - `stash`: The stash account of the validator being slashed.
    * - `slash_fraction`: The fraction of the stake that was slashed.
@@ -15806,6 +15957,7 @@ export type AssetHubWestendRuntimeRuntimeHoldReason =
   | { type: 'Preimage'; value: PalletPreimageHoldReason }
   | { type: 'Session'; value: PalletSessionHoldReason }
   | { type: 'PolkadotXcm'; value: PalletXcmHoldReason }
+  | { type: 'Recovery'; value: PalletRecoveryHoldReason }
   | { type: 'NftFractionalization'; value: PalletNftFractionalizationHoldReason }
   | { type: 'Revive'; value: PalletReviveHoldReason }
   | { type: 'AssetRewards'; value: PalletAssetRewardsHoldReason }
@@ -15822,6 +15974,12 @@ export type PalletSessionHoldReason = 'Keys';
 
 export type PalletXcmHoldReason = 'AuthorizeAlias';
 
+export type PalletRecoveryHoldReason =
+  | 'FriendGroupsStorage'
+  | 'AttemptStorage'
+  | 'InheritorStorage'
+  | 'SecurityDeposit';
+
 export type PalletNftFractionalizationHoldReason = 'Fractionalized';
 
 export type PalletReviveHoldReason = 'CodeUploadDepositReserve' | 'StorageDepositReserve' | 'AddressMapping';
@@ -15902,6 +16060,7 @@ export type AssetHubWestendRuntimeRuntimeEvent =
   | { pallet: 'Indices'; palletEvent: PalletIndicesEvent }
   | { pallet: 'MetaTx'; palletEvent: PalletMetaTxEvent }
   | { pallet: 'Parameters'; palletEvent: PalletParametersEvent }
+  | { pallet: 'Recovery'; palletEvent: PalletRecoveryEvent }
   | { pallet: 'Assets'; palletEvent: PalletAssetsEvent }
   | { pallet: 'Uniques'; palletEvent: PalletUniquesEvent }
   | { pallet: 'Nfts'; palletEvent: PalletNftsEvent }
@@ -15913,6 +16072,7 @@ export type AssetHubWestendRuntimeRuntimeEvent =
   | { pallet: 'ForeignAssetsFreezer'; palletEvent: PalletAssetsFreezerEvent002 }
   | { pallet: 'PoolAssetsFreezer'; palletEvent: PalletAssetsFreezerEvent }
   | { pallet: 'Revive'; palletEvent: PalletReviveEvent }
+  | { pallet: 'AssetsHolder'; palletEvent: PalletAssetsHolderEvent }
   | { pallet: 'AssetRewards'; palletEvent: PalletAssetRewardsEvent }
   | { pallet: 'Psm'; palletEvent: PalletPsmEvent }
   | { pallet: 'StateTrieMigration'; palletEvent: PalletStateTrieMigrationEvent }
@@ -17208,6 +17368,66 @@ export type AssetHubWestendRuntimeRuntimeParametersValue = {
 
 export type AssetHubWestendRuntimeDynamicParamsPusdParametersValue = { type: 'MaximumIssuance'; value: bigint };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletRecoveryEvent =
+  /**
+   * A recovery attempt was approved by a friend.
+   **/
+  | { name: 'AttemptApproved'; data: { lost: AccountId32; friendGroupIndex: number; friend: AccountId32 } }
+  /**
+   * A recovery attempt was canceled by either the lost account or the initiator.
+   **/
+  | { name: 'AttemptCanceled'; data: { lost: AccountId32; friendGroupIndex: number; canceler: AccountId32 } }
+  /**
+   * A recovery attempt was initiated by a friend.
+   **/
+  | { name: 'AttemptInitiated'; data: { lost: AccountId32; friendGroupIndex: number; initiator: AccountId32 } }
+  /**
+   * A recovery attempt was finished.
+   **/
+  | {
+      name: 'AttemptFinished';
+      data: {
+        lost: AccountId32;
+        friendGroupIndex: number;
+        inheritor: AccountId32;
+        previousInheritor?: AccountId32 | undefined;
+      };
+    }
+  /**
+   * A recovery attempt was discarded because the account was already recovered by a
+   * friend group of equal or higher priority.
+   *
+   * The attempt is consumed (removed from storage) and its deposits are released, but
+   * the existing inheritor remains unchanged.
+   **/
+  | { name: 'AttemptDiscarded'; data: { lost: AccountId32; friendGroupIndex: number; existingInheritor: AccountId32 } }
+  /**
+   * A recovery attempt was slashed by the lost account.
+   *
+   * The initiator will lose their security deposit.
+   **/
+  | { name: 'AttemptSlashed'; data: { lost: AccountId32; friendGroupIndex: number } }
+  /**
+   * The friend groups of an account have been changed.
+   **/
+  | { name: 'FriendGroupsChanged'; data: { lost: AccountId32 } }
+  /**
+   * The inheritor of a lost account was revoked by the lost account.
+   **/
+  | { name: 'InheritorRevoked'; data: { lost: AccountId32 } }
+  /**
+   * A recovered account was controlled by its inheritor.
+   *
+   * Check the `call_result` to see if it was successful.
+   **/
+  | {
+      name: 'RecoveredAccountControlled';
+      data: { recovered: AccountId32; inheritor: AccountId32; callHash: H256; callResult: Result<[], DispatchError> };
+    };
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -18140,6 +18360,32 @@ export type PalletReviveEvent =
    **/
   | { name: 'EthExtrinsicRevert'; data: { dispatchError: DispatchError } };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletAssetsHolderEvent =
+  /**
+   * `who`s balance on hold was increased by `amount`.
+   **/
+  | {
+      name: 'Held';
+      data: { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint };
+    }
+  /**
+   * `who`s balance on hold was decreased by `amount`.
+   **/
+  | {
+      name: 'Released';
+      data: { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint };
+    }
+  /**
+   * `who`s balance on hold was burned by `amount`.
+   **/
+  | {
+      name: 'Burned';
+      data: { who: AccountId32; assetId: number; reason: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint };
+    };
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -19894,9 +20140,12 @@ export type FrameSupportTokensMiscIdAmountRuntimeFreezeReason = {
 };
 
 export type AssetHubWestendRuntimeRuntimeFreezeReason =
+  | { type: 'Revive'; value: PalletReviveFreezeReason }
   | { type: 'AssetRewards'; value: PalletAssetRewardsFreezeReason }
   | { type: 'NominationPools'; value: PalletNominationPoolsFreezeReason };
 
+export type PalletReviveFreezeReason = 'PGasMinBalance';
+
 export type PalletAssetRewardsFreezeReason = 'Staked';
 
 export type PalletNominationPoolsFreezeReason = 'PoolMinBalance';
@@ -20658,6 +20907,120 @@ export type PalletMetaTxError =
    **/
   | 'InvalidLength';
 
+export type PalletRecoveryAttempt = {
+  friendGroupIndex: number;
+  initiator: AccountId32;
+  initBlock: number;
+  lastApprovalBlock: number;
+  approvals: PalletRecoveryBitfield;
+};
+
+export type PalletRecoveryBitfield = Array<number>;
+
+export type PalletRecoveryIdentifiedConsideration = {
+  depositor: AccountId32;
+  ticket?: FrameSupportTokensFungibleHoldConsideration | undefined;
+};
+
+export type FrameSupportStorageFootprint = { count: bigint; size: bigint };
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletRecoveryError =
+  /**
+   * This attempt is already fully approved and does not need any more votes.
+   **/
+  | 'AlreadyApproved'
+  /**
+   * The recovery attempt has already been initiated.
+   **/
+  | 'AlreadyInitiated'
+  /**
+   * The friend already voted for this attempt.
+   **/
+  | 'AlreadyVoted'
+  /**
+   * The lost account has ongoing recovery attempts.
+   **/
+  | 'HasOngoingAttempts'
+  /**
+   * The lost account cannot be a friend of itself.
+   **/
+  | 'LostAccountInFriendGroup'
+  /**
+   * The account was already recovered by a group of equal or higher priority.
+   **/
+  | 'HigherPriorityRecovered'
+  /**
+   * Cancel delay must be at least 1.
+   **/
+  | 'NoCancelDelay'
+  /**
+   * This account does not have any friend groups.
+   **/
+  | 'NoFriendGroups'
+  /**
+   * The friend group has no friends.
+   **/
+  | 'NoFriends'
+  /**
+   * The lost account does not have any inheritor.
+   **/
+  | 'NoInheritor'
+  /**
+   * Not enough friends approved this attempt.
+   **/
+  | 'NotApproved'
+  /**
+   * The referenced recovery attempt was not found.
+   **/
+  | 'NotAttempt'
+  /**
+   * The caller is not the initiator or the lost account.
+   **/
+  | 'NotCanceller'
+  /**
+   * The caller is not a friend of the lost account.
+   **/
+  | 'NotFriend'
+  /**
+   * A specific referenced friend group was not found.
+   **/
+  | 'NotFriendGroup'
+  /**
+   * The caller is not the inheritor of the lost account.
+   **/
+  | 'NotInheritor'
+  /**
+   * The cancel delay since the last approval or initialization has not yet passed.
+   **/
+  | 'NotYetCancelable'
+  /**
+   * The inheritance delay of this attempt has not yet passed.
+   **/
+  | 'NotYetInheritable'
+  /**
+   * Too many friend groups.
+   **/
+  | 'TooManyFriendGroups'
+  /**
+   * The number of friends needed is greater than the number of friends.
+   **/
+  | 'TooManyFriendsNeeded'
+  /**
+   * The number of friends needed is zero.
+   **/
+  | 'NoFriendsNeeded'
+  /**
+   * The friends of a friend group are not sorted or not unique.
+   **/
+  | 'FriendsNotSortedOrUnique'
+  /**
+   * Two friend groups have the same set of friends.
+   **/
+  | 'DuplicateFriendGroups';
+
 export type PalletAssetsAssetDetails = {
   owner: AccountId32;
   issuer: AccountId32;
@@ -21318,6 +21681,8 @@ export type PalletReviveStorageContractInfo = {
   immutableDataLen: number;
 };
 
+export type PalletReviveStorageDeletionQueueItem = { trieId: Bytes; accountId: AccountId32 };
+
 export type PalletReviveStorageDeletionQueueManager = { insertCounter: number; deleteCounter: number };
 
 export type PalletReviveEvmApiRpcTypesGenBlock = {
@@ -21791,7 +22156,22 @@ export type PalletReviveError =
   /**
    * Manual mapping is disabled when auto-mapping is enabled.
    **/
-  | 'AutoMappingEnabled';
+  | 'AutoMappingEnabled'
+  /**
+   * A contract cannot be created at this address: it still has uncleared
+   * [`NativeDepositOf`] entries from a previously terminated contract that the deletion
+   * queue has not yet drained.
+   **/
+  | 'PendingDepositCleanup';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletAssetsHolderError =
+  /**
+   * Number of holds on an account would exceed the count of `RuntimeHoldReason`.
+   **/
+  'TooManyHolds';
 
 export type PalletAssetRewardsPoolStakerInfo = { amount: bigint; rewards: bigint; rewardPerTokenPaid: bigint };
 
@@ -23478,6 +23858,7 @@ export type AssetHubWestendRuntimeRuntimeError =
   | { pallet: 'Proxy'; palletError: PalletProxyError }
   | { pallet: 'Indices'; palletError: PalletIndicesError }
   | { pallet: 'MetaTx'; palletError: PalletMetaTxError }
+  | { pallet: 'Recovery'; palletError: PalletRecoveryError }
   | { pallet: 'Assets'; palletError: PalletAssetsError }
   | { pallet: 'Uniques'; palletError: PalletUniquesError }
   | { pallet: 'Nfts'; palletError: PalletNftsError }
@@ -23489,6 +23870,7 @@ export type AssetHubWestendRuntimeRuntimeError =
   | { pallet: 'ForeignAssetsFreezer'; palletError: PalletAssetsFreezerError }
   | { pallet: 'PoolAssetsFreezer'; palletError: PalletAssetsFreezerError }
   | { pallet: 'Revive'; palletError: PalletReviveError }
+  | { pallet: 'AssetsHolder'; palletError: PalletAssetsHolderError }
   | { pallet: 'AssetRewards'; palletError: PalletAssetRewardsError }
   | { pallet: 'AssetsPrecompilesPermit'; palletError: PalletAssetsPrecompilesPermitPalletError }
   | { pallet: 'Psm'; palletError: PalletPsmError }

package/westend-asset-hub/view-functions.d.ts

@@ -1,13 +1,15 @@
 // Generated by dedot cli
 
 import type { GenericChainViewFunctions, GenericViewFunction } from 'dedot/types';
-import type { Bytes, AccountId32Like, Result, AccountId32, Perbill } from 'dedot/codecs';
+import type { Bytes, AccountId32Like, AccountId32, Result, Perbill } from 'dedot/codecs';
 import type {
   PalletMigrationsMbmIsOngoing,
   PalletMigrationsMbmProgress,
   PalletMigrationsMbmStatus,
   AssetHubWestendRuntimeRuntimeCallLike,
   AssetHubWestendRuntimeProxyType,
+  PalletRecoveryFriendGroup,
+  PalletRecoveryAttempt,
   PalletAssetsAssetDetails,
   PalletAssetsAssetMetadata,
   StagingXcmV5Location,
@@ -81,6 +83,50 @@ export interface ChainViewFunctions extends GenericChainViewFunctions {
      **/
     [name: string]: GenericViewFunction;
   };
+  /**
+   * Pallet `Recovery`'s view functions
+   **/
+  recovery: {
+    /**
+     * The provided block number that will be used to measure time.
+     **/
+    providedBlockNumber: GenericViewFunction<() => Promise<number>>;
+
+    /**
+     * The friend groups of an account that can initiate recovery attempts.
+     *
+     * @param {AccountId32Like} lost
+     **/
+    friendGroups: GenericViewFunction<(lost: AccountId32Like) => Promise<Array<PalletRecoveryFriendGroup>>>;
+
+    /**
+     * Ongoing recovery attempts for a lost account.
+     *
+     * @param {AccountId32Like} lost
+     **/
+    attempts: GenericViewFunction<
+      (lost: AccountId32Like) => Promise<Array<[PalletRecoveryFriendGroup, PalletRecoveryAttempt]>>
+    >;
+
+    /**
+     * The account that inherited full access to the lost account.
+     *
+     * @param {AccountId32Like} lost
+     **/
+    inheritor: GenericViewFunction<(lost: AccountId32Like) => Promise<AccountId32 | undefined>>;
+
+    /**
+     * All the recovered accounts that `heir` inherited access to.
+     *
+     * @param {AccountId32Like} heir
+     **/
+    inheritance: GenericViewFunction<(heir: AccountId32Like) => Promise<Array<AccountId32>>>;
+
+    /**
+     * Generic pallet view function
+     **/
+    [name: string]: GenericViewFunction;
+  };
   /**
    * Pallet `Assets`'s view functions
    **/