@pezkuwi/api-derive 16.5.5 → 16.5.6

package/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/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/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/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/democracy/referendumIds.js

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

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

@@ -0,0 +1,16 @@
+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/democracy/referendumsFinished.d.ts

@@ -0,0 +1,15 @@
+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/democracy/referendumsFinished.js

@@ -0,0 +1,17 @@
+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/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 { 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/democracy/referendumsInfo.js

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

@@ -0,0 +1,15 @@
+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/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 { 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 {
+}

package/democracy/types.js

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

package/democracy/util.d.ts

@@ -0,0 +1,18 @@
+import type { Hash, ReferendumInfoTo239 } from '@pezkuwi/types/interfaces';
+import type { PezframeSupportPreimagesBounded, PezpalletDemocracyReferendumInfo, PezpalletDemocracyReferendumStatus, PezpalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { HexString } from '@pezkuwi/util/types';
+import type { DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes } from '../types.js';
+import { BN } from '@pezkuwi/util';
+interface ApproxState {
+    votedAye: BN;
+    votedNay: BN;
+    votedTotal: BN;
+}
+export declare function compareRationals(n1: BN, d1: BN, n2: BN, d2: BN): boolean;
+export declare function calcPassing(threshold: PezpalletDemocracyVoteThreshold, sqrtElectorate: BN, state: ApproxState): boolean;
+export declare function calcVotes(sqrtElectorate: BN, referendum: DeriveReferendum, votes: DeriveReferendumVote[]): DeriveReferendumVotes;
+export declare function getStatus(info: Option<PezpalletDemocracyReferendumInfo | ReferendumInfoTo239>): PezpalletDemocracyReferendumStatus | ReferendumInfoTo239 | null;
+export declare function getImageHashBounded(hash: Uint8Array | string | Hash | PezframeSupportPreimagesBounded): HexString;
+export declare function getImageHash(status: PezpalletDemocracyReferendumStatus | ReferendumInfoTo239): HexString;
+export {};