@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/bounties/bounties.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bounties = bounties;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const filterBountyProposals_js_1 = require("./helpers/filterBountyProposals.js");
+function parseResult([maybeBounties, maybeDescriptions, ids, bountyProposals]) {
+    const bounties = [];
+    maybeBounties.forEach((bounty, index) => {
+        if (bounty.isSome) {
+            bounties.push({
+                bounty: bounty.unwrap(),
+                description: maybeDescriptions[index].unwrapOrDefault().toUtf8(),
+                index: ids[index],
+                proposals: bountyProposals.filter((bountyProposal) => bountyProposal.proposal && ids[index].eq(bountyProposal.proposal.args[0]))
+            });
+        }
+    });
+    return bounties;
+}
+/**
+ * @name bounties
+ * @descrive Retrieves all active bounties, their descriptions, and associated proposals.
+ * @example
+ * ```javascript
+ * const bounties = await api.derive.bounties();
+ * console.log("Active bounties:", bounties);
+ * ```
+ */
+function bounties(instanceId, api) {
+    const bountyBase = api.query.bounties || api.query.treasury;
+    return (0, index_js_1.memo)(instanceId, () => bountyBase.bounties
+        ? (0, rxjs_1.combineLatest)([
+            bountyBase.bountyCount(),
+            api.query.council
+                ? api.query.council.proposalCount()
+                : (0, rxjs_1.of)(0)
+        ]).pipe((0, rxjs_1.switchMap)(() => (0, rxjs_1.combineLatest)([
+            bountyBase.bounties.keys(),
+            api.derive.council
+                ? api.derive.council.proposals()
+                : (0, rxjs_1.of)([])
+        ])), (0, rxjs_1.switchMap)(([keys, proposals]) => {
+            const ids = keys.map(({ args: [id] }) => id);
+            return (0, rxjs_1.combineLatest)([
+                bountyBase.bounties.multi(ids),
+                bountyBase.bountyDescriptions.multi(ids),
+                (0, rxjs_1.of)(ids),
+                (0, rxjs_1.of)((0, filterBountyProposals_js_1.filterBountiesProposals)(api, proposals))
+            ]);
+        }), (0, rxjs_1.map)(parseResult))
+        : (0, rxjs_1.of)(parseResult([[], [], [], []])));
+}

package/cjs/bounties/helpers/filterBountyProposals.d.ts

@@ -0,0 +1,2 @@
+import type { DeriveApi, DeriveCollectiveProposal } from '../../types.js';
+export declare function filterBountiesProposals(api: DeriveApi, allProposals: DeriveCollectiveProposal[]): DeriveCollectiveProposal[];

package/cjs/bounties/helpers/filterBountyProposals.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterBountiesProposals = filterBountiesProposals;
+function filterBountiesProposals(api, allProposals) {
+    const bountyTxBase = api.tx.bounties ? api.tx.bounties : api.tx.treasury;
+    const bountyProposalCalls = [bountyTxBase.approveBounty, bountyTxBase.closeBounty, bountyTxBase.proposeCurator, bountyTxBase.unassignCurator];
+    return allProposals.filter((proposal) => bountyProposalCalls.find((bountyCall) => proposal.proposal && bountyCall.is(proposal.proposal)));
+}

package/cjs/bounties/index.d.ts

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

package/cjs/bounties/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bounties.js"), exports);

package/cjs/bundle.d.ts

@@ -0,0 +1,9 @@
+import type { DeriveCustom } from '@pezkuwi/api-base/types';
+import type { ExactDerive } from './derive.js';
+import type { DeriveApi } from './types.js';
+import { lazyDeriveSection } from './util/index.js';
+export * from './derive.js';
+export * from './type/index.js';
+export { lazyDeriveSection };
+/** @internal */
+export declare function getAvailableDerives(instanceId: string, api: DeriveApi, custom?: DeriveCustom): ExactDerive;

