@pezkuwi/api-derive 16.5.5 → 16.5.6

package/council/votesOf.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCouncilVote } from '../types.js';
+/**
+ * @name votesOf
+ * @description Retrieves the council votes associated with a given account.
+ * @returns The stake and the list of candidates the account has voted for.
+ * @param {string | Uint8Array | AccountId} accountId The accountId to retrieve votes for.
+ * @example
+ * ```javascript
+ * const accountId = "5Gw3s7qQ9Z..."; // Replace with a valid account ID
+ * const votes = await api.derive.council.votesOf(accountId);
+ * console.log("Account votes:", votes);
+ * ```
+ */
+export declare function votesOf(instanceId: string, api: DeriveApi): (accountId: string | Uint8Array | AccountId) => Observable<DeriveCouncilVote>;

package/council/votesOf.js

@@ -0,0 +1,18 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name votesOf
+ * @description Retrieves the council votes associated with a given account.
+ * @returns The stake and the list of candidates the account has voted for.
+ * @param {string | Uint8Array | AccountId} accountId The accountId to retrieve votes for.
+ * @example
+ * ```javascript
+ * const accountId = "5Gw3s7qQ9Z..."; // Replace with a valid account ID
+ * const votes = await api.derive.council.votesOf(accountId);
+ * console.log("Account votes:", votes);
+ * ```
+ */
+export function votesOf(instanceId, api) {
+    return memo(instanceId, (accountId) => api.derive.council.votes().pipe(map((votes) => (votes.find(([from]) => from.eq(accountId)) ||
+        [null, { stake: api.registry.createType('Balance'), votes: [] }])[1])));
+}

package/crowdloan/childKey.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name childKey
+ * @description Retrieves the child storage key for a given teyrchain’s crowdloan contributions.
+ * This key is used to access contribution data stored in a separate child trie of the blockchain’s state.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const childKey = await api.derive.crowdloan.childKey(3369);
+ * console.log("Child Key:", childKey);
+ * ```
+ */
+export declare function childKey(instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<string | null>;

package/crowdloan/childKey.js

@@ -0,0 +1,23 @@
+import { map } from 'rxjs';
+import { u8aConcat, u8aToHex } from '@pezkuwi/util';
+import { blake2AsU8a } from '@pezkuwi/util-crypto';
+import { memo } from '../util/index.js';
+function createChildKey(info) {
+    return u8aToHex(u8aConcat(':child_storage:default:', blake2AsU8a(u8aConcat('crowdloan', (info.fundIndex || info.trieIndex).toU8a()))));
+}
+/**
+ * @name childKey
+ * @description Retrieves the child storage key for a given teyrchain’s crowdloan contributions.
+ * This key is used to access contribution data stored in a separate child trie of the blockchain’s state.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const childKey = await api.derive.crowdloan.childKey(3369);
+ * console.log("Child Key:", childKey);
+ * ```
+ */
+export function childKey(instanceId, api) {
+    return memo(instanceId, (paraId) => api.query['crowdloan']['funds'](paraId).pipe(map((optInfo) => optInfo.isSome
+        ? createChildKey(optInfo.unwrap())
+        : null)));
+}

package/crowdloan/contributions.d.ts

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

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

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

package/crowdloan/index.js

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

package/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/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/{src/crowdloan/types.ts → crowdloan/types.d.ts}

@@ -1,11 +1,6 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import type { Balance } from '@pezkuwi/types/interfaces';
-
 export interface DeriveContributions {
-  blockHash: string;
-  contributorsHex: string[];
+    blockHash: string;
+    contributorsHex: string[];
 }
-
 export type DeriveOwnContributions = Record<string, Balance>;

package/crowdloan/types.js

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

package/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/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/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/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/{src/democracy/index.ts → democracy/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export * from './dispatchQueue.js';
 export * from './locks.js';
 export * from './nextExternal.js';

package/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/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/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/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/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/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>;