@pezkuwi/api-derive 16.5.16 → 16.5.18

package/build/staking/validators.d.ts

@@ -0,0 +1,33 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveStakingValidators } from '../types.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.
+ * @example
+ * ```javascript
+ * const nextElected = await api.derive.staking.nextElected();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export declare function nextElected(instanceId: string, api: DeriveApi): () => Observable<AccountId[]>;
+/**
+ * @name validators
+ * @description Retrieve latest list of validators.
+ * @example
+ * ```javascript
+ * const { validators, nextElected } = await api.derive.staking.validators();
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((v) => v.toString())
+ * );
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((v) => v.toString())
+ * );
+ * ```
+ */
+export declare function validators(instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators>;

package/build/staking/validators.js

@@ -0,0 +1,67 @@
+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.
+ * @example
+ * ```javascript
+ * const nextElected = await api.derive.staking.nextElected();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export function nextElected(instanceId, api) {
+    return memo(instanceId, () => 
+    // Compatibility for future generation changes in staking.
+    api.query.staking.erasStakersOverview
+        ? 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)), 
+        // 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']());
+}
+/**
+ * @name validators
+ * @description Retrieve latest list of validators.
+ * @example
+ * ```javascript
+ * const { validators, nextElected } = await api.derive.staking.validators();
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((v) => v.toString())
+ * );
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((v) => v.toString())
+ * );
+ * ```
+ */
+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]) => ({
+        nextElected: nextElected.length
+            ? nextElected
+            : validators,
+        validators
+    }))));
+}

package/build/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/build/staking/waitingInfo.js

@@ -0,0 +1,29 @@
+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.
+ * @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 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) => ({
+            info,
+            waiting
+        })));
+    })));
+}

package/build/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/build/technicalCommittee/index.js

@@ -0,0 +1,71 @@
+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.
+ * @example
+ * ```javascript
+ * const members = await api.derive.technicalCommittee.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('technicalCommittee');
+/**
+ * @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 const hasProposals = /*#__PURE__*/ collectiveHasProposals('technicalCommittee');
+/**
+ * @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 const proposal = /*#__PURE__*/ collectiveProposal('technicalCommittee');
+/**
+ * @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 const proposalCount = /*#__PURE__*/ collectiveProposalCount('technicalCommittee');
+/**
+ * @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 const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('technicalCommittee');
+/**
+ * @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 const proposals = /*#__PURE__*/ collectiveProposals('technicalCommittee');
+/**
+ * @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 const prime = /*#__PURE__*/ collectivePrime('technicalCommittee');

package/build/teyrchains/index.d.ts

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

package/build/teyrchains/index.js

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

package/build/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/build/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/build/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/build/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/build/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/build/teyrchains/types.js

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

package/build/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/build/teyrchains/util.js

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

package/build/treasury/index.d.ts

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

package/build/treasury/index.js

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

package/build/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/build/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/build/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/build/tx/constants.js

@@ -0,0 +1,5 @@
+import { BN } from '@pezkuwi/util';
+export const FALLBACK_MAX_HASH_COUNT = 250;
+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/build/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/build/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 }))));
+}