@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/democracy/dispatchQueue.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchQueue = dispatchQueue;
+const rxjs_1 = require("rxjs");
+const types_1 = require("@pezkuwi/types");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+const DEMOCRACY_ID = (0, util_1.stringToHex)('democrac');
+function isMaybeHashedOrBounded(call) {
+    // check for enum
+    return call instanceof types_1.Enum;
+}
+function isBounded(call) {
+    // check for type
+    return call.isInline || call.isLegacy || call.isLookup;
+}
+function queryQueue(api) {
+    return api.query.democracy['dispatchQueue']().pipe((0, rxjs_1.switchMap)((dispatches) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(dispatches),
+        api.derive.democracy.preimages(dispatches.map(([, hash]) => hash))
+    ])), (0, rxjs_1.map)(([dispatches, images]) => dispatches.map(([at, imageHash, index], dispatchIndex) => ({
+        at,
+        image: images[dispatchIndex],
+        imageHash: (0, util_js_1.getImageHashBounded)(imageHash),
+        index
+    }))));
+}
+function schedulerEntries(api) {
+    // We don't get entries, but rather we get the keys (triggered via finished referendums) and
+    // the subscribe to those keys - this means we pickup when the schedulers actually executes
+    // at a block, the entry for that block will become empty
+    return api.derive.democracy.referendumsFinished().pipe((0, rxjs_1.switchMap)(() => api.query.scheduler.agenda.keys()), (0, rxjs_1.switchMap)((keys) => {
+        const blockNumbers = keys.map(({ args: [blockNumber] }) => blockNumber);
+        return blockNumbers.length
+            ? (0, rxjs_1.combineLatest)([
+                (0, rxjs_1.of)(blockNumbers),
+                // this should simply be api.query.scheduler.agenda.multi,
+                // however we have had cases on Darwinia where the indices have moved around after an
+                // upgrade, which results in invalid on-chain data
+                api.query.scheduler.agenda.multi(blockNumbers).pipe((0, rxjs_1.catchError)(() => (0, rxjs_1.of)(blockNumbers.map(() => []))))
+            ])
+            : (0, rxjs_1.of)([[], []]);
+    }));
+}
+function queryScheduler(api) {
+    return schedulerEntries(api).pipe((0, rxjs_1.switchMap)(([blockNumbers, agendas]) => {
+        const result = [];
+        blockNumbers.forEach((at, index) => {
+            (agendas[index] || []).filter((o) => o.isSome).forEach((o) => {
+                const scheduled = o.unwrap();
+                if (scheduled.maybeId.isSome) {
+                    const id = scheduled.maybeId.unwrap().toHex();
+                    if (id.startsWith(DEMOCRACY_ID)) {
+                        const imageHash = isMaybeHashedOrBounded(scheduled.call)
+                            ? isBounded(scheduled.call)
+                                ? (0, util_js_1.getImageHashBounded)(scheduled.call)
+                                : scheduled.call.isHash
+                                    ? scheduled.call.asHash.toHex()
+                                    : scheduled.call.asValue.args[0].toHex()
+                            : scheduled.call.args[0].toHex();
+                        result.push({ at, imageHash, index: api.registry.createType('(u64, ReferendumIndex)', id)[1] });
+                    }
+                }
+            });
+        });
+        return (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.of)(result),
+            result.length
+                ? api.derive.democracy.preimages(result.map(({ imageHash }) => imageHash))
+                : (0, rxjs_1.of)([])
+        ]);
+    }), (0, rxjs_1.map)(([infos, images]) => infos.map((info, index) => (0, util_1.objectSpread)({ image: images[index] }, info))));
+}
+/**
+ * @name dispatchQueue
+ * @description Retrieves the list of scheduled or pending dispatches in the governance system.
+ * @example
+ * ```javascript
+ * const queue = await api.derive.democracy.dispatchQueue();
+ * console.log("Dispatch Queue:", queue);
+ * ```
+ */
+function dispatchQueue(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => (0, util_1.isFunction)(api.query.scheduler?.agenda)
+        ? queryScheduler(api)
+        : api.query.democracy['dispatchQueue']
+            ? queryQueue(api)
+            : (0, rxjs_1.of)([]));
+}

