@pezkuwi/api-derive 16.5.8 → 16.5.10

package/build-tsc-esm/balances/all.js

@@ -1,167 +0,0 @@
-import { combineLatest, map, of, switchMap } from 'rxjs';
-import { BN, BN_ZERO, bnMax, bnMin, isFunction, objectSpread } from '@pezkuwi/util';
-import { memo } from '../util/index.js';
-const VESTING_ID = '0x76657374696e6720';
-function calcLocked(api, bestNumber, locks) {
-    let lockedBalance = api.registry.createType('Balance');
-    let lockedBreakdown = [];
-    let vestingLocked = api.registry.createType('Balance');
-    let allLocked = false;
-    if (Array.isArray(locks)) {
-        // only get the locks that are valid until passed the current block
-        lockedBreakdown = locks.filter(({ until }) => !until || (bestNumber && until.gt(bestNumber)));
-        allLocked = lockedBreakdown.some(({ amount }) => amount && amount.isMax());
-        vestingLocked = api.registry.createType('Balance', lockedBreakdown.filter(({ id }) => id.eq(VESTING_ID)).reduce((result, { amount }) => result.iadd(amount), new BN(0)));
-        // get the maximum of the locks according to https://github.com/pezkuwichain/bizinikiwi/blob/master/srml/balances/src/lib.rs#L699
-        const notAll = lockedBreakdown.filter(({ amount }) => amount && !amount.isMax());
-        if (notAll.length) {
-            lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }) => amount)));
-        }
-    }
-    return { allLocked, lockedBalance, lockedBreakdown, vestingLocked };
-}
-function calcShared(api, bestNumber, data, locks) {
-    const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
-    let transferable = null;
-    if (data?.frameSystemAccountInfo?.frozen) {
-        const { frameSystemAccountInfo, freeBalance, reservedBalance } = data;
-        const noFrozenReserved = frameSystemAccountInfo.frozen.isZero() && reservedBalance.isZero();
-        const ED = api.consts.balances.existentialDeposit;
-        const maybeED = noFrozenReserved ? new BN(0) : ED;
-        const frozenReserveDif = frameSystemAccountInfo.frozen.sub(reservedBalance);
-        transferable = api.registry.createType('Balance', allLocked
-            ? 0
-            : bnMax(new BN(0), freeBalance.sub(bnMax(maybeED, frozenReserveDif))));
-    }
-    return objectSpread({}, data, {
-        availableBalance: api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), data?.freeBalance ? data.freeBalance.sub(lockedBalance) : new BN(0))),
-        lockedBalance,
-        lockedBreakdown,
-        transferable,
-        vestingLocked
-    });
-}
-function calcVesting(bestNumber, shared, _vesting) {
-    // Calculate the vesting balances,
-    //  - offset = balance locked at startingBlock
-    //  - perBlock is the unlock amount
-    const vesting = _vesting || [];
-    const isVesting = !shared.vestingLocked.isZero();
-    const vestedBalances = vesting.map(({ locked, perBlock, startingBlock }) => bestNumber.gt(startingBlock)
-        ? bnMin(locked, perBlock.mul(bestNumber.sub(startingBlock)))
-        : BN_ZERO);
-    const vestedBalance = vestedBalances.reduce((all, value) => all.iadd(value), new BN(0));
-    const vestingTotal = vesting.reduce((all, { locked }) => all.iadd(locked), new BN(0));
-    return {
-        isVesting,
-        vestedBalance,
-        vestedClaimable: isVesting
-            ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance))
-            : BN_ZERO,
-        vesting: vesting
-            .map(({ locked, perBlock, startingBlock }, index) => ({
-            endBlock: locked.div(perBlock).iadd(startingBlock),
-            locked,
-            perBlock,
-            startingBlock,
-            vested: vestedBalances[index]
-        }))
-            .filter(({ locked }) => !locked.isZero()),
-        vestingTotal
-    };
-}
-function calcBalances(api, result) {
-    const [data, [vesting, allLocks, namedReserves], bestNumber] = result;
-    const shared = calcShared(api, bestNumber, data, allLocks[0]);
-    return objectSpread(shared, calcVesting(bestNumber, shared, vesting), {
-        accountId: data.accountId,
-        accountNonce: data.accountNonce,
-        additional: allLocks
-            .slice(1)
-            .map((l, index) => calcShared(api, bestNumber, data.additional[index], l)),
-        namedReserves
-    });
-}
-function queryOld(api, accountId) {
-    return combineLatest([
-        api.query.balances.locks(accountId),
-        api.query.balances['vesting'](accountId)
-    ]).pipe(map(([locks, optVesting]) => {
-        let vestingNew = null;
-        if (optVesting.isSome) {
-            const { offset: locked, perBlock, startingBlock } = optVesting.unwrap();
-            vestingNew = api.registry.createType('VestingInfo', { locked, perBlock, startingBlock });
-        }
-        return [
-            vestingNew
-                ? [vestingNew]
-                : null,
-            [locks],
-            []
-        ];
-    }));
-}
-const isNonNullable = (nullable) => !!nullable;
-function createCalls(calls) {
-    return [
-        calls.map((c) => !c),
-        calls.filter(isNonNullable)
-    ];
-}
-function queryCurrent(api, accountId, balanceInstances = ['balances']) {
-    const [lockEmpty, lockQueries] = createCalls(balanceInstances.map((m) => api.derive[m]?.customLocks || api.query[m]?.locks));
-    const [reserveEmpty, reserveQueries] = createCalls(balanceInstances.map((m) => api.query[m]?.reserves));
-    return combineLatest([
-        api.query.vesting?.vesting
-            ? api.query.vesting.vesting(accountId)
-            : of(api.registry.createType('Option<VestingInfo>')),
-        lockQueries.length
-            ? combineLatest(lockQueries.map((c) => c(accountId)))
-            : of([]),
-        reserveQueries.length
-            ? combineLatest(reserveQueries.map((c) => c(accountId)))
-            : of([])
-    ]).pipe(map(([opt, locks, reserves]) => {
-        let offsetLock = -1;
-        let offsetReserve = -1;
-        const vesting = opt.unwrapOr(null);
-        return [
-            vesting
-                ? Array.isArray(vesting)
-                    ? vesting
-                    : [vesting]
-                : null,
-            lockEmpty.map((e) => e ? api.registry.createType('Vec<BalanceLock>') : locks[++offsetLock]),
-            reserveEmpty.map((e) => e ? api.registry.createType('Vec<PezpalletBalancesReserveData>') : reserves[++offsetReserve])
-        ];
-    }));
-}
-/**
- * @name all
- * @description Retrieves the complete balance information for an account, including free balance, locked balance, reserved balance, and more.
- * @param {( AccountId | string )} address An accountsId in different formats.
- * @example
- * ```javascript
- * const ALICE = 'F7Hs';
- *
- * api.derive.balances.account(ALICE, (accountInfo) => {
- *   console.log(
- *     `${accountInfo.accountId} info:`,
- *     Object.keys(accountInfo).map((key) => `${key}: ${accountInfo[key]}`)
- *   );
- * });
- * ```
- */
-export function all(instanceId, api) {
-    const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
-    return memo(instanceId, (address) => combineLatest([
-        api.derive.balances.account(address),
-        isFunction(api.query.system?.account) || isFunction(api.query.balances?.account)
-            ? queryCurrent(api, address, balanceInstances)
-            : queryOld(api, address)
-    ]).pipe(switchMap(([account, locks]) => combineLatest([
-        of(account),
-        of(locks),
-        api.derive.chain.bestNumber()
-    ])), map((result) => calcBalances(api, result))));
-}

