@pezkuwi/api-derive 16.5.8 → 16.5.10

package/build/democracy/locks.js

@@ -1,62 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/referendumIds.js

@@ -1,21 +0,0 @@
-import { map, of } from 'rxjs';
-import { memo } from '../util/index.js';
-/**
- * @name referendumIds
- * @description Retrieves an array of active referendum IDs.
- * @example
- * ```javascript
- * const referendums = await api.derive.democracy.referendumIds();
- * ```
- */
-export function referendumIds(instanceId, api) {
-    return memo(instanceId, () => api.query.democracy?.lowestUnbaked
-        ? api.queryMulti([
-            api.query.democracy.lowestUnbaked,
-            api.query.democracy.referendumCount
-        ]).pipe(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))
-            : []))
-        : of([]));
-}

package/build/democracy/referendums.d.ts

@@ -1,11 +0,0 @@
-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/referendums.js

@@ -1,19 +0,0 @@
-import { combineLatest, map, of, switchMap } from 'rxjs';
-import { objectSpread } from '@pezkuwi/util';
-import { memo } from '../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();
- * ```
- */
-export function referendums(instanceId, api) {
-    return memo(instanceId, () => api.derive.democracy.referendumsActive().pipe(switchMap((referendums) => referendums.length
-        ? combineLatest([
-            of(referendums),
-            api.derive.democracy._referendumsVotes(referendums)
-        ])
-        : of([[], []])), map(([referendums, votes]) => referendums.map((referendum, index) => objectSpread({}, referendum, votes[index])))));
-}

package/build/democracy/referendumsActive.d.ts

@@ -1,12 +0,0 @@
-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/referendumsActive.js

@@ -1,16 +0,0 @@
-import { of, switchMap } from 'rxjs';
-import { memo } from '../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);
- * ```
- */
-export function referendumsActive(instanceId, api) {
-    return memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap((ids) => ids.length
-        ? api.derive.democracy.referendumsInfo(ids)
-        : of([]))));
-}

package/build/democracy/referendumsFinished.d.ts

@@ -1,15 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { PezpalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
-import type { DeriveApi } from '../types.js';
-type ReferendumInfoFinished = PezpalletDemocracyReferendumInfo['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/referendumsFinished.js

@@ -1,17 +0,0 @@
-import { map, switchMap } from 'rxjs';
-import { memo } from '../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);
- * ```
- */
-export function referendumsFinished(instanceId, api) {
-    return memo(instanceId, () => api.derive.democracy.referendumIds().pipe(switchMap((ids) => api.query.democracy.referendumInfoOf.multi(ids)), map((infos) => infos
-        .map((o) => o.unwrapOr(null))
-        .filter((info) => !!info && info.isFinished)
-        .map((info) => info.asFinished))));
-}

package/build/democracy/referendumsInfo.d.ts

@@ -1,23 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { Option } from '@pezkuwi/types';
-import type { ReferendumInfoTo239 } from '@pezkuwi/types/interfaces';
-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<PezpalletDemocracyReferendumInfo | 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/referendumsInfo.js

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

package/build/democracy/sqrtElectorate.d.ts

@@ -1,13 +0,0 @@
-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/sqrtElectorate.js

@@ -1,15 +0,0 @@
-import { map } from 'rxjs';
-import { bnSqrt } from '@pezkuwi/util';
-import { memo } from '../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);
- * ```
- */
-export function sqrtElectorate(instanceId, api) {
-    return memo(instanceId, () => api.query.balances.totalIssuance().pipe(map(bnSqrt)));
-}

package/build/democracy/types.d.ts

@@ -1,70 +0,0 @@
-import type { Vec } from '@pezkuwi/types';
-import type { AccountId, Balance, Call, Hash, PropIndex, ReferendumIndex, ReferendumInfoTo239, Vote } from '@pezkuwi/types/interfaces';
-import type { PezpalletDemocracyReferendumStatus, PezpalletDemocracyVoteThreshold } 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: PezpalletDemocracyVoteThreshold;
-}
-export interface DeriveReferendum {
-    index: ReferendumIndex;
-    image?: DeriveProposalImage | undefined;
-    imageHash: HexString;
-    status: PezpalletDemocracyReferendumStatus | 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 {
-}