@pezkuwi/api-derive 16.5.5 → 16.5.6

package/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/derive.d.ts

@@ -0,0 +1,52 @@
+import type { AnyFunction } from '@pezkuwi/types/types';
+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 teyrchains from './teyrchains/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 treasury from './treasury/index.js';
+import * as tx from './tx/index.js';
+export declare const derive: {
+    accounts: typeof accounts;
+    alliance: typeof alliance;
+    bagsList: typeof bagsList;
+    balances: typeof balances;
+    bounties: typeof bounties;
+    chain: typeof chain;
+    contracts: typeof contracts;
+    council: typeof council;
+    crowdloan: typeof crowdloan;
+    democracy: typeof democracy;
+    elections: typeof elections;
+    imOnline: typeof imOnline;
+    membership: typeof membership;
+    teyrchains: typeof teyrchains;
+    session: typeof session;
+    society: typeof society;
+    staking: typeof staking;
+    technicalCommittee: typeof technicalCommittee;
+    treasury: typeof treasury;
+    tx: typeof tx;
+};
+type DeriveSection<Section> = {
+    [M in keyof Section]: Section[M] extends AnyFunction ? ReturnType<Section[M]> : never;
+};
+type DeriveAllSections<AllSections> = {
+    [S in keyof AllSections]: DeriveSection<AllSections[S]>;
+};
+export interface ExactDerive extends DeriveAllSections<typeof derive> {
+}
+export {};

package/{src/derive.ts → derive.js}

@@ -1,8 +1,3 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyFunction } from '@pezkuwi/types/types';
-
 import * as accounts from './accounts/index.js';
 import * as alliance from './alliance/index.js';
 import * as bagsList from './bagsList/index.js';
@@ -16,26 +11,11 @@ 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 parachains from './parachains/index.js';
+import * as teyrchains from './teyrchains/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 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, parachains, session, society, staking, technicalCommittee, treasury, tx };
-
-type DeriveSection<Section> = {
-  [M in keyof Section]: Section[M] extends AnyFunction
-    ? ReturnType<Section[M]> // ReturnType<Section[Method]> will be the inner function, i.e. without (api) argument
-    : never;
-};
-type DeriveAllSections<AllSections> = {
-  [S in keyof AllSections]: DeriveSection<AllSections[S]>
-};
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ExactDerive extends DeriveAllSections<typeof derive> {
-  // keep empty, allows for augmentation
-}
+export const derive = { accounts, alliance, bagsList, balances, bounties, chain, contracts, council, crowdloan, democracy, elections, imOnline, membership, teyrchains, session, society, staking, technicalCommittee, treasury, tx };

package/elections/index.d.ts

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

package/elections/index.js

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

package/elections/info.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { DeriveElectionsInfo } from './types.js';
+/**
+ * @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 declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveElectionsInfo>;

package/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/elections/types.d.ts

@@ -0,0 +1,18 @@
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BlockNumber, SetIndex, VoteIndex } from '@pezkuwi/types/interfaces';
+export interface DeriveElectionsInfo {
+    candidates: AccountId[];
+    candidateCount: u32;
+    candidacyBond?: Balance;
+    desiredRunnersUp?: u32;
+    desiredSeats?: u32;
+    members: [AccountId, Balance][];
+    nextVoterSet?: SetIndex;
+    runnersUp: [AccountId, Balance][];
+    termDuration?: BlockNumber;
+    voteCount?: VoteIndex;
+    voterCount?: SetIndex;
+    votingBond?: Balance;
+    votingBondBase?: Balance;
+    votingBondFactor?: Balance;
+}

package/elections/types.js

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

package/imOnline/index.d.ts

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

package/imOnline/index.js

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

package/imOnline/receivedHeartbeats.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveHeartbeats } from '../types.js';
+/**
+ * @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 declare function receivedHeartbeats(instanceId: string, api: DeriveApi): () => Observable<DeriveHeartbeats>;

package/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/index.d.ts

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

package/index.js

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

package/membership/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @name members
+ * @description Retrieves the list of members in the "membership" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.membership.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 "membership" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.membership.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "membership" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.membership.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 "membership" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.membership.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 "membership" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.membership.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 "membership" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.membership.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "membership" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.membership.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export declare const prime: import("../collective/types.js").PrimeFnRet;

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

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