@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-tsc-esm/democracy/preimages.js

@@ -0,0 +1,113 @@
+import { map, of, switchMap } from 'rxjs';
+import { BN_ZERO, isFunction } from '@pezkuwi/util';
+import { firstMemo, memo } from '../util/index.js';
+import { getImageHashBounded } from './util.js';
+function getUnrequestedTicket(status) {
+    return status.ticket || status.deposit;
+}
+function getRequestedTicket(status) {
+    return (status.maybeTicket || status.deposit).unwrapOrDefault();
+}
+function isDemocracyPreimage(api, imageOpt) {
+    return !!imageOpt && !api.query.democracy['dispatchQueue'];
+}
+function constructProposal(api, [bytes, proposer, balance, at]) {
+    let proposal;
+    try {
+        proposal = api.registry.createType('Call', bytes.toU8a(true));
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return { at, balance, proposal, proposer };
+}
+function parseDemocracy(api, imageOpt) {
+    if (imageOpt.isNone) {
+        return;
+    }
+    if (isDemocracyPreimage(api, imageOpt)) {
+        const status = imageOpt.unwrap();
+        if (status.isMissing) {
+            return;
+        }
+        const { data, deposit, provider, since } = status.asAvailable;
+        return constructProposal(api, [data, provider, deposit, since]);
+    }
+    return constructProposal(api, imageOpt.unwrap());
+}
+function parseImage(api, [proposalHash, status, bytes]) {
+    if (!status) {
+        return undefined;
+    }
+    const [proposer, balance] = status.isUnrequested
+        ? getUnrequestedTicket(status.asUnrequested)
+        : getRequestedTicket(status.asRequested);
+    let proposal;
+    if (bytes) {
+        try {
+            proposal = api.registry.createType('Call', bytes.toU8a(true));
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    return { at: BN_ZERO, balance, proposal, proposalHash, proposer };
+}
+function getDemocracyImages(api, bounded) {
+    const hashes = bounded.map((b) => getImageHashBounded(b));
+    return api.query.democracy['preimages'].multi(hashes).pipe(map((images) => images.map((imageOpt) => parseDemocracy(api, imageOpt))));
+}
+function getImages(api, bounded) {
+    const hashes = bounded.map((b) => getImageHashBounded(b));
+    const bytesType = api.registry.lookup.getTypeDef(api.query.preimage.preimageFor.creator.meta.type.asMap.key).type;
+    return api.query.preimage.statusFor.multi(hashes).pipe(switchMap((optStatus) => {
+        const statuses = optStatus.map((o) => o.unwrapOr(null));
+        const keys = statuses
+            .map((s, i) => s
+            ? bytesType === 'H256'
+                // first generation
+                ? hashes[i]
+                // current generation (H256,u32)
+                : s.isRequested
+                    ? [hashes[i], s.asRequested.len.unwrapOr(0)]
+                    : [hashes[i], s.asUnrequested.len]
+            : null)
+            .filter((p) => !!p);
+        return api.query.preimage.preimageFor.multi(keys).pipe(map((optBytes) => {
+            let ptr = -1;
+            return statuses
+                .map((s, i) => s
+                ? [hashes[i], s, optBytes[++ptr].unwrapOr(null)]
+                : [hashes[i], null, null])
+                .map((v) => parseImage(api, v));
+        }));
+    }));
+}
+/**
+ * @name preimages
+ * @description Retrieves the full details (preimages) of governance proposals using their on-chain hashes.
+ * @param { (Hash | Uint8Array | string | PezframeSupportPreimagesBounded)[] } hashes An array of hashes representing governance proposals.
+ * @example
+ * ```javascript
+ * const preimages = await api.derive.democracy.preimages([HASH1, HASH2]);
+ * ```
+ */
+export function preimages(instanceId, api) {
+    return memo(instanceId, (hashes) => hashes.length
+        ? isFunction(api.query.democracy['preimages'])
+            ? getDemocracyImages(api, hashes)
+            : isFunction(api.query.preimage.preimageFor)
+                ? getImages(api, hashes)
+                : of([])
+        : of([]));
+}
+/**
+ * @name preimage
+ * @description Retrieves the full details (preimage) of a governance proposal using its on-chain hash.
+ * @param { Hash | Uint8Array | string | PezframeSupportPreimagesBounded } hash Hash that represents governance proposals.
+ *  * @example
+ * ```javascript
+ * const preimage = await api.derive.democracy.preimage(HASH);
+ * ```
+ */
+export const preimage = /*#__PURE__*/ firstMemo((api, hash) => api.derive.democracy.preimages([hash]));

package/build-tsc-esm/democracy/proposals.js

@@ -0,0 +1,43 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { isFunction, objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { getImageHashBounded } from './util.js';
+function isNewDepositors(depositors) {
+    // Detect balance...
+    return isFunction(depositors[1].mul);
+}
+function parse([proposals, images, optDepositors]) {
+    return proposals
+        .filter(([, , proposer], index) => !!(optDepositors[index]?.isSome) && !proposer.isEmpty)
+        .map(([index, hash, proposer], proposalIndex) => {
+        const depositors = optDepositors[proposalIndex].unwrap();
+        return objectSpread({
+            image: images[proposalIndex],
+            imageHash: getImageHashBounded(hash),
+            index,
+            proposer
+        }, isNewDepositors(depositors)
+            ? { balance: depositors[1], seconds: depositors[0] }
+            : { balance: depositors[0], seconds: depositors[1] });
+    });
+}
+/**
+ * @name proposals
+ * @description Retrieves the list of active public proposals in the democracy module, along with their associated preimage data and deposit information.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.democracy.proposals();
+ * console.log("proposals:", proposals);
+ * ```
+ */
+export function proposals(instanceId, api) {
+    return memo(instanceId, () => isFunction(api.query.democracy?.publicProps)
+        ? api.query.democracy.publicProps().pipe(switchMap((proposals) => proposals.length
+            ? combineLatest([
+                of(proposals),
+                api.derive.democracy.preimages(proposals.map(([, hash]) => hash)),
+                api.query.democracy.depositOf.multi(proposals.map(([index]) => index))
+            ])
+            : of([[], [], []])), map(parse))
+        : of([]));
+}

package/build-tsc-esm/democracy/referendumIds.js

@@ -0,0 +1,21 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name referendumIds
+ * @description Retrieves an array of active referendum IDs.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumIds();
+ * ```
+ */
+export function referendumIds(instanceId, api) {
+    return memo(instanceId, () => api.query.democracy?.lowestUnbaked
+        ? api.queryMulti([
+            api.query.democracy.lowestUnbaked,
+            api.query.democracy.referendumCount
+        ]).pipe(map(([first, total]) => total.gt(first)
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            ? [...Array(total.sub(first).toNumber())].map((_, i) => first.addn(i))
+            : []))
+        : of([]));
+}

package/build-tsc-esm/democracy/referendums.js

@@ -0,0 +1,19 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+/**
+ * @name referendums
+ * @description Retrieves information about all active referendums, including their details and associated votes.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendums();
+ * ```
+ */
+export function referendums(instanceId, api) {
+    return memo(instanceId, () => api.derive.democracy.referendumsActive().pipe(switchMap((referendums) => referendums.length
+        ? combineLatest([
+            of(referendums),
+            api.derive.democracy._referendumsVotes(referendums)
+        ])
+        : of([[], []])), map(([referendums, votes]) => referendums.map((referendum, index) => objectSpread({}, referendum, votes[index])))));
+}

package/build-tsc-esm/democracy/referendumsActive.js

@@ -0,0 +1,16 @@
+import { of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name referendumsActive
+ * @description Retrieves information about active referendums.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumsActive();
+ * console.log("Active Referendums:", referendums);
+ * ```
+ */
+export function referendumsActive(instanceId, api) {
+    return memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap((ids) => ids.length
+        ? api.derive.democracy.referendumsInfo(ids)
+        : of([]))));
+}

package/build-tsc-esm/democracy/referendumsFinished.js

@@ -0,0 +1,17 @@
+import { map, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name referendumsFinished
+ * @description Retrieves information about finished referendums.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumsFinished();
+ * console.log("Finished Referendums:", referendums);
+ * ```
+ */
+export function referendumsFinished(instanceId, api) {
+    return memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap((ids) => api.query.democracy.referendumInfoOf.multi(ids)), map((infos) => infos
+        .map((o) => o.unwrapOr(null))
+        .filter((info) => !!info && info.isFinished)
+        .map((info) => info.asFinished))));
+}

package/build-tsc-esm/democracy/referendumsInfo.js

@@ -0,0 +1,108 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { isFunction, objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { calcVotes, getImageHash, getStatus } from './util.js';
+function votesPrev(api, referendumId) {
+    return api.query.democracy['votersFor'](referendumId).pipe(switchMap((votersFor) => combineLatest([
+        of(votersFor),
+        votersFor.length
+            ? api.query.democracy['voteOf'].multi(votersFor.map((accountId) => [referendumId, accountId]))
+            : of([]),
+        api.derive.balances.votingBalances(votersFor)
+    ])), map(([votersFor, votes, balances]) => votersFor.map((accountId, index) => ({
+        accountId,
+        balance: balances[index].votingBalance || api.registry.createType('Balance'),
+        isDelegating: false,
+        vote: votes[index] || api.registry.createType('Vote')
+    }))));
+}
+function extractVotes(mapped, referendumId) {
+    return mapped
+        .filter(([, voting]) => voting.isDirect)
+        .map(([accountId, voting]) => [
+        accountId,
+        voting.asDirect.votes.filter(([idx]) => idx.eq(referendumId))
+    ])
+        .filter(([, directVotes]) => !!directVotes.length)
+        .reduce((result, [accountId, votes]) => 
+    // FIXME We are ignoring split votes
+    votes.reduce((result, [, vote]) => {
+        if (vote.isStandard) {
+            result.push(objectSpread({
+                accountId,
+                isDelegating: false
+            }, vote.asStandard));
+        }
+        return result;
+    }, result), []);
+}
+function votesCurr(api, referendumId) {
+    return api.query.democracy.votingOf.entries().pipe(map((allVoting) => {
+        const mapped = allVoting.map(([{ args: [accountId] }, voting]) => [accountId, voting]);
+        const votes = extractVotes(mapped, referendumId);
+        const delegations = mapped
+            .filter(([, voting]) => voting.isDelegating)
+            .map(([accountId, voting]) => [accountId, voting.asDelegating]);
+        // add delegations
+        delegations.forEach(([accountId, { balance, conviction, target }]) => {
+            // Are we delegating to a delegator
+            const toDelegator = delegations.find(([accountId]) => accountId.eq(target));
+            const to = votes.find(({ accountId }) => accountId.eq(toDelegator ? toDelegator[0] : target));
+            // this delegation has a target
+            if (to) {
+                votes.push({
+                    accountId,
+                    balance,
+                    isDelegating: true,
+                    vote: api.registry.createType('Vote', { aye: to.vote.isAye, conviction })
+                });
+            }
+        });
+        return votes;
+    }));
+}
+export function _referendumVotes(instanceId, api) {
+    return memo(instanceId, (referendum) => combineLatest([
+        api.derive.democracy.sqrtElectorate(),
+        isFunction(api.query.democracy.votingOf)
+            ? votesCurr(api, referendum.index)
+            : votesPrev(api, referendum.index)
+    ]).pipe(map(([sqrtElectorate, votes]) => calcVotes(sqrtElectorate, referendum, votes))));
+}
+export function _referendumsVotes(instanceId, api) {
+    return memo(instanceId, (referendums) => referendums.length
+        ? combineLatest(referendums.map((referendum) => api.derive.democracy._referendumVotes(referendum)))
+        : of([]));
+}
+export function _referendumInfo(instanceId, api) {
+    return memo(instanceId, (index, info) => {
+        const status = getStatus(info);
+        return status
+            ? api.derive.democracy.preimage(status.proposal ||
+                status.proposalHash).pipe(map((image) => ({
+                image,
+                imageHash: getImageHash(status),
+                index: api.registry.createType('ReferendumIndex', index),
+                status
+            })))
+            : of(null);
+    });
+}
+/**
+ * @name referendumsInfo
+ * @description Retrieves information about multiple referendums by their IDs.
+ * @param {BN[]} ids An array of referendum IDs to query.
+ * @example
+ * ```javascript
+ * import { BN } from "@pezkuwi/util";
+ *
+ * const referendumIds = [new BN(1)];
+ * const referendums = await api.derive.democracy.referendumsInfo(referendumIds);
+ * console.log("Referendums Info:", referendums);
+ * ```
+ */
+export function referendumsInfo(instanceId, api) {
+    return memo(instanceId, (ids) => ids.length
+        ? api.query.democracy.referendumInfoOf.multi(ids).pipe(switchMap((infos) => combineLatest(ids.map((id, index) => api.derive.democracy._referendumInfo(id, infos[index])))), map((infos) => infos.filter((r) => !!r)))
+        : of([]));
+}

package/build-tsc-esm/democracy/sqrtElectorate.js

@@ -0,0 +1,15 @@
+import { map } from 'rxjs';
+import { bnSqrt } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+/**
+ * @name sqrtElectorate
+ * @description Computes the square root of the total token issuance in the network.
+ * @example
+ * ```javascript
+ * let sqrtElectorate = await api.derive.democracy.sqrtElectorate();
+ * console.log("Square root of token issuance:", sqrtElectorate);
+ * ```
+ */
+export function sqrtElectorate(instanceId, api) {
+    return memo(instanceId, () => api.query.balances.totalIssuance().pipe(map(bnSqrt)));
+}

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

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

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

@@ -0,0 +1,129 @@
+import { BN, bnSqrt, isHex, isString, isU8a, objectSpread, stringToHex, u8aToHex } from '@pezkuwi/util';
+function isOldInfo(info) {
+    return !!info.proposalHash;
+}
+function isCurrentStatus(status) {
+    return !!status.tally;
+}
+export function compareRationals(n1, d1, n2, d2) {
+    while (true) {
+        const q1 = n1.div(d1);
+        const q2 = n2.div(d2);
+        if (q1.lt(q2)) {
+            return true;
+        }
+        else if (q2.lt(q1)) {
+            return false;
+        }
+        const r1 = n1.mod(d1);
+        const r2 = n2.mod(d2);
+        if (r2.isZero()) {
+            return false;
+        }
+        else if (r1.isZero()) {
+            return true;
+        }
+        n1 = d2;
+        n2 = d1;
+        d1 = r2;
+        d2 = r1;
+    }
+}
+function calcPassingOther(threshold, sqrtElectorate, { votedAye, votedNay, votedTotal }) {
+    const sqrtVoters = bnSqrt(votedTotal);
+    return sqrtVoters.isZero()
+        ? false
+        : threshold.isSuperMajorityApprove
+            ? compareRationals(votedNay, sqrtVoters, votedAye, sqrtElectorate)
+            : compareRationals(votedNay, sqrtElectorate, votedAye, sqrtVoters);
+}
+export function calcPassing(threshold, sqrtElectorate, state) {
+    return threshold.isSimpleMajority
+        ? state.votedAye.gt(state.votedNay)
+        : calcPassingOther(threshold, sqrtElectorate, state);
+}
+function calcVotesPrev(votesFor) {
+    return votesFor.reduce((state, derived) => {
+        const { balance, vote } = derived;
+        const isDefault = vote.conviction.index === 0;
+        const counted = balance
+            .muln(isDefault ? 1 : vote.conviction.index)
+            .divn(isDefault ? 10 : 1);
+        if (vote.isAye) {
+            state.allAye.push(derived);
+            state.voteCountAye++;
+            state.votedAye.iadd(counted);
+        }
+        else {
+            state.allNay.push(derived);
+            state.voteCountNay++;
+            state.votedNay.iadd(counted);
+        }
+        state.voteCount++;
+        state.votedTotal.iadd(counted);
+        return state;
+    }, { allAye: [], allNay: [], voteCount: 0, voteCountAye: 0, voteCountNay: 0, votedAye: new BN(0), votedNay: new BN(0), votedTotal: new BN(0) });
+}
+function calcVotesCurrent(tally, votes) {
+    const allAye = [];
+    const allNay = [];
+    votes.forEach((derived) => {
+        if (derived.vote.isAye) {
+            allAye.push(derived);
+        }
+        else {
+            allNay.push(derived);
+        }
+    });
+    return {
+        allAye,
+        allNay,
+        voteCount: allAye.length + allNay.length,
+        voteCountAye: allAye.length,
+        voteCountNay: allNay.length,
+        votedAye: tally.ayes,
+        votedNay: tally.nays,
+        votedTotal: tally.turnout
+    };
+}
+export function calcVotes(sqrtElectorate, referendum, votes) {
+    const state = isCurrentStatus(referendum.status)
+        ? calcVotesCurrent(referendum.status.tally, votes)
+        : calcVotesPrev(votes);
+    return objectSpread({}, state, {
+        isPassing: calcPassing(referendum.status.threshold, sqrtElectorate, state),
+        votes
+    });
+}
+export function getStatus(info) {
+    if (info.isNone) {
+        return null;
+    }
+    const unwrapped = info.unwrap();
+    return isOldInfo(unwrapped)
+        ? unwrapped
+        : unwrapped.isOngoing
+            ? unwrapped.asOngoing
+            // done, we don't include it here... only currently active
+            : null;
+}
+export function getImageHashBounded(hash) {
+    return hash.isLegacy
+        ? hash.asLegacy.hash_.toHex()
+        : hash.isLookup
+            ? hash.asLookup.hash_.toHex()
+            // for inline, use the actual Bytes hash
+            : hash.isInline
+                ? hash.asInline.hash.toHex()
+                : isString(hash)
+                    ? isHex(hash)
+                        ? hash
+                        : stringToHex(hash)
+                    : isU8a(hash)
+                        ? u8aToHex(hash)
+                        : hash.toHex();
+}
+export function getImageHash(status) {
+    return getImageHashBounded(status.proposal ||
+        status.proposalHash);
+}

package/build-tsc-esm/derive.js

@@ -0,0 +1,21 @@
+import * as accounts from './accounts/index.js';
+import * as alliance from './alliance/index.js';
+import * as bagsList from './bagsList/index.js';
+import * as balances from './balances/index.js';
+import * as bounties from './bounties/index.js';
+import * as chain from './chain/index.js';
+import * as contracts from './contracts/index.js';
+import * as council from './council/index.js';
+import * as crowdloan from './crowdloan/index.js';
+import * as democracy from './democracy/index.js';
+import * as elections from './elections/index.js';
+import * as imOnline from './imOnline/index.js';
+import * as membership from './membership/index.js';
+import * as session from './session/index.js';
+import * as society from './society/index.js';
+import * as staking from './staking/index.js';
+import * as technicalCommittee from './technicalCommittee/index.js';
+import * as teyrchains from './teyrchains/index.js';
+import * as treasury from './treasury/index.js';
+import * as tx from './tx/index.js';
+export const derive = { accounts, alliance, bagsList, balances, bounties, chain, contracts, council, crowdloan, democracy, elections, imOnline, membership, teyrchains, session, society, staking, technicalCommittee, treasury, tx };

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

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

package/build-tsc-esm/elections/info.js

@@ -0,0 +1,90 @@
+import { combineLatest, map, of } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function isSeatHolder(value) {
+    return !Array.isArray(value);
+}
+function isCandidateTuple(value) {
+    return Array.isArray(value);
+}
+function getAccountTuple(value) {
+    return isSeatHolder(value)
+        ? [value.who, value.stake]
+        : value;
+}
+function getCandidate(value) {
+    return isCandidateTuple(value)
+        ? value[0]
+        : value;
+}
+function sortAccounts([, balanceA], [, balanceB]) {
+    return balanceB.cmp(balanceA);
+}
+function getConstants(api, elections) {
+    return elections
+        ? {
+            candidacyBond: api.consts[elections].candidacyBond,
+            desiredRunnersUp: api.consts[elections].desiredRunnersUp,
+            desiredSeats: api.consts[elections].desiredMembers,
+            termDuration: api.consts[elections].termDuration,
+            votingBond: api.consts[elections]['votingBond'],
+            votingBondBase: api.consts[elections].votingBondBase,
+            votingBondFactor: api.consts[elections].votingBondFactor
+        }
+        : {};
+}
+function getModules(api) {
+    const [council] = api.registry.getModuleInstances(api.runtimeVersion.specName, 'council') || ['council'];
+    const elections = api.query['phragmenElection']
+        ? 'phragmenElection'
+        : api.query['electionsPhragmen']
+            ? 'electionsPhragmen'
+            : api.query.elections
+                ? 'elections'
+                : null;
+    // In some cases council here can refer to `generalCouncil` depending on what the chain specific override is.
+    // Therefore, we check to see if it exists in the query field. If it does not we default to `council`.
+    const resolvedCouncil = api.query[council] ? council : 'council';
+    return [resolvedCouncil, elections];
+}
+function queryAll(api, council, elections) {
+    return api.queryMulti([
+        api.query[council].members,
+        api.query[elections].candidates,
+        api.query[elections].members,
+        api.query[elections].runnersUp
+    ]);
+}
+function queryCouncil(api, council) {
+    return combineLatest([
+        api.query[council].members(),
+        of([]),
+        of([]),
+        of([])
+    ]);
+}
+/**
+ * @name info
+ * @description An object containing the combined results of the storage queries for all relevant election module properties.
+ * @example
+ * ```javascript
+ * api.derive.elections.info(({ members, candidates }) => {
+ *   console.log(`There are currently ${members.length} council members and ${candidates.length} prospective council candidates.`);
+ * });
+ * ```
+ */
+export function info(instanceId, api) {
+    return memo(instanceId, () => {
+        const [council, elections] = getModules(api);
+        return (elections
+            ? queryAll(api, council, elections)
+            : queryCouncil(api, council)).pipe(map(([councilMembers, candidates, members, runnersUp]) => objectSpread({}, getConstants(api, elections), {
+            candidateCount: api.registry.createType('u32', candidates.length),
+            candidates: candidates.map(getCandidate),
+            members: members.length
+                ? members.map(getAccountTuple).sort(sortAccounts)
+                : councilMembers.map((a) => [a, api.registry.createType('Balance')]),
+            runnersUp: runnersUp.map(getAccountTuple).sort(sortAccounts)
+        })));
+    });
+}

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

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

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

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

package/build-tsc-esm/imOnline/receivedHeartbeats.js

@@ -0,0 +1,39 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { BN_ZERO } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function mapResult([result, validators, heartbeats, numBlocks]) {
+    validators.forEach((validator, index) => {
+        const validatorId = validator.toString();
+        const blockCount = numBlocks[index];
+        const hasMessage = !heartbeats[index].isEmpty;
+        const prev = result[validatorId];
+        if (!prev || prev.hasMessage !== hasMessage || !prev.blockCount.eq(blockCount)) {
+            result[validatorId] = {
+                blockCount,
+                hasMessage,
+                isOnline: hasMessage || blockCount.gt(BN_ZERO)
+            };
+        }
+    });
+    return result;
+}
+/**
+ * @name receivedHeartbeats
+ * @description Return a boolean array indicating whether the passed accounts had received heartbeats in the current session.
+ * @example
+ * ```javascript
+ * let unsub = await api.derive.imOnline.receivedHeartbeats((heartbeat) => {
+ *   console.log(heartbeat);
+ * });
+ * ```
+ */
+export function receivedHeartbeats(instanceId, api) {
+    return memo(instanceId, () => api.query.imOnline?.receivedHeartbeats
+        ? api.derive.staking.overview().pipe(switchMap(({ currentIndex, validators }) => combineLatest([
+            of({}),
+            of(validators),
+            api.query.imOnline.receivedHeartbeats.multi(validators.map((_address, index) => [currentIndex, index])),
+            api.query.imOnline.authoredBlocks.multi(validators.map((address) => [currentIndex, address]))
+        ])), map(mapResult))
+        : of({}));
+}

package/build-tsc-esm/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';