package/cjs/democracy/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./dispatchQueue.js"), exports);
+tslib_1.__exportStar(require("./locks.js"), exports);
+tslib_1.__exportStar(require("./nextExternal.js"), exports);
+tslib_1.__exportStar(require("./preimages.js"), exports);
+tslib_1.__exportStar(require("./proposals.js"), exports);
+tslib_1.__exportStar(require("./referendumIds.js"), exports);
+tslib_1.__exportStar(require("./referendums.js"), exports);
+tslib_1.__exportStar(require("./referendumsActive.js"), exports);
+tslib_1.__exportStar(require("./referendumsFinished.js"), exports);
+tslib_1.__exportStar(require("./referendumsInfo.js"), exports);
+tslib_1.__exportStar(require("./sqrtElectorate.js"), exports);

package/cjs/democracy/locks.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locks = locks;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const LOCKUPS = [0, 1, 2, 4, 8, 16, 32];
+function parseEnd(api, vote, { approved, end }) {
+    return [
+        end,
+        (approved.isTrue && vote.isAye) || (approved.isFalse && vote.isNay)
+            ? end.add((api.consts.democracy.voteLockingPeriod ||
+                api.consts.democracy.enactmentPeriod).muln(LOCKUPS[vote.conviction.index]))
+            : util_1.BN_ZERO
+    ];
+}
+function parseLock(api, [referendumId, accountVote], referendum) {
+    const { balance, vote } = accountVote.asStandard;
+    const [referendumEnd, unlockAt] = referendum.isFinished
+        ? parseEnd(api, vote, referendum.asFinished)
+        : [util_1.BN_ZERO, util_1.BN_ZERO];
+    return { balance, isDelegated: false, isFinished: referendum.isFinished, referendumEnd, referendumId, unlockAt, vote };
+}
+function delegateLocks(api, { balance, conviction, target }) {
+    return api.derive.democracy.locks(target).pipe((0, rxjs_1.map)((available) => available.map(({ isFinished, referendumEnd, referendumId, unlockAt, vote }) => ({
+        balance,
+        isDelegated: true,
+        isFinished,
+        referendumEnd,
+        referendumId,
+        unlockAt: unlockAt.isZero()
+            ? unlockAt
+            : referendumEnd.add((api.consts.democracy.voteLockingPeriod ||
+                api.consts.democracy.enactmentPeriod).muln(LOCKUPS[conviction.index])),
+        vote: api.registry.createType('Vote', { aye: vote.isAye, conviction })
+    }))));
+}
+function directLocks(api, { votes }) {
+    if (!votes.length) {
+        return (0, rxjs_1.of)([]);
+    }
+    return api.query.democracy.referendumInfoOf.multi(votes.map(([referendumId]) => referendumId)).pipe((0, rxjs_1.map)((referendums) => votes
+        .map((vote, index) => [vote, referendums[index].unwrapOr(null)])
+        .filter((item) => !!item[1] && (0, util_1.isUndefined)(item[1].end) && item[0][1].isStandard)
+        .map(([directVote, referendum]) => parseLock(api, directVote, referendum))));
+}
+/**
+ * @name locks
+ * @description Retrieves the democracy voting locks for a given account.
+ * @param { string | AccountId } accountId The accountId for which to retrieve democracy voting locks.
+ * @example
+ * ```javascript
+ * const locks = await api.derive.democracy.locks('5FfFjX...'); // Replace with an actual accountId
+ * console.log("Democracy Locks:", locks);
+ * ```
+ */
+function locks(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId) => api.query.democracy.votingOf
+        ? api.query.democracy.votingOf(accountId).pipe((0, rxjs_1.switchMap)((voting) => voting.isDirect
+            ? directLocks(api, voting.asDirect)
+            : voting.isDelegating
+                ? delegateLocks(api, voting.asDelegating)
+                : (0, rxjs_1.of)([])))
+        : (0, rxjs_1.of)([]));
+}