package/cjs/bundle.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyDeriveSection = void 0;
+exports.getAvailableDerives = getAvailableDerives;
+const tslib_1 = require("tslib");
+const index_js_1 = require("./util/index.js");
+Object.defineProperty(exports, "lazyDeriveSection", { enumerable: true, get: function () { return index_js_1.lazyDeriveSection; } });
+const derive_js_1 = require("./derive.js");
+tslib_1.__exportStar(require("./derive.js"), exports);
+tslib_1.__exportStar(require("./type/index.js"), exports);
+const checks = {
+    allianceMotion: {
+        instances: ['allianceMotion'],
+        methods: []
+    },
+    bagsList: {
+        instances: ['voterBagsList', 'voterList', 'bagsList'],
+        methods: [],
+        withDetect: true
+    },
+    contracts: {
+        instances: ['contracts'],
+        methods: []
+    },
+    council: {
+        instances: ['council'],
+        methods: [],
+        withDetect: true
+    },
+    crowdloan: {
+        instances: ['crowdloan'],
+        methods: []
+    },
+    democracy: {
+        instances: ['democracy'],
+        methods: []
+    },
+    elections: {
+        instances: ['phragmenElection', 'electionsPhragmen', 'elections', 'council'],
+        methods: [],
+        withDetect: true
+    },
+    imOnline: {
+        instances: ['imOnline'],
+        methods: []
+    },
+    membership: {
+        instances: ['membership'],
+        methods: []
+    },
+    teyrchains: {
+        instances: ['teyrchains', 'registrar'],
+        methods: []
+    },
+    session: {
+        instances: ['session'],
+        methods: []
+    },
+    society: {
+        instances: ['society'],
+        methods: []
+    },
+    staking: {
+        instances: ['staking'],
+        methods: ['erasRewardPoints']
+    },
+    technicalCommittee: {
+        instances: ['technicalCommittee'],
+        methods: [],
+        withDetect: true
+    },
+    treasury: {
+        instances: ['treasury'],
+        methods: []
+    }
+};
+function getModuleInstances(api, specName, moduleName) {
+    return api.registry.getModuleInstances(specName, moduleName) || [];
+}
+/**
+ * Returns an object that will inject `api` into all the functions inside
+ * `allSections`, and keep the object architecture of `allSections`.
+ */
+/** @internal */
+function injectFunctions(instanceId, api, derives) {
+    const result = {};
+    const names = Object.keys(derives);
+    const keys = Object.keys(api.query);
+    const specName = api.runtimeVersion.specName;
+    const filterKeys = (q) => keys.includes(q);
+    const filterInstances = (q) => getModuleInstances(api, specName, q).some(filterKeys);
+    const filterMethods = (all) => (m) => all.some((q) => keys.includes(q) && api.query[q][m]);
+    const getKeys = (s) => Object.keys(derives[s]);
+    const creator = (s, m) => derives[s][m](instanceId, api);
+    const isIncluded = (c) => (!checks[c] || ((checks[c].instances.some(filterKeys) && (!checks[c].methods.length ||
+        checks[c].methods.every(filterMethods(checks[c].instances)))) ||
+        (checks[c].withDetect &&
+            checks[c].instances.some(filterInstances))));
+    for (let i = 0, count = names.length; i < count; i++) {
+        const name = names[i];
+        isIncluded(name) &&
+            (0, index_js_1.lazyDeriveSection)(result, name, getKeys, creator);
+    }
+    return result;
+}
+/** @internal */
+function getAvailableDerives(instanceId, api, custom = {}) {
+    return {
+        ...injectFunctions(instanceId, api, derive_js_1.derive),
+        ...injectFunctions(instanceId, api, custom)
+    };
+}

package/cjs/chain/bestNumber.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @name bestNumber
+ * @descrive Retrieves the latest block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumber((blockNumber) => {
+ *   console.log(`the current best block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export declare const bestNumber: import("./util.js").BlockNumberDerive;

package/cjs/chain/bestNumber.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bestNumber = void 0;
+const util_js_1 = require("./util.js");
+/**
+ * @name bestNumber
+ * @descrive Retrieves the latest block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumber((blockNumber) => {
+ *   console.log(`the current best block is #${blockNumber}`);
+ * });
+ * ```
+ */
+exports.bestNumber = (0, util_js_1.createBlockNumberDerive)((api) => api.rpc.chain.subscribeNewHeads());

package/cjs/chain/bestNumberFinalized.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @name bestNumberFinalized
+ * @returns A BlockNumber
+ * @description Get the latest finalized block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumberFinalized((blockNumber) => {
+ *   console.log(`the current finalized block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export declare const bestNumberFinalized: import("./util.js").BlockNumberDerive;

package/cjs/chain/bestNumberFinalized.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bestNumberFinalized = void 0;
+const util_js_1 = require("./util.js");
+/**
+ * @name bestNumberFinalized
+ * @returns A BlockNumber
+ * @description Get the latest finalized block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumberFinalized((blockNumber) => {
+ *   console.log(`the current finalized block is #${blockNumber}`);
+ * });
+ * ```
+ */
+exports.bestNumberFinalized = (0, util_js_1.createBlockNumberDerive)((api) => api.rpc.chain.subscribeFinalizedHeads());

package/cjs/chain/bestNumberLag.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BlockNumber } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name bestNumberLag
+ * @returns A number of blocks
+ * @description Calculates the lag between finalized head and best head
+ * @examplew
+ * ```javascript
+ * api.derive.chain.bestNumberLag((lag) => {
+ *   console.log(`finalized is ${lag} blocks behind head`);
+ * });
+ * ```
+ */
+export declare function bestNumberLag(instanceId: string, api: DeriveApi): () => Observable<BlockNumber>;

