@pezkuwi/api-derive 16.5.10 → 16.5.13

package/build/crowdloan/contributions.js

@@ -0,0 +1,80 @@
+import { BehaviorSubject, combineLatest, EMPTY, map, of, startWith, switchMap, tap, toArray } from 'rxjs';
+import { arrayFlatten, isFunction, nextTick } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { extractContributed } from './util.js';
+const PAGE_SIZE_K = 1000; // limit aligned with the 1k on the node (trie lookups are heavy)
+function _getUpdates(api, paraId) {
+    let added = [];
+    let removed = [];
+    return api.query.system.events().pipe(switchMap((events) => {
+        const changes = extractContributed(paraId, events);
+        if (changes.added.length || changes.removed.length) {
+            added = added.concat(...changes.added);
+            removed = removed.concat(...changes.removed);
+            return of({ added, addedDelta: changes.added, blockHash: events.createdAtHash?.toHex() || '-', removed, removedDelta: changes.removed });
+        }
+        return EMPTY;
+    }), startWith({ added, addedDelta: [], blockHash: '-', removed, removedDelta: [] }));
+}
+function _eventTriggerAll(api, paraId) {
+    return api.query.system.events().pipe(switchMap((events) => {
+        const items = events.filter(({ event: { data: [eventParaId], method, section } }) => section === 'crowdloan' &&
+            ['AllRefunded', 'Dissolved', 'PartiallyRefunded'].includes(method) &&
+            eventParaId.eq(paraId));
+        return items.length
+            ? of(events.createdAtHash?.toHex() || '-')
+            : EMPTY;
+    }), startWith('-'));
+}
+function _getKeysPaged(api, childKey) {
+    const subject = new BehaviorSubject(undefined);
+    return subject.pipe(switchMap((startKey) => api.rpc.childstate.getKeysPaged(childKey, '0x', PAGE_SIZE_K, startKey)), tap((keys) => {
+        nextTick(() => {
+            keys.length === PAGE_SIZE_K
+                ? subject.next(keys[PAGE_SIZE_K - 1].toHex())
+                : subject.complete();
+        });
+    }), toArray(), // toArray since we want to startSubject to be completed
+    map((keyArr) => arrayFlatten(keyArr)));
+}
+function _getAll(api, paraId, childKey) {
+    return _eventTriggerAll(api, paraId).pipe(switchMap(() => isFunction(api.rpc.childstate.getKeysPaged)
+        ? _getKeysPaged(api, childKey)
+        : api.rpc.childstate.getKeys(childKey, '0x')), map((keys) => keys.map((k) => k.toHex())));
+}
+function _contributions(api, paraId, childKey) {
+    return combineLatest([
+        _getAll(api, paraId, childKey),
+        _getUpdates(api, paraId)
+    ]).pipe(map(([keys, { added, blockHash, removed }]) => {
+        const contributorsMap = {};
+        keys.forEach((k) => {
+            contributorsMap[k] = true;
+        });
+        added.forEach((k) => {
+            contributorsMap[k] = true;
+        });
+        removed.forEach((k) => {
+            delete contributorsMap[k];
+        });
+        return {
+            blockHash,
+            contributorsHex: Object.keys(contributorsMap)
+        };
+    }));
+}
+/**
+ * @name contributions
+ * @description Retrieves all contributions for a given teyrchain crowdloan.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.contributions(3369);
+ * console.log("Contributions:", contributions);
+ * ```
+ */
+export function contributions(instanceId, api) {
+    return memo(instanceId, (paraId) => api.derive.crowdloan.childKey(paraId).pipe(switchMap((childKey) => childKey
+        ? _contributions(api, paraId, childKey)
+        : of({ blockHash: '-', contributorsHex: [] }))));
+}

package/build/crowdloan/index.d.ts

@@ -0,0 +1,3 @@
+export * from './childKey.js';
+export * from './contributions.js';
+export * from './ownContributions.js';

package/build/crowdloan/index.js

@@ -0,0 +1,3 @@
+export * from './childKey.js';
+export * from './contributions.js';
+export * from './ownContributions.js';

package/build/crowdloan/ownContributions.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveOwnContributions } from '../types.js';
+/**
+ * @name ownContributions
+ * @description Retrieves the contribution amounts made by specific accounts (`keys`) to a given teyrchain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @param {string[]} keys An array of account addresses whose contributions are to be fetched.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.ownContributions(2000, ['5Ff...PqV', '5Gg...XyZ']);
+ * console.log("Own Contributions:", contributions);
+ * ```
+ */
+export declare function ownContributions(instanceId: string, api: DeriveApi): (paraId: string | number | BN, keys: string[]) => Observable<DeriveOwnContributions>;

package/build/crowdloan/ownContributions.js