package/cjs/democracy/nextExternal.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextExternal = nextExternal;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function withImage(api, nextOpt) {
+    if (nextOpt.isNone) {
+        return (0, rxjs_1.of)(null);
+    }
+    const [hash, threshold] = nextOpt.unwrap();
+    return api.derive.democracy.preimage(hash).pipe((0, rxjs_1.map)((image) => ({
+        image,
+        imageHash: (0, util_js_1.getImageHashBounded)(hash),
+        threshold
+    })));
+}
+/**
+ * @name nextExternal
+ * @description Retrieves the next external proposal that is scheduled for a referendum.
+ * @example
+ * ```javascript
+ * const nextExternal = await api.derive.democracy.nextExternal();
+ * console.log("Next external proposal:", nextExternal);
+ * ```
+ */
+function nextExternal(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.democracy?.nextExternal
+        ? api.query.democracy.nextExternal().pipe((0, rxjs_1.switchMap)((nextOpt) => withImage(api, nextOpt)))
+        : (0, rxjs_1.of)(null));
+}

package/{build → cjs}/democracy/preimages.d.ts

@@ -1,24 +1,24 @@
 import type { Observable } from 'rxjs';
 import type { Hash } from '@pezkuwi/types/interfaces';
-import type { FrameSupportPreimagesBounded } from '@pezkuwi/types/lookup';
+import type { PezframeSupportPreimagesBounded } from '@pezkuwi/types/lookup';
 import type { DeriveApi, DeriveProposalImage } from '../types.js';
 /**
  * @name preimages
  * @description Retrieves the full details (preimages) of governance proposals using their on-chain hashes.
- * @param { (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[] } hashes An array of hashes representing governance proposals.
+ * @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 declare function preimages(instanceId: string, api: DeriveApi): (hashes: (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[]) => Observable<(DeriveProposalImage | undefined)[]>;
+export declare function preimages(instanceId: string, api: DeriveApi): (hashes: (Hash | Uint8Array | string | PezframeSupportPreimagesBounded)[]) => Observable<(DeriveProposalImage | undefined)[]>;
 /**
  * @name preimage
  * @description Retrieves the full details (preimage) of a governance proposal using its on-chain hash.
- * @param { Hash | Uint8Array | string | FrameSupportPreimagesBounded } hash Hash that represents governance proposals.
+ * @param { Hash | Uint8Array | string | PezframeSupportPreimagesBounded } hash Hash that represents governance proposals.
  *  * @example
  * ```javascript
  * const preimage = await api.derive.democracy.preimage(HASH);
  * ```
  */
-export declare const preimage: (instanceId: string, api: DeriveApi) => (hash: any) => Observable<DeriveProposalImage>;
+export declare const preimage: (instanceId: string, api: DeriveApi) => (hash: string | Uint8Array | Hash | PezframeSupportPreimagesBounded) => Observable<DeriveProposalImage | undefined>;