package/cjs/chain/bestNumberLag.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bestNumberLag = bestNumberLag;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name bestNumberLag
+ * @returns A number of blocks
+ * @description Calculates the lag between finalized head and best head
+ * @examplew
+ * ```javascript
+ * api.derive.chain.bestNumberLag((lag) => {
+ *   console.log(`finalized is ${lag} blocks behind head`);
+ * });
+ * ```
+ */
+function bestNumberLag(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => (0, rxjs_1.combineLatest)([
+        api.derive.chain.bestNumber(),
+        api.derive.chain.bestNumberFinalized()
+    ]).pipe((0, rxjs_1.map)(([bestNumber, bestNumberFinalized]) => api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized)))));
+}

package/cjs/chain/getBlock.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name getBlock
+ * @param {( Uint8Array | string )} hash A block hash as U8 array or string.
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlock('0x123...456');
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export declare function getBlock(instanceId: string, api: DeriveApi): (hash: Uint8Array | string) => Observable<SignedBlockExtended>;

package/cjs/chain/getBlock.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlock = getBlock;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../type/index.js");
+const index_js_2 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+/**
+ * @name getBlock
+ * @param {( Uint8Array | string )} hash A block hash as U8 array or string.
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlock('0x123...456');
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+function getBlock(instanceId, api) {
+    return (0, index_js_2.memo)(instanceId, (blockHash) => (0, rxjs_1.combineLatest)([
+        api.rpc.chain.getBlock(blockHash),
+        api.queryAt(blockHash)
+    ]).pipe((0, rxjs_1.switchMap)(([signedBlock, queryAt]) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(signedBlock),
+        queryAt.system.events(),
+        (0, util_js_1.getAuthorDetails)(api, signedBlock.block.header, blockHash)
+    ])), (0, rxjs_1.map)(([signedBlock, events, [, validators, author]]) => (0, index_js_1.createSignedBlockExtended)(events.registry, signedBlock, events, validators, author))));
+}

package/{src/chain/getBlockByNumber.ts → cjs/chain/getBlockByNumber.d.ts}

@@ -1,15 +1,7 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import type { Observable } from 'rxjs';
 import type { AnyNumber } from '@pezkuwi/types/types';
 import type { SignedBlockExtended } from '../type/types.js';
 import type { DeriveApi } from '../types.js';
-
-import { switchMap } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
 /**
  * @name getBlockByNumber
  * @param {( BN | bigint | Uint8Array | number | string )} blockNumber
@@ -21,10 +13,4 @@ import { memo } from '../util/index.js';
  * console.log(`block #${block.header.number} was authored by ${author}`);
  * ```
  */
-export function getBlockByNumber (instanceId: string, api: DeriveApi): (blockNumber: AnyNumber) => Observable<SignedBlockExtended> {
-  return memo(instanceId, (blockNumber: AnyNumber): Observable<SignedBlockExtended> =>
-    api.rpc.chain.getBlockHash(blockNumber).pipe(
-      switchMap((h) => api.derive.chain.getBlock(h))
-    )
-  );
-}
+export declare function getBlockByNumber(instanceId: string, api: DeriveApi): (blockNumber: AnyNumber) => Observable<SignedBlockExtended>;

package/cjs/chain/getBlockByNumber.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockByNumber = getBlockByNumber;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name getBlockByNumber
+ * @param {( BN | bigint | Uint8Array | number | string )} blockNumber
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author by block number
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlockByNumber(123);
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+function getBlockByNumber(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (blockNumber) => api.rpc.chain.getBlockHash(blockNumber).pipe((0, rxjs_1.switchMap)((h) => api.derive.chain.getBlock(h))));
+}

