@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/type/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignedBlockExtended = exports.createHeaderExtended = void 0;
+var HeaderExtended_js_1 = require("./HeaderExtended.js");
+Object.defineProperty(exports, "createHeaderExtended", { enumerable: true, get: function () { return HeaderExtended_js_1.createHeaderExtended; } });
+var SignedBlockExtended_js_1 = require("./SignedBlockExtended.js");
+Object.defineProperty(exports, "createSignedBlockExtended", { enumerable: true, get: function () { return SignedBlockExtended_js_1.createSignedBlockExtended; } });

package/cjs/type/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/type/util.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAuthor = extractAuthor;
+function extractAuthor(digest, sessionValidators) {
+    const [citem] = digest.logs.filter((e) => e.isConsensus);
+    const preRuntimeItems = digest.logs.filter((e) => e.isPreRuntime);
+    const [sitem] = digest.logs.filter((e) => e.isSeal);
+    let accountId;
+    try {
+        // This is critical to be first for BABE (before Consensus)
+        // If not first, we end up dropping the author at session-end
+        // Iterate through ALL preRuntime logs to find a recognized engine
+        // (teyrchains may have multiple preRuntime logs, e.g., CMLS + aura)
+        for (const pitem of preRuntimeItems) {
+            const [engine, data] = pitem.asPreRuntime;
+            accountId = engine.extractAuthor(data, sessionValidators);
+            // Stop at first recognized engine that returns an author
+            if (accountId) {
+                return accountId;
+            }
+        }
+        if (!accountId && citem) {
+            const [engine, data] = citem.asConsensus;
+            accountId = engine.extractAuthor(data, sessionValidators);
+        }
+        // SEAL, still used in e.g. Kulupu for pow
+        if (!accountId && sitem) {
+            const [engine, data] = sitem.asSeal;
+            accountId = engine.extractAuthor(data, sessionValidators);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return accountId;
+}

package/{build → cjs}/types.d.ts

@@ -1,7 +1,7 @@
 import type { ApiInterfaceRx } from '@pezkuwi/api-base/types';
 import type { u32 } from '@pezkuwi/types';
 import type { Balance, BlockNumber, BountyIndex, Hash, Proposal, ProposalIndex, SetIndex, Votes } from '@pezkuwi/types/interfaces';
-import type { PalletBountiesBounty, PalletTreasuryProposal } from '@pezkuwi/types/lookup';
+import type { PezpalletBountiesBounty, PezpalletTreasuryProposal } from '@pezkuwi/types/lookup';
 import type { BN } from '@pezkuwi/util';
 import type { ExactDerive } from './derive.js';
 export * from './accounts/types.js';
@@ -11,7 +11,7 @@ export * from './council/types.js';
 export * from './crowdloan/types.js';
 export * from './democracy/types.js';
 export * from './elections/types.js';
-export * from './parachains/types.js';
+export * from './teyrchains/types.js';
 export * from './session/types.js';
 export * from './society/types.js';
 export * from './staking/types.js';
@@ -57,7 +57,7 @@ export type DeriveRecentlyOffline = Record<string, RecentlyOffline[]>;
 export interface DeriveTreasuryProposal {
     council: DeriveCollectiveProposal[];
     id: ProposalIndex;
-    proposal: PalletTreasuryProposal;
+    proposal: PezpalletTreasuryProposal;
 }
 export interface DeriveTreasuryProposals {
     approvals: DeriveTreasuryProposal[];
@@ -71,7 +71,7 @@ export interface VoterPosition {
 }
 export type DeriveVoterPositions = Record<string, VoterPosition>;
 export interface DeriveBounty {
-    bounty: PalletBountiesBounty;
+    bounty: PezpalletBountiesBounty;
     description: string;
     index: BountyIndex;
     proposals: DeriveCollectiveProposal[];

package/cjs/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./accounts/types.js"), exports);
+tslib_1.__exportStar(require("./bagsList/types.js"), exports);
+tslib_1.__exportStar(require("./balances/types.js"), exports);
+tslib_1.__exportStar(require("./council/types.js"), exports);
+tslib_1.__exportStar(require("./crowdloan/types.js"), exports);
+tslib_1.__exportStar(require("./democracy/types.js"), exports);
+tslib_1.__exportStar(require("./elections/types.js"), exports);
+tslib_1.__exportStar(require("./teyrchains/types.js"), exports);
+tslib_1.__exportStar(require("./session/types.js"), exports);
+tslib_1.__exportStar(require("./society/types.js"), exports);
+tslib_1.__exportStar(require("./staking/types.js"), exports);
+tslib_1.__exportStar(require("./type/types.js"), exports);

package/cjs/util/approvalFlagsToBools.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalFlagsToBools = approvalFlagsToBools;
+/** @internal */
+function approvalFlagsToBools(flags) {
+    const bools = [];
+    for (let i = 0, count = flags.length; i < count; i++) {
+        const str = flags[i].toString(2);
+        // read from lowest bit to highest
+        for (const bit of str.split('').reverse()) {
+            bools.push(!!parseInt(bit, 10));
+        }
+    }
+    // slice off trailing "false" values, as in bizinikiwi
+    const lastApproval = bools.lastIndexOf(true);
+    return lastApproval >= 0
+        ? bools.slice(0, lastApproval + 1)
+        : [];
+}

package/cjs/util/blockNumber.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapBlockNumber = unwrapBlockNumber;
+const util_1 = require("@pezkuwi/util");
+function unwrapBlockNumber(hdr) {
+    return (0, util_1.isCompact)(hdr.number)
+        ? hdr.number.unwrap()
+        : hdr.number;
+}

package/cjs/util/cache.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCache = void 0;
+exports.setDeriveCache = setDeriveCache;
+const cacheImpl_js_1 = require("./cacheImpl.js");
+const CACHE_EXPIRY = 7 * (24 * 60) * (60 * 1000);
+let deriveCache;
+function wrapCache(keyStart, cache) {
+    return {
+        del: (partial) => cache.del(`${keyStart}${partial}`),
+        forEach: cache.forEach,
+        get: (partial) => {
+            const key = `${keyStart}${partial}`;
+            const cached = cache.get(key);
+            if (cached) {
+                cached.x = Date.now();
+                cache.set(key, cached);
+                return cached.v;
+            }
+            return undefined;
+        },
+        set: (partial, v) => {
+            cache.set(`${keyStart}${partial}`, { v, x: Date.now() });
+        }
+    };
+}
+function clearCache(cache) {
+    // clear all expired values
+    const now = Date.now();
+    const all = [];
+    cache.forEach((key, { x }) => {
+        ((now - x) > CACHE_EXPIRY) && all.push(key);
+    });
+    // don't do delete inside loop, just in-case
+    all.forEach((key) => cache.del(key));
+}
+function setDeriveCache(prefix = '', cache) {
+    exports.deriveCache = deriveCache = cache
+        ? wrapCache(`derive:${prefix}:`, cache)
+        : cacheImpl_js_1.deriveNoopCache;
+    if (cache) {
+        clearCache(cache);
+    }
+}
+setDeriveCache();

package/cjs/util/cacheImpl.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveNoopCache = exports.deriveMapCache = void 0;
+const mapCache = new Map();
+exports.deriveMapCache = {
+    del: (key) => {
+        mapCache.delete(key);
+    },
+    forEach: (cb) => {
+        for (const [k, v] of mapCache.entries()) {
+            cb(k, v);
+        }
+    },
+    get: (key) => {
+        return mapCache.get(key);
+    },
+    set: (key, value) => {
+        mapCache.set(key, value);
+    }
+};
+exports.deriveNoopCache = {
+    del: () => undefined,
+    forEach: () => undefined,
+    get: () => undefined,
+    set: (_, value) => value
+};

package/cjs/util/first.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstObservable = firstObservable;
+exports.firstMemo = firstMemo;
+const rxjs_1 = require("rxjs");
+const rpc_core_1 = require("@pezkuwi/rpc-core");
+function firstObservable(obs) {
+    return obs.pipe((0, rxjs_1.map)(([a]) => a));
+}
+function firstMemo(fn) {
+    return (instanceId, api) => (0, rpc_core_1.memo)(instanceId, (...args) => firstObservable(fn(api, ...args)));
+}

package/cjs/util/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memo = exports.drr = void 0;
+const tslib_1 = require("tslib");
+var rpc_core_1 = require("@pezkuwi/rpc-core");
+Object.defineProperty(exports, "drr", { enumerable: true, get: function () { return rpc_core_1.drr; } });
+Object.defineProperty(exports, "memo", { enumerable: true, get: function () { return rpc_core_1.memo; } });
+tslib_1.__exportStar(require("./approvalFlagsToBools.js"), exports);
+tslib_1.__exportStar(require("./blockNumber.js"), exports);
+tslib_1.__exportStar(require("./cache.js"), exports);
+tslib_1.__exportStar(require("./cacheImpl.js"), exports);
+tslib_1.__exportStar(require("./first.js"), exports);
+tslib_1.__exportStar(require("./lazy.js"), exports);

package/cjs/util/lazy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyDeriveSection = lazyDeriveSection;
+const util_1 = require("@pezkuwi/util");
+function lazyDeriveSection(result, section, getKeys, creator) {
+    (0, util_1.lazyMethod)(result, section, () => (0, util_1.lazyMethods)({}, getKeys(section), (method) => creator(section, method)));
+}

package/cjs/util/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/collective/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { Collective } from './types.js';
+export declare function getInstance(api: DeriveApi, section: string): DeriveApi['query']['council'];
+export declare function withSection<T, F extends (...args: any[]) => Observable<T>>(section: Collective, fn: (query: DeriveApi['query']['council'], api: DeriveApi, instanceId: string) => F): (instanceId: string, api: DeriveApi) => F;
+export declare function callMethod<T>(method: 'members' | 'proposals' | 'proposalCount', empty: T): (section: Collective) => (instanceId: string, api: DeriveApi) => () => Observable<T>;

package/collective/helpers.js

@@ -0,0 +1,18 @@
+import { of } from 'rxjs';
+import { isFunction } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+export function getInstance(api, section) {
+    const instances = api.registry.getModuleInstances(api.runtimeVersion.specName, section);
+    const name = instances?.length
+        ? instances[0]
+        : section;
+    return api.query[name];
+}
+export function withSection(section, fn) {
+    return (instanceId, api) => memo(instanceId, fn(getInstance(api, section), api, instanceId));
+}
+export function callMethod(method, empty) {
+    return (section) => withSection(section, (query) => () => isFunction(query?.[method])
+        ? query[method]()
+        : of(empty));
+}

package/collective/index.d.ts

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

package/collective/index.js

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

package/collective/members.d.ts

@@ -0,0 +1,2 @@
+import type { MembersFn } from './types.js';
+export declare const members: MembersFn;

package/collective/members.js

@@ -0,0 +1,2 @@
+import { callMethod } from './helpers.js';
+export const members = /*#__PURE__*/ callMethod('members', []);

package/collective/prime.d.ts

@@ -0,0 +1,2 @@
+import type { Collective, PrimeFnRet } from './types.js';
+export declare function prime(section: Collective): PrimeFnRet;

package/collective/prime.js

@@ -0,0 +1,8 @@
+import { map, of } from 'rxjs';
+import { isFunction } from '@pezkuwi/util';
+import { withSection } from './helpers.js';
+export function prime(section) {
+    return withSection(section, (query) => () => isFunction(query?.prime)
+        ? query.prime().pipe(map((o) => o.unwrapOr(null)))
+        : of(null));
+}

package/collective/proposals.d.ts

@@ -0,0 +1,6 @@
+import type { Collective, HasProposalsFnRet, ProposalCountFn, ProposalFnRet, ProposalHashesFn, ProposalsFnRet } from './types.js';
+export declare function hasProposals(section: Collective): HasProposalsFnRet;
+export declare function proposals(section: Collective): ProposalsFnRet;
+export declare function proposal(section: Collective): ProposalFnRet;
+export declare const proposalCount: ProposalCountFn;
+export declare const proposalHashes: ProposalHashesFn;

package/collective/proposals.js

@@ -0,0 +1,38 @@
+import { catchError, combineLatest, map, of, switchMap } from 'rxjs';
+import { isFunction } from '@pezkuwi/util';
+import { firstObservable } from '../util/index.js';
+import { callMethod, withSection } from './helpers.js';
+function parse(api, [hashes, proposals, votes]) {
+    return proposals.map((o, index) => ({
+        hash: api.registry.createType('Hash', hashes[index]),
+        proposal: o && o.isSome
+            ? o.unwrap()
+            : null,
+        votes: votes[index].unwrapOr(null)
+    }));
+}
+function _proposalsFrom(api, query, hashes) {
+    return (isFunction(query?.proposals) && hashes.length
+        ? combineLatest([
+            of(hashes),
+            // this should simply be api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
+            // however we have had cases on Edgeware where the indices have moved around after an
+            // upgrade, which results in invalid on-chain data
+            query.proposalOf.multi(hashes).pipe(catchError(() => of(hashes.map(() => null)))),
+            query.voting.multi(hashes)
+        ])
+        : of([[], [], []])).pipe(map((r) => parse(api, r)));
+}
+export function hasProposals(section) {
+    return withSection(section, (query) => () => of(isFunction(query?.proposals)));
+}
+export function proposals(section) {
+    return withSection(section, (query, api) => () => api.derive[section].proposalHashes().pipe(switchMap((all) => _proposalsFrom(api, query, all))));
+}
+export function proposal(section) {
+    return withSection(section, (query, api) => (hash) => isFunction(query?.proposals)
+        ? firstObservable(_proposalsFrom(api, query, [hash]))
+        : of(null));
+}
+export const proposalCount = /*#__PURE__*/ callMethod('proposalCount', null);
+export const proposalHashes = /*#__PURE__*/ callMethod('proposals', []);

package/{src/collective/types.ts → collective/types.d.ts}

@@ -1,30 +1,19 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import type { Observable } from 'rxjs';
 import type { u32 } from '@pezkuwi/types';
 import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
 import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
-
 export type Collective = 'allianceMotion' | 'council' | 'membership' | 'technicalCommittee';
-
 export type HasProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<boolean>;
 export type HasProposalsFn = (section: Collective) => HasProposalsFnRet;
-
 export type MembersFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId[]>;
 export type MembersFn = (section: Collective) => MembersFnRet;
-
 export type PrimeFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId | null>;
 export type PrimeFn = (section: Collective) => PrimeFnRet;
-
 export type ProposalFnRet = (instanceId: string, api: DeriveApi) => (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null>;
 export type ProposalFn = (section: Collective) => ProposalFnRet;
-
 export type ProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<DeriveCollectiveProposal[]>;
 export type ProposalsFn = (section: Collective) => ProposalsFnRet;
-
 export type ProposalCountFnRet = (instanceId: string, api: DeriveApi) => () => Observable<u32 | null>;
 export type ProposalCountFn = (section: Collective) => ProposalCountFnRet;
-
 export type ProposalHashesFnRet = (instanceId: string, api: DeriveApi) => () => Observable<Hash[]>;
 export type ProposalHashesFn = (section: Collective) => ProposalHashesFnRet;

package/collective/types.js

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

package/contracts/fees.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveContractFees } from '../types.js';
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export declare function fees(instanceId: string, api: DeriveApi): () => Observable<DeriveContractFees>;

package/contracts/fees.js

@@ -0,0 +1,45 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+function queryConstants(api) {
+    return of([
+        // deprecated
+        api.consts.contracts['callBaseFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['contractFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['creationFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transactionBaseFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transactionByteFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transferFee'] || api.registry.createType('Balance'),
+        // current
+        api.consts.contracts['rentByteFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['rentDepositOffset'] || api.registry.createType('Balance'),
+        api.consts.contracts['surchargeReward'] || api.registry.createType('Balance'),
+        api.consts.contracts['tombstoneDeposit'] || api.registry.createType('Balance')
+    ]);
+}
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export function fees(instanceId, api) {
+    return memo(instanceId, () => {
+        return queryConstants(api).pipe(map(([callBaseFee, contractFee, creationFee, transactionBaseFee, transactionByteFee, transferFee, rentByteFee, rentDepositOffset, surchargeReward, tombstoneDeposit]) => ({
+            callBaseFee,
+            contractFee,
+            creationFee,
+            rentByteFee,
+            rentDepositOffset,
+            surchargeReward,
+            tombstoneDeposit,
+            transactionBaseFee,
+            transactionByteFee,
+            transferFee
+        })));
+    });
+}

package/contracts/index.d.ts

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

package/contracts/index.js

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

package/council/index.d.ts

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

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

@@ -1,11 +1,6 @@
-// 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';
-
 export * from './votes.js';
 export * from './votesOf.js';
-
 /**
  * @name members
  * @description Retrieves the list of members in the "council" collective.
@@ -16,7 +11,6 @@ export * from './votesOf.js';
  * ```
  */
 export const members = /*#__PURE__*/ collectiveMembers('council');
-
 /**
  * @name hasProposals
  * @description Checks if there are any active proposals in the "council" collective.

package/{src/council/types.ts → council/types.d.ts}

@@ -1,11 +1,6 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import type { AccountId, Balance } from '@pezkuwi/types/interfaces';
-
 export interface DeriveCouncilVote {
-  stake: Balance;
-  votes: AccountId[];
+    stake: Balance;
+    votes: AccountId[];
 }
-
 export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

package/council/types.js

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

package/council/votes.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveCouncilVotes } from '../types.js';
+/**
+ * @name votes
+ * @description Retrieves the council election votes for all participants.
+ * @example
+ * ```javascript
+ * const votes = await api.derive.council.votes();
+ * ```
+ */
+export declare function votes(instanceId: string, api: DeriveApi): () => Observable<DeriveCouncilVotes>;

package/council/votes.js

@@ -0,0 +1,56 @@
+import { combineLatest, map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+function isVoter(value) {
+    return !Array.isArray(value);
+}
+function retrieveStakeOf(elections) {
+    return elections['stakeOf'].entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])));
+}
+function retrieveVoteOf(elections) {
+    return elections['votesOf'].entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])));
+}
+function retrievePrev(api, elections) {
+    return combineLatest([
+        retrieveStakeOf(elections),
+        retrieveVoteOf(elections)
+    ]).pipe(map(([stakes, votes]) => {
+        const result = [];
+        votes.forEach(([voter, votes]) => {
+            result.push([voter, { stake: api.registry.createType('Balance'), votes }]);
+        });
+        stakes.forEach(([staker, stake]) => {
+            const entry = result.find(([voter]) => voter.eq(staker));
+            if (entry) {
+                entry[1].stake = stake;
+            }
+            else {
+                result.push([staker, { stake, votes: [] }]);
+            }
+        });
+        return result;
+    }));
+}
+function retrieveCurrent(elections) {
+    return elections.voting.entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, value]) => [
+        accountId,
+        isVoter(value)
+            ? { stake: value.stake, votes: value.votes }
+            : { stake: value[0], votes: value[1] }
+    ])));
+}
+/**
+ * @name votes
+ * @description Retrieves the council election votes for all participants.
+ * @example
+ * ```javascript
+ * const votes = await api.derive.council.votes();
+ * ```
+ */
+export function votes(instanceId, api) {
+    const elections = api.query.elections || api.query['phragmenElection'] || api.query['electionsPhragmen'];
+    return memo(instanceId, () => elections
+        ? elections['stakeOf']
+            ? retrievePrev(api, elections)
+            : retrieveCurrent(elections)
+        : of([]));
+}