package/build-tsc-esm/balances/index.js

@@ -1,20 +0,0 @@
-import { all } from './all.js';
-export * from './account.js';
-export * from './votingBalances.js';
-/**
- * @name votingBalance
- * @param {( AccountId | string )} address An accounts Id in different formats.
- * @returns An object containing the results of various balance queries
- * @example
- * <BR>
- *
- * ```javascript
- * const ALICE = 'F7Hs';
- *
- * api.derive.balances.votingBalance(ALICE, ({ accountId, lockedBalance }) => {
- *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
- * });
- * ```
- */
-const votingBalance = all;
-export { all, votingBalance };

package/build-tsc-esm/balances/types.js

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

package/build-tsc-esm/balances/votingBalances.js

@@ -1,18 +0,0 @@
-import { combineLatest, of } from 'rxjs';
-import { memo } from '../util/index.js';
-/**
- * @name votingBalances
- * @description Retrieves the balance information for multiple accounts, typically used in governance-related contexts to check voting power.
- * @param {(AccountId | AccountIndex | Address | string)[]} addresses An array of account identifiers.
- * @example
- * ```javascript
- * const addresses = ["5D4b...Zf1", "5HGj...yrV"];
- * const balances = await api.derive.balances.votingBalances(addresses);
- * console.log("Voting Balances:", balances);
- * ```
- */
-export function votingBalances(instanceId, api) {
-    return memo(instanceId, (addresses) => !addresses?.length
-        ? of([])
-        : combineLatest(addresses.map((accountId) => api.derive.balances.account(accountId))));
-}

