@dedot/chaintypes 0.205.0 → 0.206.0

package/basilisk/runtime.d.ts

@@ -2,59 +2,112 @@
 
 import type { GenericRuntimeApis, GenericRuntimeApiMethod } from 'dedot/types';
 import type {
-  Option,
-  OpaqueMetadata,
-  ApplyExtrinsicResult,
-  OpaqueExtrinsicLike,
-  CheckInherentsResult,
-  Block,
-  InherentData,
-  OpaqueExtrinsic,
+  RuntimeVersion,
   Header,
-  TransactionValidity,
-  TransactionSource,
-  BlockHash,
+  DispatchError,
+  Result,
+  UncheckedExtrinsicLike,
+  UncheckedExtrinsic,
+  H256,
   Bytes,
   BytesLike,
-  KeyTypeId,
-  Nonce,
   AccountId32Like,
-  RuntimeDispatchInfo,
-  FeeDetails,
-  Balance,
-  Weight,
-  Result,
-  Text,
+  AccountId32,
 } from 'dedot/codecs';
+import type {
+  SpRuntimeBlock,
+  SpRuntimeExtrinsicInclusionMode,
+  SpCoreOpaqueMetadata,
+  SpRuntimeTransactionValidityTransactionValidityError,
+  SpInherentsInherentData,
+  SpInherentsCheckInherentsResult,
+  SpRuntimeTransactionValidityValidTransaction,
+  SpRuntimeTransactionValidityTransactionSource,
+  SpCoreCryptoKeyTypeId,
+  SpConsensusSlotsSlotDuration,
+  SpConsensusAuraSr25519AppSr25519Public,
+  CumulusPrimitivesCoreCollationInfo,
+  PalletTransactionPaymentRuntimeDispatchInfo,
+  PalletTransactionPaymentFeeDetails,
+  SpWeightsWeightV2Weight,
+  XcmVersionedAssetId,
+  XcmRuntimeApisFeesError,
+  XcmVersionedXcm,
+  XcmVersionedAssets,
+  XcmVersionedLocation,
+  XcmRuntimeApisDryRunCallDryRunEffects,
+  XcmRuntimeApisDryRunError,
+  BasiliskRuntimeOriginCaller,
+  BasiliskRuntimeRuntimeCallLike,
+  XcmRuntimeApisDryRunXcmDryRunEffects,
+  XcmRuntimeApisConversionsError,
+  SpConsensusSlotsSlot,
+} from './types.js';
 
 export interface RuntimeApis extends GenericRuntimeApis {
+  /**
+   * @runtimeapi: Core - 0xdf6acb689907609b
+   **/
+  core: {
+    /**
+     * Returns the version of the runtime.
+     *
+     * @callname: Core_version
+     **/
+    version: GenericRuntimeApiMethod<() => Promise<RuntimeVersion>>;
+
+    /**
+     * Execute the given block.
+     *
+     * @callname: Core_execute_block
+     * @param {SpRuntimeBlock} block
+     **/
+    executeBlock: GenericRuntimeApiMethod<(block: SpRuntimeBlock) => Promise<[]>>;
+
+    /**
+     * Initialize a block with the given header and return the runtime executive mode.
+     *
+     * @callname: Core_initialize_block
+     * @param {Header} header
+     **/
+    initializeBlock: GenericRuntimeApiMethod<(header: Header) => Promise<SpRuntimeExtrinsicInclusionMode>>;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
   /**
    * @runtimeapi: Metadata - 0x37e397fc7c91f5e4
-   * @version: 2
    **/
   metadata: {
+    /**
+     * Returns the metadata of a runtime.
+     *
+     * @callname: Metadata_metadata
+     **/
+    metadata: GenericRuntimeApiMethod<() => Promise<SpCoreOpaqueMetadata>>;
+
     /**
      * Returns the metadata at a given version.
      *
+     * If the given `version` isn't supported, this will return `None`.
+     * Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime.
+     *
      * @callname: Metadata_metadata_at_version
      * @param {number} version
      **/
-    metadataAtVersion: GenericRuntimeApiMethod<(version: number) => Promise<Option<OpaqueMetadata>>>;
+    metadataAtVersion: GenericRuntimeApiMethod<(version: number) => Promise<SpCoreOpaqueMetadata | undefined>>;
 
     /**
      * Returns the supported metadata versions.
      *
+     * This can be used to call `metadata_at_version`.
+     *
      * @callname: Metadata_metadata_versions
      **/
     metadataVersions: GenericRuntimeApiMethod<() => Promise<Array<number>>>;
 
-    /**
-     * Returns the metadata of a runtime.
-     *
-     * @callname: Metadata_metadata
-     **/
-    metadata: GenericRuntimeApiMethod<() => Promise<OpaqueMetadata>>;
-
     /**
      * Generic runtime api call
      **/
@@ -62,36 +115,50 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: BlockBuilder - 0x40fe3ad401f8959a
-   * @version: 6
    **/
   blockBuilder: {
     /**
+     * Apply the given extrinsic.
+     *
+     * Returns an inclusion outcome which specifies if this extrinsic is included in
+     * this block or not.
      *
      * @callname: BlockBuilder_apply_extrinsic
-     * @param {OpaqueExtrinsicLike} extrinsic
+     * @param {UncheckedExtrinsicLike} extrinsic
      **/
-    applyExtrinsic: GenericRuntimeApiMethod<(extrinsic: OpaqueExtrinsicLike) => Promise<ApplyExtrinsicResult>>;
+    applyExtrinsic: GenericRuntimeApiMethod<
+      (
+        extrinsic: UncheckedExtrinsicLike,
+      ) => Promise<Result<Result<[], DispatchError>, SpRuntimeTransactionValidityTransactionValidityError>>
+    >;
 
     /**
+     * Finish the current block.
      *
-     * @callname: BlockBuilder_check_inherents
-     * @param {Block} block
-     * @param {InherentData} data
+     * @callname: BlockBuilder_finalize_block
      **/
-    checkInherents: GenericRuntimeApiMethod<(block: Block, data: InherentData) => Promise<CheckInherentsResult>>;
+    finalizeBlock: GenericRuntimeApiMethod<() => Promise<Header>>;
 
     /**
+     * Generate inherent extrinsics. The inherent data will vary from chain to chain.
      *
      * @callname: BlockBuilder_inherent_extrinsics
-     * @param {InherentData} inherent
+     * @param {SpInherentsInherentData} inherent
      **/
-    inherentExtrinsics: GenericRuntimeApiMethod<(inherent: InherentData) => Promise<Array<OpaqueExtrinsic>>>;
+    inherentExtrinsics: GenericRuntimeApiMethod<
+      (inherent: SpInherentsInherentData) => Promise<Array<UncheckedExtrinsic>>
+    >;
 
     /**
+     * Check that the inherents are valid. The inherent data will vary from chain to chain.
      *
-     * @callname: BlockBuilder_finalize_block
+     * @callname: BlockBuilder_check_inherents
+     * @param {SpRuntimeBlock} block
+     * @param {SpInherentsInherentData} data
      **/
-    finalizeBlock: GenericRuntimeApiMethod<() => Promise<Header>>;
+    checkInherents: GenericRuntimeApiMethod<
+      (block: SpRuntimeBlock, data: SpInherentsInherentData) => Promise<SpInherentsCheckInherentsResult>
+    >;
 
     /**
      * Generic runtime api call
@@ -100,19 +167,32 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: TaggedTransactionQueue - 0xd2bc9897eed08f15
-   * @version: 3
    **/
   taggedTransactionQueue: {
     /**
      * Validate the transaction.
      *
+     * This method is invoked by the transaction pool to learn details about given transaction.
+     * The implementation should make sure to verify the correctness of the transaction
+     * against current state. The given `block_hash` corresponds to the hash of the block
+     * that is used as current state.
+     *
+     * Note that this call may be performed by the pool multiple times and transactions
+     * might be verified in any possible order.
+     *
      * @callname: TaggedTransactionQueue_validate_transaction
-     * @param {TransactionSource} source
-     * @param {OpaqueExtrinsicLike} tx
-     * @param {BlockHash} blockHash
+     * @param {SpRuntimeTransactionValidityTransactionSource} source
+     * @param {UncheckedExtrinsicLike} tx
+     * @param {H256} block_hash
      **/
     validateTransaction: GenericRuntimeApiMethod<
-      (source: TransactionSource, tx: OpaqueExtrinsicLike, blockHash: BlockHash) => Promise<TransactionValidity>
+      (
+        source: SpRuntimeTransactionValidityTransactionSource,
+        tx: UncheckedExtrinsicLike,
+        blockHash: H256,
+      ) => Promise<
+        Result<SpRuntimeTransactionValidityValidTransaction, SpRuntimeTransactionValidityTransactionValidityError>
+      >
     >;
 
     /**
@@ -122,7 +202,6 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: OffchainWorkerApi - 0xf78b278be53f454c
-   * @version: 2
    **/
   offchainWorkerApi: {
     /**
@@ -140,7 +219,6 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: SessionKeys - 0xab3c0572291feb8b
-   * @version: 1
    **/
   sessionKeys: {
     /**
@@ -153,19 +231,66 @@ export interface RuntimeApis extends GenericRuntimeApis {
      * Returns the concatenated SCALE encoded public keys.
      *
      * @callname: SessionKeys_generate_session_keys
-     * @param {Option<BytesLike>} seed
+     * @param {BytesLike | undefined} seed
      **/
-    generateSessionKeys: GenericRuntimeApiMethod<(seed?: Option<BytesLike>) => Promise<Bytes>>;
+    generateSessionKeys: GenericRuntimeApiMethod<(seed?: BytesLike | undefined) => Promise<Bytes>>;
 
     /**
-     * Decode the given public session key
+     * Decode the given public session keys.
      *
-     * Returns the list of public raw public keys + key typ
+     * Returns the list of public raw public keys + key type.
      *
      * @callname: SessionKeys_decode_session_keys
      * @param {BytesLike} encoded
      **/
-    decodeSessionKeys: GenericRuntimeApiMethod<(encoded: BytesLike) => Promise<Option<Array<[Bytes, KeyTypeId]>>>>;
+    decodeSessionKeys: GenericRuntimeApiMethod<
+      (encoded: BytesLike) => Promise<Array<[Bytes, SpCoreCryptoKeyTypeId]> | undefined>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: AuraApi - 0xdd718d5cc53262d4
+   **/
+  auraApi: {
+    /**
+     * Returns the slot duration for Aura.
+     *
+     * Currently, only the value provided by this type at genesis will be used.
+     *
+     * @callname: AuraApi_slot_duration
+     **/
+    slotDuration: GenericRuntimeApiMethod<() => Promise<SpConsensusSlotsSlotDuration>>;
+
+    /**
+     * Return the current set of authorities.
+     *
+     * @callname: AuraApi_authorities
+     **/
+    authorities: GenericRuntimeApiMethod<() => Promise<Array<SpConsensusAuraSr25519AppSr25519Public>>>;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: CollectCollationInfo - 0xea93e3f16f3d6962
+   **/
+  collectCollationInfo: {
+    /**
+     * Collect information about a collation.
+     *
+     * The given `header` is the header of the built block for that
+     * we are collecting the collation info for.
+     *
+     * @callname: CollectCollationInfo_collect_collation_info
+     * @param {Header} header
+     **/
+    collectCollationInfo: GenericRuntimeApiMethod<(header: Header) => Promise<CumulusPrimitivesCoreCollationInfo>>;
 
     /**
      * Generic runtime api call
@@ -174,16 +299,15 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: AccountNonceApi - 0xbc9d89904f5b923f
-   * @version: 1
    **/
   accountNonceApi: {
     /**
-     * The API to query account nonce (aka transaction index)
+     * Get current account nonce of given `AccountId`.
      *
      * @callname: AccountNonceApi_account_nonce
-     * @param {AccountId32Like} accountId
+     * @param {AccountId32Like} account
      **/
-    accountNonce: GenericRuntimeApiMethod<(accountId: AccountId32Like) => Promise<Nonce>>;
+    accountNonce: GenericRuntimeApiMethod<(account: AccountId32Like) => Promise<number>>;
 
     /**
      * Generic runtime api call
@@ -192,42 +316,41 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: TransactionPaymentApi - 0x37c8bb1350a9a2a8
-   * @version: 4
    **/
   transactionPaymentApi: {
     /**
-     * The transaction info
      *
      * @callname: TransactionPaymentApi_query_info
-     * @param {OpaqueExtrinsicLike} uxt
+     * @param {UncheckedExtrinsicLike} uxt
      * @param {number} len
      **/
-    queryInfo: GenericRuntimeApiMethod<(uxt: OpaqueExtrinsicLike, len: number) => Promise<RuntimeDispatchInfo>>;
+    queryInfo: GenericRuntimeApiMethod<
+      (uxt: UncheckedExtrinsicLike, len: number) => Promise<PalletTransactionPaymentRuntimeDispatchInfo>
+    >;
 
     /**
-     * The transaction fee details
      *
      * @callname: TransactionPaymentApi_query_fee_details
-     * @param {OpaqueExtrinsicLike} uxt
+     * @param {UncheckedExtrinsicLike} uxt
      * @param {number} len
      **/
-    queryFeeDetails: GenericRuntimeApiMethod<(uxt: OpaqueExtrinsicLike, len: number) => Promise<FeeDetails>>;
+    queryFeeDetails: GenericRuntimeApiMethod<
+      (uxt: UncheckedExtrinsicLike, len: number) => Promise<PalletTransactionPaymentFeeDetails>
+    >;
 
     /**
-     * Query the output of the current LengthToFee given some input
      *
-     * @callname: TransactionPaymentApi_query_length_to_fee
-     * @param {number} length
+     * @callname: TransactionPaymentApi_query_weight_to_fee
+     * @param {SpWeightsWeightV2Weight} weight
      **/
-    queryLengthToFee: GenericRuntimeApiMethod<(length: number) => Promise<Balance>>;
+    queryWeightToFee: GenericRuntimeApiMethod<(weight: SpWeightsWeightV2Weight) => Promise<bigint>>;
 
     /**
-     * Query the output of the current WeightToFee given some input
      *
-     * @callname: TransactionPaymentApi_query_weight_to_fee
-     * @param {Weight} weight
+     * @callname: TransactionPaymentApi_query_length_to_fee
+     * @param {number} length
      **/
-    queryWeightToFee: GenericRuntimeApiMethod<(weight: Weight) => Promise<Balance>>;
+    queryLengthToFee: GenericRuntimeApiMethod<(length: number) => Promise<bigint>>;
 
     /**
      * Generic runtime api call
@@ -236,32 +359,214 @@ export interface RuntimeApis extends GenericRuntimeApis {
   };
   /**
    * @runtimeapi: GenesisBuilder - 0xfbc577b9d747efd6
-   * @version: 1
    **/
   genesisBuilder: {
     /**
-     * Creates the default `GenesisConfig` and returns it as a JSON blob.
+     * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the
+     * storage.
+     *
+     * In the case of a FRAME-based runtime, this function deserializes the full
+     * `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage. If the
+     * provided JSON blob is incorrect or incomplete or the deserialization fails, an error
+     * is returned.
      *
-     * This function instantiates the default `GenesisConfig` struct for the runtime and serializes it into a JSON
-     * blob. It returns a `Vec<u8>` containing the JSON representation of the default `GenesisConfig`.
+     * Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no
+     * defaults will be used.
      *
-     * @callname: GenesisBuilder_create_default_config
+     * @callname: GenesisBuilder_build_state
+     * @param {BytesLike} json
      **/
-    createDefaultConfig: GenericRuntimeApiMethod<() => Promise<Bytes>>;
+    buildState: GenericRuntimeApiMethod<(json: BytesLike) => Promise<Result<[], string>>>;
 
     /**
-     * Build `GenesisConfig` from a JSON blob not using any defaults and store it in the storage.
+     * Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by
+     * `id`.
      *
-     * This function deserializes the full `GenesisConfig` from the given JSON blob and puts it into the storage.
-     * If the provided JSON blob is incorrect or incomplete or the deserialization fails, an error is returned.
-     * It is recommended to log any errors encountered during the process.
+     * If `id` is `None` the function should return JSON blob representation of the default
+     * `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default
+     * `RuntimeGenesisConfig`.
      *
-     * Please note that provided json blob must contain all `GenesisConfig` fields, no defaults will be used.
+     * Otherwise function returns a JSON representation of the built-in, named
+     * `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does not
+     * exist. Returned `Vec<u8>` contains bytes of JSON blob (patch) which comprises a list of
+     * (potentially nested) key-value pairs that are intended for customizing the default
+     * runtime genesis config. The patch shall be merged (rfc7386) with the JSON representation
+     * of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can
+     * be used in `build_state` method.
      *
-     * @callname: GenesisBuilder_build_config
-     * @param {BytesLike} json
+     * @callname: GenesisBuilder_get_preset
+     * @param {string | undefined} id
+     **/
+    getPreset: GenericRuntimeApiMethod<(id?: string | undefined) => Promise<Bytes | undefined>>;
+
+    /**
+     * Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets.
+     *
+     * The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If
+     * no named presets are provided by the runtime the list is empty.
+     *
+     * @callname: GenesisBuilder_preset_names
+     **/
+    presetNames: GenericRuntimeApiMethod<() => Promise<Array<string>>>;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: XcmPaymentApi - 0x6ff52ee858e6c5bd
+   **/
+  xcmPaymentApi: {
+    /**
+     * Returns a list of acceptable payment assets.
+     *
+     * # Arguments
+     *
+     * * `xcm_version`: Version.
+     *
+     * @callname: XcmPaymentApi_query_acceptable_payment_assets
+     * @param {number} xcm_version
+     **/
+    queryAcceptablePaymentAssets: GenericRuntimeApiMethod<
+      (xcmVersion: number) => Promise<Result<Array<XcmVersionedAssetId>, XcmRuntimeApisFeesError>>
+    >;
+
+    /**
+     * Returns a weight needed to execute a XCM.
+     *
+     * # Arguments
+     *
+     * * `message`: `VersionedXcm`.
+     *
+     * @callname: XcmPaymentApi_query_xcm_weight
+     * @param {XcmVersionedXcm} message
+     **/
+    queryXcmWeight: GenericRuntimeApiMethod<
+      (message: XcmVersionedXcm) => Promise<Result<SpWeightsWeightV2Weight, XcmRuntimeApisFeesError>>
+    >;
+
+    /**
+     * Converts a weight into a fee for the specified `AssetId`.
+     *
+     * # Arguments
+     *
+     * * `weight`: convertible `Weight`.
+     * * `asset`: `VersionedAssetId`.
+     *
+     * @callname: XcmPaymentApi_query_weight_to_asset_fee
+     * @param {SpWeightsWeightV2Weight} weight
+     * @param {XcmVersionedAssetId} asset
+     **/
+    queryWeightToAssetFee: GenericRuntimeApiMethod<
+      (weight: SpWeightsWeightV2Weight, asset: XcmVersionedAssetId) => Promise<Result<bigint, XcmRuntimeApisFeesError>>
+    >;
+
+    /**
+     * Get delivery fees for sending a specific `message` to a `destination`.
+     * These always come in a specific asset, defined by the chain.
+     *
+     * # Arguments
+     * * `message`: The message that'll be sent, necessary because most delivery fees are based on the
+     * size of the message.
+     * * `destination`: The destination to send the message to. Different destinations may use
+     * different senders that charge different fees.
+     *
+     * @callname: XcmPaymentApi_query_delivery_fees
+     * @param {XcmVersionedLocation} destination
+     * @param {XcmVersionedXcm} message
+     **/
+    queryDeliveryFees: GenericRuntimeApiMethod<
+      (
+        destination: XcmVersionedLocation,
+        message: XcmVersionedXcm,
+      ) => Promise<Result<XcmVersionedAssets, XcmRuntimeApisFeesError>>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: DryRunApi - 0x91b1c8b16328eb92
+   **/
+  dryRunApi: {
+    /**
+     * Dry run call V2.
+     *
+     * @callname: DryRunApi_dry_run_call
+     * @param {BasiliskRuntimeOriginCaller} origin
+     * @param {BasiliskRuntimeRuntimeCallLike} call
+     * @param {number} result_xcms_version
+     **/
+    dryRunCall: GenericRuntimeApiMethod<
+      (
+        origin: BasiliskRuntimeOriginCaller,
+        call: BasiliskRuntimeRuntimeCallLike,
+        resultXcmsVersion: number,
+      ) => Promise<Result<XcmRuntimeApisDryRunCallDryRunEffects, XcmRuntimeApisDryRunError>>
+    >;
+
+    /**
+     * Dry run XCM program
+     *
+     * @callname: DryRunApi_dry_run_xcm
+     * @param {XcmVersionedLocation} origin_location
+     * @param {XcmVersionedXcm} xcm
+     **/
+    dryRunXcm: GenericRuntimeApiMethod<
+      (
+        originLocation: XcmVersionedLocation,
+        xcm: XcmVersionedXcm,
+      ) => Promise<Result<XcmRuntimeApisDryRunXcmDryRunEffects, XcmRuntimeApisDryRunError>>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: LocationToAccountApi - 0x9ffb505aa738d69c
+   **/
+  locationToAccountApi: {
+    /**
+     * Converts `Location` to `AccountId`.
+     *
+     * @callname: LocationToAccountApi_convert_location
+     * @param {XcmVersionedLocation} location
+     **/
+    convertLocation: GenericRuntimeApiMethod<
+      (location: XcmVersionedLocation) => Promise<Result<AccountId32, XcmRuntimeApisConversionsError>>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod;
+  };
+  /**
+   * @runtimeapi: AuraUnincludedSegmentApi - 0xd7bdd8a272ca0d65
+   **/
+  auraUnincludedSegmentApi: {
+    /**
+     * Whether it is legal to extend the chain, assuming the given block is the most
+     * recently included one as-of the relay parent that will be built against, and
+     * the given relay chain slot.
+     *
+     * This should be consistent with the logic the runtime uses when validating blocks to
+     * avoid issues.
+     *
+     * When the unincluded segment is empty, i.e. `included_hash == at`, where at is the block
+     * whose state we are querying against, this must always return `true` as long as the slot
+     * is more recent than the included block itself.
+     *
+     * @callname: AuraUnincludedSegmentApi_can_build_upon
+     * @param {H256} included_hash
+     * @param {SpConsensusSlotsSlot} slot
      **/
-    buildConfig: GenericRuntimeApiMethod<(json: BytesLike) => Promise<Result<[], Text>>>;
+    canBuildUpon: GenericRuntimeApiMethod<(includedHash: H256, slot: SpConsensusSlotsSlot) => Promise<boolean>>;
 
     /**
      * Generic runtime api call