package/cjs/democracy/preimages.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preimage = void 0;
+exports.preimages = preimages;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./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: util_1.BN_ZERO, balance, proposal, proposalHash, proposer };
+}
+function getDemocracyImages(api, bounded) {
+    const hashes = bounded.map((b) => (0, util_js_1.getImageHashBounded)(b));
+    return api.query.democracy['preimages'].multi(hashes).pipe((0, rxjs_1.map)((images) => images.map((imageOpt) => parseDemocracy(api, imageOpt))));
+}
+function getImages(api, bounded) {
+    const hashes = bounded.map((b) => (0, util_js_1.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((0, rxjs_1.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((0, rxjs_1.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]);
+ * ```
+ */
+function preimages(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (hashes) => hashes.length
+        ? (0, util_1.isFunction)(api.query.democracy['preimages'])
+            ? getDemocracyImages(api, hashes)
+            : (0, util_1.isFunction)(api.query.preimage.preimageFor)
+                ? getImages(api, hashes)
+                : (0, rxjs_1.of)([])
+        : (0, rxjs_1.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);
+ * ```
+ */
+exports.preimage = (0, index_js_1.firstMemo)((api, hash) => api.derive.democracy.preimages([hash]));

package/cjs/democracy/proposals.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proposals = proposals;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function isNewDepositors(depositors) {
+    // Detect balance...
+    return (0, util_1.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 (0, util_1.objectSpread)({
+            image: images[proposalIndex],
+            imageHash: (0, util_js_1.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);
+ * ```
+ */
+function proposals(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => (0, util_1.isFunction)(api.query.democracy?.publicProps)
+        ? api.query.democracy.publicProps().pipe((0, rxjs_1.switchMap)((proposals) => proposals.length
+            ? (0, rxjs_1.combineLatest)([
+                (0, rxjs_1.of)(proposals),
+                api.derive.democracy.preimages(proposals.map(([, hash]) => hash)),
+                api.query.democracy.depositOf.multi(proposals.map(([index]) => index))
+            ])
+            : (0, rxjs_1.of)([[], [], []])), (0, rxjs_1.map)(parse))
+        : (0, rxjs_1.of)([]));
+}

package/cjs/democracy/referendumIds.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referendumIds = referendumIds;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name referendumIds
+ * @description Retrieves an array of active referendum IDs.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumIds();
+ * ```
+ */
+function referendumIds(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.democracy?.lowestUnbaked
+        ? api.queryMulti([
+            api.query.democracy.lowestUnbaked,
+            api.query.democracy.referendumCount
+        ]).pipe((0, rxjs_1.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))
+            : []))
+        : (0, rxjs_1.of)([]));
+}

package/cjs/democracy/referendums.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referendums = referendums;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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();
+ * ```
+ */
+function referendums(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.democracy.referendumsActive().pipe((0, rxjs_1.switchMap)((referendums) => referendums.length
+        ? (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.of)(referendums),
+            api.derive.democracy._referendumsVotes(referendums)
+        ])
+        : (0, rxjs_1.of)([[], []])), (0, rxjs_1.map)(([referendums, votes]) => referendums.map((referendum, index) => (0, util_1.objectSpread)({}, referendum, votes[index])))));
+}

package/cjs/democracy/referendumsActive.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referendumsActive = referendumsActive;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../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);
+ * ```
+ */
+function referendumsActive(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.democracy.referendumIds().pipe((0, rxjs_1.switchMap)((ids) => ids.length
+        ? api.derive.democracy.referendumsInfo(ids)
+        : (0, rxjs_1.of)([]))));
+}

package/{build → cjs}/democracy/referendumsFinished.d.ts

@@ -1,7 +1,7 @@
 import type { Observable } from 'rxjs';
-import type { PalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
+import type { PezpalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
 import type { DeriveApi } from '../types.js';
-type ReferendumInfoFinished = PalletDemocracyReferendumInfo['asFinished'];
+type ReferendumInfoFinished = PezpalletDemocracyReferendumInfo['asFinished'];
 /**
  * @name referendumsFinished
  * @description Retrieves information about finished referendums.

package/cjs/democracy/referendumsFinished.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referendumsFinished = referendumsFinished;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../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);
+ * ```
+ */
+function referendumsFinished(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.democracy.referendumIds().pipe((0, rxjs_1.switchMap)((ids) => api.query.democracy.referendumInfoOf.multi(ids)), (0, rxjs_1.map)((infos) => infos
+        .map((o) => o.unwrapOr(null))
+        .filter((info) => !!info && info.isFinished)
+        .map((info) => info.asFinished))));
+}

package/{build → cjs}/democracy/referendumsInfo.d.ts

@@ -1,12 +1,12 @@
 import type { Observable } from 'rxjs';
 import type { Option } from '@pezkuwi/types';
 import type { ReferendumInfoTo239 } from '@pezkuwi/types/interfaces';
-import type { PalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
+import type { PezpalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
 import type { BN } from '@pezkuwi/util';
 import type { DeriveApi, DeriveReferendum, DeriveReferendumVotes } from '../types.js';
 export declare function _referendumVotes(instanceId: string, api: DeriveApi): (referendum: DeriveReferendum) => Observable<DeriveReferendumVotes>;
 export declare function _referendumsVotes(instanceId: string, api: DeriveApi): (referendums: DeriveReferendum[]) => Observable<DeriveReferendumVotes[]>;
-export declare function _referendumInfo(instanceId: string, api: DeriveApi): (index: BN, info: Option<PalletDemocracyReferendumInfo | ReferendumInfoTo239>) => Observable<DeriveReferendum | null>;
+export declare function _referendumInfo(instanceId: string, api: DeriveApi): (index: BN, info: Option<PezpalletDemocracyReferendumInfo | ReferendumInfoTo239>) => Observable<DeriveReferendum | null>;
 /**
  * @name referendumsInfo
  * @description Retrieves information about multiple referendums by their IDs.

package/cjs/democracy/referendumsInfo.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._referendumVotes = _referendumVotes;
+exports._referendumsVotes = _referendumsVotes;
+exports._referendumInfo = _referendumInfo;
+exports.referendumsInfo = referendumsInfo;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function votesPrev(api, referendumId) {
+    return api.query.democracy['votersFor'](referendumId).pipe((0, rxjs_1.switchMap)((votersFor) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(votersFor),
+        votersFor.length
+            ? api.query.democracy['voteOf'].multi(votersFor.map((accountId) => [referendumId, accountId]))
+            : (0, rxjs_1.of)([]),
+        api.derive.balances.votingBalances(votersFor)
+    ])), (0, rxjs_1.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((0, util_1.objectSpread)({
+                accountId,
+                isDelegating: false
+            }, vote.asStandard));
+        }
+        return result;
+    }, result), []);
+}
+function votesCurr(api, referendumId) {
+    return api.query.democracy.votingOf.entries().pipe((0, rxjs_1.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;
+    }));
+}
+function _referendumVotes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (referendum) => (0, rxjs_1.combineLatest)([
+        api.derive.democracy.sqrtElectorate(),
+        (0, util_1.isFunction)(api.query.democracy.votingOf)
+            ? votesCurr(api, referendum.index)
+            : votesPrev(api, referendum.index)
+    ]).pipe((0, rxjs_1.map)(([sqrtElectorate, votes]) => (0, util_js_1.calcVotes)(sqrtElectorate, referendum, votes))));
+}
+function _referendumsVotes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (referendums) => referendums.length
+        ? (0, rxjs_1.combineLatest)(referendums.map((referendum) => api.derive.democracy._referendumVotes(referendum)))
+        : (0, rxjs_1.of)([]));
+}
+function _referendumInfo(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (index, info) => {
+        const status = (0, util_js_1.getStatus)(info);
+        return status
+            ? api.derive.democracy.preimage(status.proposal ||
+                status.proposalHash).pipe((0, rxjs_1.map)((image) => ({
+                image,
+                imageHash: (0, util_js_1.getImageHash)(status),
+                index: api.registry.createType('ReferendumIndex', index),
+                status
+            })))
+            : (0, rxjs_1.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);
+ * ```
+ */
+function referendumsInfo(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (ids) => ids.length
+        ? api.query.democracy.referendumInfoOf.multi(ids).pipe((0, rxjs_1.switchMap)((infos) => (0, rxjs_1.combineLatest)(ids.map((id, index) => api.derive.democracy._referendumInfo(id, infos[index])))), (0, rxjs_1.map)((infos) => infos.filter((r) => !!r)))
+        : (0, rxjs_1.of)([]));
+}

package/cjs/democracy/sqrtElectorate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrtElectorate = sqrtElectorate;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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);
+ * ```
+ */
+function sqrtElectorate(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.balances.totalIssuance().pipe((0, rxjs_1.map)(util_1.bnSqrt)));
+}