package/cjs/chain/getHeader.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { HeaderExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name getHeader
+ * @param {( Uint8Array | string )} hash - A block hash as U8 array or string.
+ * @returns An array containing the block header and the block author
+ * @description Get a specific block header and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, number } = await api.derive.chain.getHeader('0x123...456');
+ *
+ * console.log(`block #${number} was authored by ${author}`);
+ * ```
+ */
+export declare function getHeader(instanceId: string, api: DeriveApi): (blockHash: Uint8Array | string) => Observable<HeaderExtended>;

package/cjs/chain/getHeader.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeader = getHeader;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../type/index.js");
+const index_js_2 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+/**
+ * @name getHeader
+ * @param {( Uint8Array | string )} hash - A block hash as U8 array or string.
+ * @returns An array containing the block header and the block author
+ * @description Get a specific block header and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, number } = await api.derive.chain.getHeader('0x123...456');
+ *
+ * console.log(`block #${number} was authored by ${author}`);
+ * ```
+ */
+function getHeader(instanceId, api) {
+    return (0, index_js_2.memo)(instanceId, (blockHash) => api.rpc.chain.getHeader(blockHash).pipe((0, rxjs_1.switchMap)((header) => (0, util_js_1.getAuthorDetails)(api, header, blockHash)), (0, rxjs_1.map)(([header, validators, author]) => (0, index_js_1.createHeaderExtended)((validators || header).registry, header, validators, author))));
+}

package/cjs/chain/index.d.ts

@@ -0,0 +1,10 @@
+export * from './bestNumber.js';
+export * from './bestNumberFinalized.js';
+export * from './bestNumberLag.js';
+export * from './getBlock.js';
+export * from './getBlockByNumber.js';
+export * from './getHeader.js';
+export * from './subscribeFinalizedBlocks.js';
+export * from './subscribeFinalizedHeads.js';
+export * from './subscribeNewBlocks.js';
+export * from './subscribeNewHeads.js';

package/cjs/chain/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bestNumber.js"), exports);
+tslib_1.__exportStar(require("./bestNumberFinalized.js"), exports);
+tslib_1.__exportStar(require("./bestNumberLag.js"), exports);
+tslib_1.__exportStar(require("./getBlock.js"), exports);
+tslib_1.__exportStar(require("./getBlockByNumber.js"), exports);
+tslib_1.__exportStar(require("./getHeader.js"), exports);
+tslib_1.__exportStar(require("./subscribeFinalizedBlocks.js"), exports);
+tslib_1.__exportStar(require("./subscribeFinalizedHeads.js"), exports);
+tslib_1.__exportStar(require("./subscribeNewBlocks.js"), exports);
+tslib_1.__exportStar(require("./subscribeNewHeads.js"), exports);

package/cjs/chain/subscribeFinalizedBlocks.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeFinalizedBlocks
+ * @description Retrieves the finalized block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedBlocks((finalizedBlock) => {
+ *  console.log(`# Finalized block ${finalizedBlock.block.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeFinalizedBlocks(instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended>;

