@pezkuwi/api-derive 16.5.5 → 16.5.6

package/{src/staking/validators.ts → staking/validators.js}

@@ -1,14 +1,5 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountId } from '@pezkuwi/types/interfaces';
-import type { DeriveApi, DeriveStakingValidators } from '../types.js';
-
 import { combineLatest, map, of, switchMap } from 'rxjs';
-
 import { memo } from '../util/index.js';
-
 /**
  * @name nextElected
  * @description Retrieves the list of accounts that are set to be the next elected validators in the staking system. It provides a preview of who will be validators in the next staking era.
@@ -21,29 +12,25 @@ import { memo } from '../util/index.js';
  * );
  * ```
  */
-export function nextElected (instanceId: string, api: DeriveApi): () => Observable<AccountId[]> {
-  return memo(instanceId, (): Observable<AccountId[]> =>
+export function nextElected(instanceId, api) {
+    return memo(instanceId, () => 
     // Compatibility for future generation changes in staking.
     api.query.staking.erasStakersOverview
-      ? api.derive.session.indexes().pipe(
+        ? api.derive.session.indexes().pipe(
         // only populate for next era in the last session, so track both here - entries are not
         // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
-        switchMap(({ currentEra }) => api.query.staking.erasStakersOverview.keys(currentEra)),
+        switchMap(({ currentEra }) => api.query.staking.erasStakersOverview.keys(currentEra)), 
         // Dedupe any duplicates
-        map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
-      )
-      : api.query.staking.erasStakers
-        ? api.derive.session.indexes().pipe(
-          // only populate for next era in the last session, so track both here - entries are not
-          // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
-          switchMap(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)),
-          // Dedupe any duplicates
-          map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
-        )
-        : api.query.staking['currentElected']<AccountId[]>()
-  );
+        map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a))))
+        : api.query.staking.erasStakers
+            ? api.derive.session.indexes().pipe(
+            // only populate for next era in the last session, so track both here - entries are not
+            // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+            switchMap(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)), 
+            // Dedupe any duplicates
+            map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a))))
+            : api.query.staking['currentElected']());
 }
-
 /**
  * @name validators
  * @description Retrieve latest list of validators.
@@ -60,23 +47,21 @@ export function nextElected (instanceId: string, api: DeriveApi): () => Observab
  * );
  * ```
  */
-export function validators (instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators> {
-  return memo(instanceId, (): Observable<DeriveStakingValidators> =>
+export function validators(instanceId, api) {
+    return memo(instanceId, () => 
     // Sadly the node-template is (for some obscure reason) not comprehensive, so while the derive works
     // in all actual real-world deployed chains, it does create some confusion for limited template chains
     combineLatest([
-      api.query.session
-        ? api.query.session.validators()
-        : of([]),
-      api.query.staking
-        ? api.derive.staking.nextElected()
-        : of([])
-    ]).pipe(
-      map(([validators, nextElected]): DeriveStakingValidators => ({
+        api.query.session
+            ? api.query.session.validators()
+            : of([]),
+        api.query.staking
+            ? api.derive.staking.nextElected()
+            : of([])
+    ]).pipe(map(([validators, nextElected]) => ({
         nextElected: nextElected.length
-          ? nextElected
-          : validators,
+            ? nextElected
+            : validators,
         validators
-      }))
-    ));
+    }))));
 }

package/staking/waitingInfo.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingWaiting, StakingQueryFlags } from '../types.js';
+/**
+ * @name waitingInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @description Staking candidates who are waiting to become validators.
+ * @example
+ * ```javascript
+ * const { waiting, info } = await api.derive.staking.waitingInfo();
+ * console.log(
+ *   "Waiting Candidates:",
+ *   waiting.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export declare function waitingInfo(instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags) => Observable<DeriveStakingWaiting>;

package/{src/staking/waitingInfo.ts → staking/waitingInfo.js}

@@ -1,15 +1,6 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveStakingWaiting, StakingQueryFlags } from '../types.js';
-
 import { combineLatest, map, switchMap } from 'rxjs';
-
 import { memo } from '../util/index.js';
-
 const DEFAULT_FLAGS = { withController: true, withPrefs: true };
-
 /**
  * @name waitingInfo
  * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
@@ -23,23 +14,16 @@ const DEFAULT_FLAGS = { withController: true, withPrefs: true };
  * );
  * ```
  */