package/build-tsc-esm/bounties/bounties.js

@@ -1,50 +0,0 @@
-import { combineLatest, map, of, switchMap } from 'rxjs';
-import { memo } from '../util/index.js';
-import { filterBountiesProposals } from './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);
- * ```
- */
-export function bounties(instanceId, api) {
-    const bountyBase = api.query.bounties || api.query.treasury;
-    return memo(instanceId, () => bountyBase.bounties
-        ? combineLatest([
-            bountyBase.bountyCount(),
-            api.query.council
-                ? api.query.council.proposalCount()
-                : of(0)
-        ]).pipe(switchMap(() => combineLatest([
-            bountyBase.bounties.keys(),
-            api.derive.council
-                ? api.derive.council.proposals()
-                : of([])
-        ])), switchMap(([keys, proposals]) => {
-            const ids = keys.map(({ args: [id] }) => id);
-            return combineLatest([
-                bountyBase.bounties.multi(ids),
-                bountyBase.bountyDescriptions.multi(ids),
-                of(ids),
-                of(filterBountiesProposals(api, proposals))
-            ]);
-        }), map(parseResult))
-        : of(parseResult([[], [], [], []])));
-}

package/build-tsc-esm/bounties/helpers/filterBountyProposals.js

@@ -1,5 +0,0 @@
-export 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/build-tsc-esm/bounties/index.js

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

package/build-tsc-esm/bundle.js

@@ -1,107 +0,0 @@
-import { lazyDeriveSection } from './util/index.js';
-import { derive } from './derive.js';
-export * from './derive.js';
-export * from './type/index.js';
-export { lazyDeriveSection };
-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) &&
-            lazyDeriveSection(result, name, getKeys, creator);
-    }
-    return result;
-}
-/** @internal */
-export function getAvailableDerives(instanceId, api, custom = {}) {
-    return {
-        ...injectFunctions(instanceId, api, derive),
-        ...injectFunctions(instanceId, api, custom)
-    };
-}

package/build-tsc-esm/chain/bestNumber.js

@@ -1,12 +0,0 @@
-import { createBlockNumberDerive } from './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}`);
- * });
- * ```
- */
-export const bestNumber = /*#__PURE__*/ createBlockNumberDerive((api) => api.rpc.chain.subscribeNewHeads());

package/build-tsc-esm/chain/bestNumberFinalized.js

@@ -1,13 +0,0 @@
-import { createBlockNumberDerive } from './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}`);
- * });
- * ```
- */
-export const bestNumberFinalized = /*#__PURE__*/ createBlockNumberDerive((api) => api.rpc.chain.subscribeFinalizedHeads());

package/build-tsc-esm/chain/bestNumberLag.js

@@ -1,19 +0,0 @@
-import { combineLatest, map } from 'rxjs';
-import { memo } from '../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`);
- * });
- * ```
- */
-export function bestNumberLag(instanceId, api) {
-    return memo(instanceId, () => combineLatest([
-        api.derive.chain.bestNumber(),
-        api.derive.chain.bestNumberFinalized()
-    ]).pipe(map(([bestNumber, bestNumberFinalized]) => api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized)))));
-}

package/build-tsc-esm/chain/getBlock.js

@@ -1,25 +0,0 @@
-import { combineLatest, map, of, switchMap } from 'rxjs';
-import { createSignedBlockExtended } from '../type/index.js';
-import { memo } from '../util/index.js';
-import { getAuthorDetails } from './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}`);
- * ```
- */
-export function getBlock(instanceId, api) {
-    return memo(instanceId, (blockHash) => combineLatest([
-        api.rpc.chain.getBlock(blockHash),
-        api.queryAt(blockHash)
-    ]).pipe(switchMap(([signedBlock, queryAt]) => combineLatest([
-        of(signedBlock),
-        queryAt.system.events(),
-        getAuthorDetails(api, signedBlock.block.header, blockHash)
-    ])), map(([signedBlock, events, [, validators, author]]) => createSignedBlockExtended(events.registry, signedBlock, events, validators, author))));
-}

package/build-tsc-esm/chain/getBlockByNumber.js

@@ -1,16 +0,0 @@
-import { switchMap } from 'rxjs';
-import { memo } from '../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}`);
- * ```
- */
-export function getBlockByNumber(instanceId, api) {
-    return memo(instanceId, (blockNumber) => api.rpc.chain.getBlockHash(blockNumber).pipe(switchMap((h) => api.derive.chain.getBlock(h))));
-}

package/build-tsc-esm/chain/getHeader.js

@@ -1,19 +0,0 @@
-import { map, switchMap } from 'rxjs';
-import { createHeaderExtended } from '../type/index.js';
-import { memo } from '../util/index.js';
-import { getAuthorDetails } from './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}`);
- * ```
- */
-export function getHeader(instanceId, api) {
-    return memo(instanceId, (blockHash) => api.rpc.chain.getHeader(blockHash).pipe(switchMap((header) => getAuthorDetails(api, header, blockHash)), map(([header, validators, author]) => createHeaderExtended((validators || header).registry, header, validators, author))));
-}

package/build-tsc-esm/chain/index.js

@@ -1,10 +0,0 @@
-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/build-tsc-esm/chain/subscribeFinalizedBlocks.js

@@ -1,15 +0,0 @@
-import { switchMap } from 'rxjs';
-import { memo } from '../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}`);
- * });
- * ```
- */
-export function subscribeFinalizedBlocks(instanceId, api) {
-    return memo(instanceId, () => api.derive.chain.subscribeFinalizedHeads().pipe(switchMap((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
-}

package/build-tsc-esm/chain/subscribeFinalizedHeads.js

@@ -1,37 +0,0 @@
-import { from, of, switchMap } from 'rxjs';
-import { memo } from '../util/index.js';
-/**
- * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
- */
-export function _getHeaderRange(instanceId, api) {
-    return memo(instanceId, (startHash, endHash, prev = []) => api.rpc.chain.getHeader(startHash).pipe(switchMap((header) => header.parentHash.eq(endHash)
-        ? 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}`);
- * });
- * ```
- */
-export function subscribeFinalizedHeads(instanceId, api) {
-    return memo(instanceId, () => {
-        let prevHash = null;
-        return api.rpc.chain.subscribeFinalizedHeads().pipe(switchMap((header) => {
-            const endHash = prevHash;
-            const startHash = header.parentHash;
-            prevHash = header.createdAtHash = header.hash;
-            return endHash === null || startHash.eq(endHash)
-                ? of(header)
-                : api.derive.chain._getHeaderRange(startHash, endHash, [header]).pipe(switchMap((headers) => from(headers)));
-        }));
-    });
-}

package/build-tsc-esm/chain/subscribeNewBlocks.js

@@ -1,15 +0,0 @@
-import { switchMap } from 'rxjs';
-import { memo } from '../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}`);
- * });
- * ```
- */
-export function subscribeNewBlocks(instanceId, api) {
-    return memo(instanceId, () => api.derive.chain.subscribeNewHeads().pipe(switchMap((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
-}

package/build-tsc-esm/chain/subscribeNewHeads.js

@@ -1,21 +0,0 @@
-import { map, switchMap } from 'rxjs';
-import { createHeaderExtended } from '../type/index.js';
-import { memo } from '../util/index.js';
-import { getAuthorDetails } from './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}`);
- * });
- * ```
- */
-export function subscribeNewHeads(instanceId, api) {
-    return memo(instanceId, () => api.rpc.chain.subscribeNewHeads().pipe(switchMap((header) => getAuthorDetails(api, header)), map(([header, validators, author]) => {
-        header.createdAtHash = header.hash;
-        return createHeaderExtended(header.registry, header, validators, author);
-    })));
-}

package/build-tsc-esm/chain/util.js

@@ -1,57 +0,0 @@
-import { combineLatest, map, mergeMap, of, switchMap } from 'rxjs';
-import { memo, unwrapBlockNumber } from '../util/index.js';
-export function createBlockNumberDerive(fn) {
-    return (instanceId, api) => memo(instanceId, () => fn(api).pipe(map(unwrapBlockNumber)));
-}
-/** @internal */
-function getAuthorDetailsWithAt(header, queryAt) {
-    const validators = queryAt.session?.validators
-        ? queryAt.session.validators()
-        : of(null);
-    // nimbus consensus stores the session key of the block author in header logs
-    const { logs: [log] } = header.digest;
-    const loggedAuthor = (log && ((log.isConsensus && log.asConsensus[0].isNimbus && log.asConsensus[1]) ||
-        (log.isPreRuntime && log.asPreRuntime[0].isNimbus && log.asPreRuntime[1])));
-    if (loggedAuthor) {
-        // use the author mapping pallet, if available (ie: moonbeam, moonriver), to map session (nimbus) key to author (collator/validator) key
-        if (queryAt['authorMapping']?.['mappingWithDeposit']) {
-            return combineLatest([
-                of(header),
-                validators,
-                queryAt['authorMapping']['mappingWithDeposit'](loggedAuthor).pipe(map((o) => o.unwrapOr({ account: null }).account))
-            ]);
-        }
-        // fall back to session and teyrchain staking pallets, if available (ie: manta, calamari), to map session (nimbus) key to author (collator) key
-        if (queryAt['teyrchainStaking']?.['selectedCandidates'] && queryAt.session?.nextKeys) {
-            const loggedHex = loggedAuthor.toHex();
-            return combineLatest([
-                of(header),
-                validators,
-                queryAt['teyrchainStaking']['selectedCandidates']().pipe(mergeMap((selectedCandidates) => combineLatest([
-                    of(selectedCandidates),
-                    queryAt.session.nextKeys.multi(selectedCandidates).pipe(map((nextKeys) => nextKeys.findIndex((o) => o.unwrapOrDefault().nimbus.toHex() === loggedHex)))
-                ])), map(([selectedCandidates, index]) => index === -1
-                    ? null
-                    : selectedCandidates[index]))
-            ]);
-        }
-    }
-    // normal operation, non-mapping
-    return combineLatest([
-        of(header),
-        validators,
-        of(null)
-    ]);
-}
-export function getAuthorDetails(api, header, blockHash) {
-    // For on-chain state, we need to retrieve it as per the start
-    // of the block being constructed, i.e. session validators would
-    // be at the point of the block construction, not when all operations
-    // has been supplied.
-    //
-    // However for the first block (no parentHash available), we would
-    // just use the as-is
-    return api.queryAt(header.parentHash.isEmpty
-        ? blockHash || header.hash
-        : header.parentHash).pipe(switchMap((queryAt) => getAuthorDetailsWithAt(header, queryAt)));
-}