@@ -0,0 +1,45 @@
+import { combineLatest, EMPTY, map, of, startWith, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { extractContributed } from './util.js';
+function _getValues(api, childKey, keys) {
+    // We actually would love to use multi-keys https://github.com/pezkuwichain/bizinikiwi/issues/9203
+    return combineLatest(keys.map((k) => api.rpc.childstate.getStorage(childKey, k))).pipe(map((values) => values
+        .map((v) => api.registry.createType('Option<StorageData>', v))
+        .map((o) => o.isSome
+        ? api.registry.createType('Balance', o.unwrap())
+        : api.registry.createType('Balance'))
+        .reduce((all, b, index) => objectSpread(all, { [keys[index]]: b }), {})));
+}
+function _watchOwnChanges(api, paraId, childkey, keys) {
+    return api.query.system.events().pipe(switchMap((events) => {
+        const changes = extractContributed(paraId, events);
+        const filtered = keys.filter((k) => changes.added.includes(k) ||
+            changes.removed.includes(k));
+        return filtered.length
+            ? _getValues(api, childkey, filtered)
+            : EMPTY;
+    }), startWith({}));
+}
+function _contributions(api, paraId, childKey, keys) {
+    return combineLatest([
+        _getValues(api, childKey, keys),
+        _watchOwnChanges(api, paraId, childKey, keys)
+    ]).pipe(map(([all, latest]) => objectSpread({}, all, latest)));
+}
+/**
+ * @name ownContributions
+ * @description Retrieves the contribution amounts made by specific accounts (`keys`) to a given teyrchain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @param {string[]} keys An array of account addresses whose contributions are to be fetched.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.ownContributions(2000, ['5Ff...PqV', '5Gg...XyZ']);
+ * console.log("Own Contributions:", contributions);
+ * ```
+ */
+export function ownContributions(instanceId, api) {
+    return memo(instanceId, (paraId, keys) => api.derive.crowdloan.childKey(paraId).pipe(switchMap((childKey) => childKey && keys.length
+        ? _contributions(api, paraId, childKey, keys)
+        : of({}))));
+}

package/build/crowdloan/types.d.ts

@@ -0,0 +1,6 @@
+import type { Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveContributions {
+    blockHash: string;
+    contributorsHex: string[];
+}
+export type DeriveOwnContributions = Record<string, Balance>;

package/build/crowdloan/types.js

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

package/build/crowdloan/util.d.ts

@@ -0,0 +1,10 @@
+import type { PezframeSystemEventRecord } from '@pezkuwi/types/lookup';
+import type { Vec } from '@pezkuwi/types-codec';
+import type { BN } from '@pezkuwi/util';
+interface Changes {
+    added: string[];
+    blockHash: string;
+    removed: string[];
+}
+export declare function extractContributed(paraId: string | number | BN, events: Vec<PezframeSystemEventRecord>): Changes;
+export {};

package/build/crowdloan/util.js

@@ -0,0 +1,17 @@
+export function extractContributed(paraId, events) {
+    const added = [];
+    const removed = [];
+    return events
+        .filter(({ event: { data: [, eventParaId], method, section } }) => section === 'crowdloan' &&
+        ['Contributed', 'Withdrew'].includes(method) &&
+        eventParaId.eq(paraId))
+        .reduce((result, { event: { data: [accountId], method } }) => {
+        if (method === 'Contributed') {
+            result.added.push(accountId.toHex());
+        }
+        else {
+            result.removed.push(accountId.toHex());
+        }
+        return result;
+    }, { added, blockHash: events.createdAtHash?.toHex() || '-', removed });
+}

package/build/democracy/dispatchQueue.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveDispatch } from '../types.js';
+/**
+ * @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);
+ * ```
+ */
+export declare function dispatchQueue(instanceId: string, api: DeriveApi): () => Observable<DeriveDispatch[]>;

package/build/democracy/dispatchQueue.js

@@ -0,0 +1,87 @@
+import { catchError, combineLatest, map, of, switchMap } from 'rxjs';
+import { Enum } from '@pezkuwi/types';
+import { isFunction, objectSpread, stringToHex } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { getImageHashBounded } from './util.js';
+const DEMOCRACY_ID = stringToHex('democrac');
+function isMaybeHashedOrBounded(call) {
+    // check for enum
+    return call instanceof Enum;
+}
+function isBounded(call) {
+    // check for type
+    return call.isInline || call.isLegacy || call.isLookup;
+}
+function queryQueue(api) {
+    return api.query.democracy['dispatchQueue']().pipe(switchMap((dispatches) => combineLatest([
+        of(dispatches),
+        api.derive.democracy.preimages(dispatches.map(([, hash]) => hash))
+    ])), map(([dispatches, images]) => dispatches.map(([at, imageHash, index], dispatchIndex) => ({
+        at,
+        image: images[dispatchIndex],
+        imageHash: 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(switchMap(() => api.query.scheduler.agenda.keys()), switchMap((keys) => {
+        const blockNumbers = keys.map(({ args: [blockNumber] }) => blockNumber);
+        return blockNumbers.length
+            ? combineLatest([
+                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(catchError(() => of(blockNumbers.map(() => []))))
+            ])
+            : of([[], []]);
+    }));
+}
+function queryScheduler(api) {
+    return schedulerEntries(api).pipe(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)
+                                ? 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 combineLatest([
+            of(result),
+            result.length
+                ? api.derive.democracy.preimages(result.map(({ imageHash }) => imageHash))
+                : of([])
+        ]);
+    }), map(([infos, images]) => infos.map((info, index) => 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);
+ * ```
+ */
+export function dispatchQueue(instanceId, api) {
+    return memo(instanceId, () => isFunction(api.query.scheduler?.agenda)
+        ? queryScheduler(api)
+        : api.query.democracy['dispatchQueue']
+            ? queryQueue(api)
+            : of([]));
+}

package/build/democracy/index.d.ts

@@ -0,0 +1,11 @@
+export * from './dispatchQueue.js';
+export * from './locks.js';
+export * from './nextExternal.js';
+export * from './preimages.js';
+export * from './proposals.js';
+export * from './referendumIds.js';
+export * from './referendums.js';
+export * from './referendumsActive.js';
+export * from './referendumsFinished.js';
+export * from './referendumsInfo.js';
+export * from './sqrtElectorate.js';

package/build/democracy/index.js

@@ -0,0 +1,11 @@
+export * from './dispatchQueue.js';
+export * from './locks.js';
+export * from './nextExternal.js';
+export * from './preimages.js';
+export * from './proposals.js';
+export * from './referendumIds.js';
+export * from './referendums.js';
+export * from './referendumsActive.js';
+export * from './referendumsFinished.js';
+export * from './referendumsInfo.js';
+export * from './sqrtElectorate.js';

package/build/democracy/locks.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveDemocracyLock } from '../types.js';
+/**
+ * @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);
+ * ```
+ */
+export declare function locks(instanceId: string, api: DeriveApi): (accountId: string | AccountId) => Observable<DeriveDemocracyLock[]>;

package/build/democracy/locks.js

@@ -0,0 +1,62 @@
+import { map, of, switchMap } from 'rxjs';
+import { BN_ZERO, isUndefined } from '@pezkuwi/util';
+import { memo } from '../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]))
+            : BN_ZERO
+    ];
+}
+function parseLock(api, [referendumId, accountVote], referendum) {
+    const { balance, vote } = accountVote.asStandard;
+    const [referendumEnd, unlockAt] = referendum.isFinished
+        ? parseEnd(api, vote, referendum.asFinished)
+        : [BN_ZERO, 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(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 of([]);
+    }
+    return api.query.democracy.referendumInfoOf.multi(votes.map(([referendumId]) => referendumId)).pipe(map((referendums) => votes
+        .map((vote, index) => [vote, referendums[index].unwrapOr(null)])
+        .filter((item) => !!item[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);
+ * ```
+ */
+export function locks(instanceId, api) {
+    return memo(instanceId, (accountId) => api.query.democracy.votingOf
+        ? api.query.democracy.votingOf(accountId).pipe(switchMap((voting) => voting.isDirect
+            ? directLocks(api, voting.asDirect)
+            : voting.isDelegating
+                ? delegateLocks(api, voting.asDelegating)
+                : of([])))
+        : of([]));
+}

package/build/democracy/nextExternal.d.ts

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

package/build/democracy/nextExternal.js

@@ -0,0 +1,28 @@
+import { map, of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+import { getImageHashBounded } from './util.js';
+function withImage(api, nextOpt) {
+    if (nextOpt.isNone) {
+        return of(null);
+    }
+    const [hash, threshold] = nextOpt.unwrap();
+    return api.derive.democracy.preimage(hash).pipe(map((image) => ({
+        image,
+        imageHash: 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);
+ * ```
+ */
+export function nextExternal(instanceId, api) {
+    return memo(instanceId, () => api.query.democracy?.nextExternal
+        ? api.query.democracy.nextExternal().pipe(switchMap((nextOpt) => withImage(api, nextOpt)))
+        : of(null));
+}

package/build/democracy/preimages.d.ts

@@ -0,0 +1,24 @@
+import type { Observable } from 'rxjs';
+import type { Hash } from '@pezkuwi/types/interfaces';
+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 | 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 | 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 | 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: string | Uint8Array | Hash | PezframeSupportPreimagesBounded) => Observable<DeriveProposalImage | undefined>;

package/build/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/democracy/proposals.d.ts

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

package/build/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/democracy/referendumIds.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name referendumIds
+ * @description Retrieves an array of active referendum IDs.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumIds();
+ * ```
+ */
+export declare function referendumIds(instanceId: string, api: DeriveApi): () => Observable<BN[]>;