@pezkuwi/api-derive 16.5.5

package/build/chain/getBlockByNumber.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AnyNumber } from '@pezkuwi/types/types';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name getBlockByNumber
+ * @param {( BN | bigint | Uint8Array | number | string )} blockNumber
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author by block number
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlockByNumber(123);
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export declare function getBlockByNumber(instanceId: string, api: DeriveApi): (blockNumber: AnyNumber) => Observable<SignedBlockExtended>;

package/build/chain/getHeader.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { HeaderExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name getHeader
+ * @param {( Uint8Array | string )} hash - A block hash as U8 array or string.
+ * @returns An array containing the block header and the block author
+ * @description Get a specific block header and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, number } = await api.derive.chain.getHeader('0x123...456');
+ *
+ * console.log(`block #${number} was authored by ${author}`);
+ * ```
+ */
+export declare function getHeader(instanceId: string, api: DeriveApi): (blockHash: Uint8Array | string) => Observable<HeaderExtended>;

package/build/chain/index.d.ts

@@ -0,0 +1,10 @@
+export * from './bestNumber.js';
+export * from './bestNumberFinalized.js';
+export * from './bestNumberLag.js';
+export * from './getBlock.js';
+export * from './getBlockByNumber.js';
+export * from './getHeader.js';
+export * from './subscribeFinalizedBlocks.js';
+export * from './subscribeFinalizedHeads.js';
+export * from './subscribeNewBlocks.js';
+export * from './subscribeNewHeads.js';

package/build/chain/subscribeFinalizedBlocks.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeFinalizedBlocks
+ * @description Retrieves the finalized block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedBlocks((finalizedBlock) => {
+ *  console.log(`# Finalized block ${finalizedBlock.block.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeFinalizedBlocks(instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended>;

package/build/chain/subscribeFinalizedHeads.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { Hash, Header } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+export declare function _getHeaderRange(instanceId: string, api: DeriveApi): (startHash: Hash, endHash: Hash, prev?: Header[]) => Observable<Header[]>;
+/**
+ * @name subscribeFinalizedHeads
+ * @description An observable of the finalized block headers. Unlike the base
+ * chain.subscribeFinalizedHeads this does not skip any headers. Since finalization
+ * may skip specific blocks (finalization happens in terms of chains), this version
+ * of the derive tracks missing headers (since last retrieved) and provides them
+ * to the caller.
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedHeads((finalizedHead) => {
+ *   console.log(`${finalizedHead.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeFinalizedHeads(instanceId: string, api: DeriveApi): () => Observable<Header>;

package/build/chain/subscribeNewBlocks.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeNewBlocks
+ * @returns The latest block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeNewBlocks((newBlock) => {
+ *   console.log(`Block Hash: ${newBlock.hash}`);
+ * });
+ * ```
+ */
+export declare function subscribeNewBlocks(instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended>;

package/build/chain/subscribeNewHeads.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { HeaderExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name subscribeNewHeads
+ * @returns A header with the current header (including extracted author).
+ * @description An observable of the current block header and it's author.
+ * @example
+ * ```javascript
+ * api.derive.chain.subscribeNewHeads((header) => {
+ *   console.log(`block #${header.number} was authored by ${header.author}`);
+ * });
+ * ```
+ */
+export declare function subscribeNewHeads(instanceId: string, api: DeriveApi): () => Observable<HeaderExtended>;

package/build/chain/util.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { Compact, Vec } from '@pezkuwi/types';
+import type { AccountId, BlockNumber, Header } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+export type BlockNumberDerive = (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+export declare function createBlockNumberDerive<T extends {
+    number: Compact<BlockNumber> | BlockNumber;
+}>(fn: (api: DeriveApi) => Observable<T>): BlockNumberDerive;
+export declare function getAuthorDetails(api: DeriveApi, header: Header, blockHash?: Uint8Array | string): Observable<[Header, Vec<AccountId> | null, AccountId | null]>;

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

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

package/build/collective/members.d.ts

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

package/build/collective/prime.d.ts

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

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

@@ -0,0 +1,19 @@
+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/build/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 substrate 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/build/contracts/index.d.ts

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

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

@@ -0,0 +1,6 @@
+import type { AccountId, Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveCouncilVote {
+    stake: Balance;
+    votes: AccountId[];
+}
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

package/build/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/build/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/build/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 parachain’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 parachain 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/build/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 parachain crowdloan.
+ * @param {string | number | BN} paraId The parachain 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/build/crowdloan/index.d.ts

@@ -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 parachain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The parachain 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/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/util.d.ts

@@ -0,0 +1,10 @@
+import type { FrameSystemEventRecord } 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<FrameSystemEventRecord>): Changes;
+export {};

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

@@ -0,0 +1,24 @@
+import type { Observable } from 'rxjs';
+import type { Hash } from '@pezkuwi/types/interfaces';
+import type { FrameSupportPreimagesBounded } 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.
+ * @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)[]>;
+/**
+ * @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.
+ *  * @example
+ * ```javascript
+ * const preimage = await api.derive.democracy.preimage(HASH);
+ * ```
+ */
+export declare const preimage: (instanceId: string, api: DeriveApi) => (hash: any) => Observable<DeriveProposalImage>;

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/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[]>;

package/build/democracy/referendums.d.ts

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

package/build/democracy/referendumsActive.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveReferendum } from '../types.js';
+/**
+ * @name referendumsActive
+ * @description Retrieves information about active referendums.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumsActive();
+ * console.log("Active Referendums:", referendums);
+ * ```
+ */
+export declare function referendumsActive(instanceId: string, api: DeriveApi): () => Observable<DeriveReferendum[]>;