-export function waitingInfo (instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags) => Observable<DeriveStakingWaiting> {
-  return memo(instanceId, (flags: StakingQueryFlags = DEFAULT_FLAGS): Observable<DeriveStakingWaiting> =>
-    combineLatest([
-      api.derive.staking.validators(),
-      api.derive.staking.stashes()
-    ]).pipe(
-      switchMap(([{ nextElected }, stashes]): Observable<DeriveStakingWaiting> => {
+export function waitingInfo(instanceId, api) {
+    return memo(instanceId, (flags = DEFAULT_FLAGS) => combineLatest([
+        api.derive.staking.validators(),
+        api.derive.staking.stashes()
+    ]).pipe(switchMap(([{ nextElected }, stashes]) => {
         const elected = nextElected.map((a) => a.toString());
         const waiting = stashes.filter((v) => !elected.includes(v.toString()));
-
-        return api.derive.staking.queryMulti(waiting, flags).pipe(
-          map((info): DeriveStakingWaiting => ({
+        return api.derive.staking.queryMulti(waiting, flags).pipe(map((info) => ({
             info,
             waiting
-          }))
-        );
-      })
-    )
-  );
+        })));
+    })));
 }

package/technicalCommittee/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @name members
+ * @description Retrieves the list of members in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.technicalCommittee.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export declare const members: import("../collective/types.js").MembersFnRet;
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.technicalCommittee.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "technicalCommitteeMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.technicalCommittee.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export declare const proposal: import("../collective/types.js").ProposalFnRet;
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.technicalCommittee.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export declare const proposalCount: import("../collective/types.js").ProposalCountFnRet;
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.technicalCommittee.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export declare const proposalHashes: import("../collective/types.js").ProposalHashesFnRet;
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.technicalCommittee.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "technicalCommittee" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.technicalCommittee.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export declare const prime: import("../collective/types.js").PrimeFnRet;

package/{src/technicalCommittee/index.ts → technicalCommittee/index.js}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { hasProposals as collectiveHasProposals, members as collectiveMembers, prime as collectivePrime, proposal as collectiveProposal, proposalCount as collectiveProposalCount, proposalHashes as collectiveProposalHashes, proposals as collectiveProposals } from '../collective/index.js';
-
 /**
  * @name members
  * @description Retrieves the list of members in the "technicalCommittee" collective.
@@ -13,7 +9,6 @@ import { hasProposals as collectiveHasProposals, members as collectiveMembers, p
  * ```
  */
 export const members = /*#__PURE__*/ collectiveMembers('technicalCommittee');
-
 /**
  * @name hasProposals
  * @description Checks if there are any active proposals in the "technicalCommittee" collective.

package/teyrchains/index.d.ts

@@ -0,0 +1,2 @@
+export * from './info.js';
+export * from './overview.js';

package/teyrchains/index.js

@@ -0,0 +1,2 @@
+export * from './info.js';
+export * from './overview.js';

package/teyrchains/info.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveTeyrchainFull } from '../types.js';
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Teyrchain information not available.");
+ *   }
+ * });
+ * ```
+*/
+export declare function info(instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveTeyrchainFull | null>;

package/teyrchains/info.js

@@ -0,0 +1,72 @@
+import { map, of } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { didUpdateToBool } from './util.js';
+function parseActive(id, active) {
+    const found = active.find(([paraId]) => paraId === id);
+    if (found && found[1].isSome) {
+        const [collatorId, retriable] = found[1].unwrap();
+        return objectSpread({ collatorId }, retriable.isWithRetries
+            ? {
+                isRetriable: true,
+                retries: retriable.asWithRetries.toNumber()
+            }
+            : {
+                isRetriable: false,
+                retries: 0
+            });
+    }
+    return null;
+}
+function parseCollators(id, collatorQueue) {
+    return collatorQueue.map((queue) => {
+        const found = queue.find(([paraId]) => paraId === id);
+        return found ? found[1] : null;
+    });
+}
+function parse(id, [active, retryQueue, selectedThreads, didUpdate, info, pendingSwap, heads, relayDispatchQueue]) {
+    if (info.isNone) {
+        return null;
+    }
+    return {
+        active: parseActive(id, active),
+        didUpdate: didUpdateToBool(didUpdate, id),
+        heads,
+        id,
+        info: objectSpread({ id }, info.unwrap()),
+        pendingSwapId: pendingSwap.unwrapOr(null),
+        relayDispatchQueue,
+        retryCollators: parseCollators(id, retryQueue),
+        selectedCollators: parseCollators(id, selectedThreads)
+    };
+}
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Teyrchain information not available.");
+ *   }
+ * });
+ * ```
+*/
+export function info(instanceId, api) {
+    return memo(instanceId, (id) => api.query['registrar'] && api.query['teyrchains']
+        ? api.queryMulti([
+            api.query['registrar']['active'],
+            api.query['registrar']['retryQueue'],
+            api.query['registrar']['selectedThreads'],
+            api.query['teyrchains']['didUpdate'],
+            [api.query['registrar']['paras'], id],
+            [api.query['registrar']['pendingSwap'], id],
+            [api.query['teyrchains']['heads'], id],
+            [api.query['teyrchains']['relayDispatchQueue'], id]
+        ])
+            .pipe(map((result) => parse(api.registry.createType('ParaId', id), result)))
+        : of(null));
+}

package/teyrchains/overview.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveTeyrchain } from '../types.js';
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveTeyrchain[]>;

package/teyrchains/overview.js

@@ -0,0 +1,36 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { didUpdateToBool } from './util.js';
+function parse([ids, didUpdate, relayDispatchQueueSizes, infos, pendingSwaps]) {
+    return ids.map((id, index) => ({
+        didUpdate: didUpdateToBool(didUpdate, id),
+        id,
+        info: objectSpread({ id }, infos[index].unwrapOr(null)),
+        pendingSwapId: pendingSwaps[index].unwrapOr(null),
+        relayDispatchQueueSize: relayDispatchQueueSizes[index][0].toNumber()
+    }));
+}
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export function overview(instanceId, api) {
+    return memo(instanceId, () => api.query['registrar']?.['teyrchains'] && api.query['teyrchains']
+        ? api.query['registrar']['teyrchains']().pipe(switchMap((paraIds) => combineLatest([
+            of(paraIds),
+            api.query['teyrchains']['didUpdate'](),
+            api.query['teyrchains']['relayDispatchQueueSize'].multi(paraIds),
+            api.query['registrar']['paras'].multi(paraIds),
+            api.query['registrar']['pendingSwap'].multi(paraIds)
+        ])), map(parse))
+        : of([]));
+}

package/teyrchains/types.d.ts

@@ -0,0 +1,38 @@
+import type { Bytes, Option, u32, Vec } from '@pezkuwi/types';
+import type { CollatorId, ParaId, ParaInfo, Retriable, UpwardMessage } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+export type ParaInfoResult = Option<ParaInfo>;
+export type PendingSwap = Option<ParaId>;
+export type Active = Vec<ITuple<[ParaId, Option<ITuple<[CollatorId, Retriable]>>]>>;
+export type RetryQueue = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type SelectedThreads = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type Code = Bytes;
+export type Heads = Bytes;
+export type RelayDispatchQueue = Vec<UpwardMessage>;
+export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
+export type DidUpdate = Option<Vec<ParaId>>;
+export interface DeriveTeyrchainActive {
+    collatorId: CollatorId;
+    isRetriable: boolean;
+    retries: number;
+}
+export interface DeriveTeyrchainInfo extends ParaInfo {
+    id: ParaId;
+    icon?: string;
+    name?: string;
+    owner?: string;
+}
+export interface DeriveTeyrchain {
+    didUpdate: boolean;
+    pendingSwapId: ParaId | null;
+    id: ParaId;
+    info: DeriveTeyrchainInfo | null;
+    relayDispatchQueueSize?: number;
+}
+export interface DeriveTeyrchainFull extends DeriveTeyrchain {
+    active: DeriveTeyrchainActive | null;
+    heads: Bytes | null;
+    relayDispatchQueue: UpwardMessage[];
+    retryCollators: (CollatorId | null)[];
+    selectedCollators: (CollatorId | null)[];
+}

package/teyrchains/types.js

@@ -0,0 +1 @@
+export {};

package/teyrchains/util.d.ts

@@ -0,0 +1,3 @@
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DidUpdate } from './types.js';
+export declare function didUpdateToBool(didUpdate: DidUpdate, id: ParaId): boolean;

package/teyrchains/util.js

@@ -0,0 +1,5 @@
+export function didUpdateToBool(didUpdate, id) {
+    return didUpdate.isSome
+        ? didUpdate.unwrap().some((paraId) => paraId.eq(id))
+        : false;
+}

package/treasury/index.d.ts

@@ -0,0 +1 @@
+export * from './proposals.js';

package/treasury/index.js

@@ -0,0 +1 @@
+export * from './proposals.js';

package/treasury/proposals.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveTreasuryProposals } from '../types.js';
+/**
+ * @name proposals
+ * @description Retrieve all active and approved treasury proposals, along with their info.
+ * @example
+ * ```javascript
+ * const treasuryProposals = await api.derive.treasury.proposals();
+ * console.log(treasuryProposals);
+ * ```
+ */
+export declare function proposals(instanceId: string, api: DeriveApi): () => Observable<DeriveTreasuryProposals>;

package/treasury/proposals.js

@@ -0,0 +1,68 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+function parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount }) {
+    const approvals = [];
+    const proposals = [];
+    const councilTreasury = councilProposals.filter(({ proposal }) => 
+    // FIXME `approveProposal` and `rejectProposal` have been removed in bizinikiwi and released in 1.14
+    // in favor of `spend`. See: https://github.com/pezkuwichain/pezkuwi-sdk/pull/3820
+    proposal && ((api.tx.treasury['approveProposal'] && api.tx.treasury['approveProposal'].is(proposal)) ||
+        (api.tx.treasury['rejectProposal'] && api.tx.treasury['rejectProposal'].is(proposal))));
+    allIds.forEach((id, index) => {
+        if (allProposals[index].isSome) {
+            const council = councilTreasury
+                .filter(({ proposal }) => proposal && id.eq(proposal.args[0]))
+                .sort((a, b) => a.proposal && b.proposal
+                ? a.proposal.method.localeCompare(b.proposal.method)
+                : a.proposal
+                    ? -1
+                    : 1);
+            const isApproval = approvalIds.some((approvalId) => approvalId.eq(id));
+            const derived = { council, id, proposal: allProposals[index].unwrap() };
+            if (isApproval) {
+                approvals.push(derived);
+            }
+            else {
+                proposals.push(derived);
+            }
+        }
+    });
+    return { approvals, proposalCount, proposals };
+}
+function retrieveProposals(api, proposalCount, approvalIds) {
+    const proposalIds = [];
+    const count = proposalCount.toNumber();
+    for (let index = 0; index < count; index++) {
+        if (!approvalIds.some((id) => id.eqn(index))) {
+            proposalIds.push(api.registry.createType('ProposalIndex', index));
+        }
+    }
+    const allIds = [...proposalIds, ...approvalIds];
+    return combineLatest([
+        api.query.treasury.proposals.multi(allIds),
+        api.derive.council
+            ? api.derive.council.proposals()
+            : of([])
+    ]).pipe(map(([allProposals, councilProposals]) => parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })));
+}
+/**
+ * @name proposals
+ * @description Retrieve all active and approved treasury proposals, along with their info.
+ * @example
+ * ```javascript
+ * const treasuryProposals = await api.derive.treasury.proposals();
+ * console.log(treasuryProposals);
+ * ```
+ */
+export function proposals(instanceId, api) {
+    return memo(instanceId, () => api.query.treasury
+        ? combineLatest([
+            api.query.treasury.proposalCount(),
+            api.query.treasury.approvals()
+        ]).pipe(switchMap(([proposalCount, approvalIds]) => retrieveProposals(api, proposalCount, approvalIds)))
+        : of({
+            approvals: [],
+            proposalCount: api.registry.createType('ProposalIndex'),
+            proposals: []
+        }));
+}

package/tx/constants.d.ts

@@ -0,0 +1,5 @@
+import { BN } from '@pezkuwi/util';
+export declare const FALLBACK_MAX_HASH_COUNT = 250;
+export declare const FALLBACK_PERIOD: BN;
+export declare const MAX_FINALITY_LAG: BN;
+export declare const MORTAL_PERIOD: BN;

package/{src/tx/constants.ts → tx/constants.js}

@@ -1,13 +1,5 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { BN } from '@pezkuwi/util';
-
 export const FALLBACK_MAX_HASH_COUNT = 250;
-
-// default here to 5 min eras, adjusted based on the actual blocktime
 export const FALLBACK_PERIOD = new BN(6 * 1000);
-
 export const MAX_FINALITY_LAG = new BN(5);
-
 export const MORTAL_PERIOD = new BN(5 * 60 * 1000);

package/tx/events.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { EventRecord, Hash, SignedBlock } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+interface Result {
+    block: SignedBlock;
+    events: EventRecord[];
+}
+/**
+ * @name events
+ * @param {Hash} at Block hash to query at.
+ * @description Retrieves the block information alongside its events at a given block hash
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   "Hash",
+ *   "0xf1dc2efe8265be67deea5e91b05a98a7f9f81f66854e92825cf36f541beb7af6"
+ * );
+ * const { events, block } = await api.derive.tx.events(blockHash);
+ * ```
+ */
+export declare function events(instanceId: string, api: DeriveApi): (at: Hash) => Observable<Result>;
+export {};

package/tx/events.js

@@ -0,0 +1,21 @@
+import { combineLatest, map, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name events
+ * @param {Hash} at Block hash to query at.
+ * @description Retrieves the block information alongside its events at a given block hash
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   "Hash",
+ *   "0xf1dc2efe8265be67deea5e91b05a98a7f9f81f66854e92825cf36f541beb7af6"
+ * );
+ * const { events, block } = await api.derive.tx.events(blockHash);
+ * ```
+ */
+export function events(instanceId, api) {
+    return memo(instanceId, (blockHash) => combineLatest([
+        api.rpc.chain.getBlock(blockHash),
+        api.queryAt(blockHash).pipe(switchMap((queryAt) => queryAt.system.events()))
+    ]).pipe(map(([block, events]) => ({ block, events }))));
+}