package/cjs/chain/subscribeFinalizedBlocks.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeFinalizedBlocks = subscribeFinalizedBlocks;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name subscribeFinalizedBlocks
+ * @description Retrieves the finalized block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedBlocks((finalizedBlock) => {
+ *  console.log(`# Finalized block ${finalizedBlock.block.hash}`);
+ * });
+ * ```
+ */
+function subscribeFinalizedBlocks(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.chain.subscribeFinalizedHeads().pipe((0, rxjs_1.switchMap)((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
+}

package/cjs/chain/subscribeFinalizedHeads.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { Hash, Header } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+export declare function _getHeaderRange(instanceId: string, api: DeriveApi): (startHash: Hash, endHash: Hash, prev?: Header[]) => Observable<Header[]>;
+/**
+ * @name subscribeFinalizedHeads
+ * @description An observable of the finalized block headers. Unlike the base
+ * chain.subscribeFinalizedHeads this does not skip any headers. Since finalization
+ * may skip specific blocks (finalization happens in terms of chains), this version
+ * of the derive tracks missing headers (since last retrieved) and provides them
+ * to the caller.
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedHeads((finalizedHead) => {
+ *   console.log(`${finalizedHead.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeFinalizedHeads(instanceId: string, api: DeriveApi): () => Observable<Header>;

package/cjs/chain/subscribeFinalizedHeads.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getHeaderRange = _getHeaderRange;
+exports.subscribeFinalizedHeads = subscribeFinalizedHeads;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+function _getHeaderRange(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (startHash, endHash, prev = []) => api.rpc.chain.getHeader(startHash).pipe((0, rxjs_1.switchMap)((header) => header.parentHash.eq(endHash)
+        ? (0, rxjs_1.of)([header, ...prev])
+        : api.derive.chain._getHeaderRange(header.parentHash, endHash, [header, ...prev]))));
+}
+/**
+ * @name subscribeFinalizedHeads
+ * @description An observable of the finalized block headers. Unlike the base
+ * chain.subscribeFinalizedHeads this does not skip any headers. Since finalization
+ * may skip specific blocks (finalization happens in terms of chains), this version
+ * of the derive tracks missing headers (since last retrieved) and provides them
+ * to the caller.
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedHeads((finalizedHead) => {
+ *   console.log(`${finalizedHead.hash}`);
+ * });
+ * ```
+ */
+function subscribeFinalizedHeads(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => {
+        let prevHash = null;
+        return api.rpc.chain.subscribeFinalizedHeads().pipe((0, rxjs_1.switchMap)((header) => {
+            const endHash = prevHash;
+            const startHash = header.parentHash;
+            prevHash = header.createdAtHash = header.hash;
+            return endHash === null || startHash.eq(endHash)
+                ? (0, rxjs_1.of)(header)
+                : api.derive.chain._getHeaderRange(startHash, endHash, [header]).pipe((0, rxjs_1.switchMap)((headers) => (0, rxjs_1.from)(headers)));
+        }));
+    });
+}

package/cjs/chain/subscribeNewBlocks.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeNewBlocks
+ * @returns The latest block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeNewBlocks((newBlock) => {
+ *   console.log(`Block Hash: ${newBlock.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeNewBlocks(instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended>;

package/cjs/chain/subscribeNewBlocks.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeNewBlocks = subscribeNewBlocks;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name subscribeNewBlocks
+ * @returns The latest block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeNewBlocks((newBlock) => {
+ *   console.log(`Block Hash: ${newBlock.hash}`);
+ * });
+ * ```
+ */
+function subscribeNewBlocks(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.chain.subscribeNewHeads().pipe((0, rxjs_1.switchMap)((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
+}

package/cjs/chain/subscribeNewHeads.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { HeaderExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeNewHeads
+ * @returns A header with the current header (including extracted author).
+ * @description An observable of the current block header and it's author.
+ * @example
+ * ```javascript
+ * api.derive.chain.subscribeNewHeads((header) => {
+ *   console.log(`block #${header.number} was authored by ${header.author}`);
+ * });
+ * ```
+ */
+export declare function subscribeNewHeads(instanceId: string, api: DeriveApi): () => Observable<HeaderExtended>;

package/cjs/chain/subscribeNewHeads.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeNewHeads = subscribeNewHeads;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../type/index.js");
+const index_js_2 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+/**
+ * @name subscribeNewHeads
+ * @returns A header with the current header (including extracted author).
+ * @description An observable of the current block header and it's author.
+ * @example
+ * ```javascript
+ * api.derive.chain.subscribeNewHeads((header) => {
+ *   console.log(`block #${header.number} was authored by ${header.author}`);
+ * });
+ * ```
+ */
+function subscribeNewHeads(instanceId, api) {
+    return (0, index_js_2.memo)(instanceId, () => api.rpc.chain.subscribeNewHeads().pipe((0, rxjs_1.switchMap)((header) => (0, util_js_1.getAuthorDetails)(api, header)), (0, rxjs_1.map)(([header, validators, author]) => {
+        header.createdAtHash = header.hash;
+        return (0, index_js_1.createHeaderExtended)(header.registry, header, validators, author);
+    })));
+}

package/cjs/chain/util.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { Compact, Vec } from '@pezkuwi/types';
+import type { AccountId, BlockNumber, Header } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+export type BlockNumberDerive = (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+export declare function createBlockNumberDerive<T extends {
+    number: Compact<BlockNumber> | BlockNumber;
+}>(fn: (api: DeriveApi) => Observable<T>): BlockNumberDerive;
+export declare function getAuthorDetails(api: DeriveApi, header: Header, blockHash?: Uint8Array | string): Observable<[Header, Vec<AccountId> | null, AccountId | null]>;