package/build/democracy/referendumsFinished.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { PalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+type ReferendumInfoFinished = PalletDemocracyReferendumInfo['asFinished'];
+/**
+ * @name referendumsFinished
+ * @description Retrieves information about finished referendums.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumsFinished();
+ * console.log("Finished Referendums:", referendums);
+ * ```
+ */
+export declare function referendumsFinished(instanceId: string, api: DeriveApi): () => Observable<ReferendumInfoFinished[]>;
+export {};

package/build/democracy/referendumsInfo.d.ts

@@ -0,0 +1,23 @@
+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 { 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>;
+/**
+ * @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);
+ * ```
+ */
+export declare function referendumsInfo(instanceId: string, api: DeriveApi): (ids: BN[]) => Observable<DeriveReferendum[]>;

package/build/democracy/sqrtElectorate.d.ts

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

package/build/democracy/types.d.ts

@@ -0,0 +1,70 @@
+import type { Vec } from '@pezkuwi/types';
+import type { AccountId, Balance, Call, Hash, PropIndex, ReferendumIndex, ReferendumInfoTo239, Vote } from '@pezkuwi/types/interfaces';
+import type { PalletDemocracyReferendumStatus, PalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+export interface AtBlock {
+    at: BN;
+}
+export interface DeriveDemocracyLock {
+    balance: Balance;
+    isDelegated: boolean;
+    isFinished: boolean;
+    referendumEnd: BN;
+    referendumId: ReferendumIndex;
+    unlockAt: BN;
+    vote: Vote;
+}
+export interface DeriveProposalImage extends AtBlock {
+    balance: Balance;
+    proposal?: Call | undefined;
+    proposalHash?: HexString;
+    proposalLen?: number;
+    proposer: AccountId;
+}
+export interface DeriveDispatch extends AtBlock {
+    index: ReferendumIndex;
+    imageHash: HexString;
+    image?: DeriveProposalImage | undefined;
+}
+export interface DeriveProposal {
+    balance?: Balance;
+    index: PropIndex;
+    image?: DeriveProposalImage | undefined;
+    imageHash: Hash;
+    proposer: AccountId;
+    seconds: Vec<AccountId>;
+}
+export interface DeriveProposalExternal {
+    image?: DeriveProposalImage | undefined;
+    imageHash: HexString;
+    threshold: PalletDemocracyVoteThreshold;
+}
+export interface DeriveReferendum {
+    index: ReferendumIndex;
+    image?: DeriveProposalImage | undefined;
+    imageHash: HexString;
+    status: PalletDemocracyReferendumStatus | ReferendumInfoTo239;
+}
+export interface DeriveReferendumVote {
+    accountId: AccountId;
+    balance: Balance;
+    isDelegating: boolean;
+    vote: Vote;
+}
+export interface DeriveReferendumVoteState {
+    allAye: DeriveReferendumVote[];
+    allNay: DeriveReferendumVote[];
+    voteCount: number;
+    voteCountAye: number;
+    voteCountNay: number;
+    votedAye: BN;
+    votedNay: BN;
+    votedTotal: BN;
+}
+export interface DeriveReferendumVotes extends DeriveReferendumVoteState {
+    isPassing: boolean;
+    votes: DeriveReferendumVote[];
+}
+export interface DeriveReferendumExt extends DeriveReferendum, DeriveReferendumVotes {
+}