@pezkuwi/api-derive 16.5.5 → 16.5.8

package/accounts/indexToId.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name indexToId
+ * @description Resolves an AccountIndex (short address) to the full AccountId.
+ * @param {( AccountIndex | string )} accountIndex An accounts index in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const id = await api.derive.accounts.indexToId(ALICE);
+ * console.log(id);
+ * ```
+ */
+export declare function indexToId(instanceId: string, api: DeriveApi): (accountIndex: AccountIndex | string) => Observable<AccountId | undefined>;

package/accounts/indexToId.js

@@ -0,0 +1,18 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name indexToId
+ * @description Resolves an AccountIndex (short address) to the full AccountId.
+ * @param {( AccountIndex | string )} accountIndex An accounts index in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const id = await api.derive.accounts.indexToId(ALICE);
+ * console.log(id);
+ * ```
+ */
+export function indexToId(instanceId, api) {
+    return memo(instanceId, (accountIndex) => api.query.indices
+        ? api.query.indices.accounts(accountIndex).pipe(map((optResult) => optResult.unwrapOr([])[0]))
+        : of(undefined));
+}

package/accounts/indexes.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AccountIndexes, DeriveApi } from '../types.js';
+/**
+ * @name indexes
+ * @returns Returns all the indexes on the system.
+ * @description This is an unwieldly query since it loops through
+ * all of the enumsets and returns all of the values found. This could be up to 32k depending
+ * on the number of active accounts in the system.
+ * @example
+ * ```javascript
+ * api.derive.accounts.indexes((indexes) => {
+ *   console.log('All existing AccountIndexes', indexes);
+ * });
+ * ```
+ */
+export declare function indexes(instanceId: string, api: DeriveApi): () => Observable<AccountIndexes>;

package/accounts/indexes.js

@@ -0,0 +1,34 @@
+import { map, of, startWith } from 'rxjs';
+import { memo } from '../util/index.js';
+let indicesCache = null;
+function queryAccounts(api) {
+    return api.query.indices.accounts.entries().pipe(map((entries) => entries.reduce((indexes, [key, idOpt]) => {
+        if (idOpt.isSome) {
+            indexes[idOpt.unwrap()[0].toString()] = api.registry.createType('AccountIndex', key.args[0]);
+        }
+        return indexes;
+    }, {})));
+}
+/**
+ * @name indexes
+ * @returns Returns all the indexes on the system.
+ * @description This is an unwieldly query since it loops through
+ * all of the enumsets and returns all of the values found. This could be up to 32k depending
+ * on the number of active accounts in the system.
+ * @example
+ * ```javascript
+ * api.derive.accounts.indexes((indexes) => {
+ *   console.log('All existing AccountIndexes', indexes);
+ * });
+ * ```
+ */
+export function indexes(instanceId, api) {
+    return memo(instanceId, () => indicesCache
+        ? of(indicesCache)
+        : (api.query.indices
+            ? queryAccounts(api).pipe(startWith({}))
+            : of({})).pipe(map((indices) => {
+            indicesCache = indices;
+            return indices;
+        })));
+}

package/accounts/info.d.ts

@@ -0,0 +1,18 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveAccountInfo, DeriveApi } from '../types.js';
+/**
+ * @name info
+ * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex, identity and nickname
+ * @param {(AccountIndex | AccountId | Address | Uint8Array | string | null)} address An accounts in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const info = await api.derive.accounts.info(ALICE);
+ * console.log(
+ *   "Account Info: ",
+ *   Object.keys(info).map((key) => `${key}: ${info[key]}`)
+ * );
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): (address?: AccountIndex | AccountId | Address | Uint8Array | string | null) => Observable<DeriveAccountInfo>;

package/accounts/info.js

@@ -0,0 +1,33 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { u8aToString } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function retrieveNick(api, accountId) {
+    return (accountId && api.query['nicks']?.['nameOf']
+        ? api.query['nicks']['nameOf'](accountId)
+        : of(undefined)).pipe(map((nameOf) => nameOf?.isSome
+        ? u8aToString(nameOf.unwrap()[0]).substring(0, api.consts['nicks']['maxLength'].toNumber())
+        : undefined));
+}
+/**
+ * @name info
+ * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex, identity and nickname
+ * @param {(AccountIndex | AccountId | Address | Uint8Array | string | null)} address An accounts in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const info = await api.derive.accounts.info(ALICE);
+ * console.log(
+ *   "Account Info: ",
+ *   Object.keys(info).map((key) => `${key}: ${info[key]}`)
+ * );
+ * ```
+ */
+export function info(instanceId, api) {
+    return memo(instanceId, (address) => api.derive.accounts.idAndIndex(address).pipe(switchMap(([accountId, accountIndex]) => combineLatest([
+        of({ accountId, accountIndex }),
+        api.derive.accounts.identity(accountId),
+        retrieveNick(api, accountId)
+    ])), map(([{ accountId, accountIndex }, identity, nickname]) => ({
+        accountId, accountIndex, identity, nickname
+    }))));
+}

package/accounts/types.d.ts

@@ -0,0 +1,39 @@
+import type { AccountId, AccountIndex, RegistrationJudgement } from '@pezkuwi/types/interfaces';
+import type { Vec } from '@pezkuwi/types-codec';
+export type AccountIdAndIndex = [AccountId | undefined, AccountIndex | undefined];
+export type AccountIndexes = Record<string, AccountIndex>;
+export interface DeriveAccountRegistration {
+    discord?: string | undefined;
+    display?: string | undefined;
+    displayParent?: string | undefined;
+    email?: string | undefined;
+    github?: string | undefined;
+    image?: string | undefined;
+    legal?: string | undefined;
+    matrix?: string | undefined;
+    other?: Record<string, string> | undefined;
+    parent?: AccountId | undefined;
+    pgp?: string | undefined;
+    riot?: string | undefined;
+    subs?: Vec<AccountId> | undefined;
+    twitter?: string | undefined;
+    web?: string | undefined;
+    judgements: RegistrationJudgement[];
+}
+export interface DeriveAccountFlags {
+    isCouncil: boolean;
+    isSociety: boolean;
+    isSudo: boolean;
+    isTechCommittee: boolean;
+}
+export interface DeriveAccountInfo {
+    accountId?: AccountId | undefined;
+    accountIndex?: AccountIndex | undefined;
+    identity: DeriveAccountRegistration;
+    nickname?: string | undefined;
+}
+export interface DeriveHasIdentity {
+    display?: string | undefined;
+    hasIdentity: boolean;
+    parentId?: string | undefined;
+}

package/accounts/types.js

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

package/alliance/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @name members
+ * @description Retrieves the list of members in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.alliance.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 "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.alliance.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "allianceMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.alliance.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 "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.alliance.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 "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.alliance.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 "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.alliance.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "allianceMotion" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.alliance.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export declare const prime: import("../collective/types.js").PrimeFnRet;

package/alliance/index.js

@@ -0,0 +1,71 @@
+import { hasProposals as collectiveHasProposals, members as collectiveMembers, prime as collectivePrime, proposal as collectiveProposal, proposalCount as collectiveProposalCount, proposalHashes as collectiveProposalHashes, proposals as collectiveProposals } from '../collective/index.js';
+/**
+ * @name members
+ * @description Retrieves the list of members in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.alliance.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('allianceMotion');
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.alliance.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export const hasProposals = /*#__PURE__*/ collectiveHasProposals('allianceMotion');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "allianceMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.alliance.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export const proposal = /*#__PURE__*/ collectiveProposal('allianceMotion');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.alliance.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export const proposalCount = /*#__PURE__*/ collectiveProposalCount('allianceMotion');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.alliance.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('allianceMotion');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.alliance.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export const proposals = /*#__PURE__*/ collectiveProposals('allianceMotion');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "allianceMotion" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.alliance.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export const prime = /*#__PURE__*/ collectivePrime('allianceMotion');

package/augment.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/augment.js

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/bagsList/get.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag } from './types.js';
+export declare function _getIds(instanceId: string, api: DeriveApi): (ids: (BN | number)[]) => Observable<Bag[]>;
+export declare function all(instanceId: string, api: DeriveApi): () => Observable<Bag[]>;
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+export declare function get(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<Bag>;

package/bagsList/get.js

@@ -0,0 +1,42 @@
+import { map, of, switchMap } from 'rxjs';
+import { BN_ZERO, bnToBn, objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { getQueryInterface } from './util.js';
+function orderBags(ids, bags) {
+    const sorted = ids
+        .map((id, index) => ({
+        bag: bags[index].unwrapOr(null),
+        id,
+        key: id.toString()
+    }))
+        .sort((a, b) => b.id.cmp(a.id));
+    const max = sorted.length - 1;
+    return sorted.map((entry, index) => objectSpread(entry, {
+        bagLower: index === max
+            ? BN_ZERO
+            : sorted[index + 1].id,
+        bagUpper: entry.id,
+        index
+    }));
+}
+export function _getIds(instanceId, api) {
+    const query = getQueryInterface(api);
+    return memo(instanceId, (_ids) => {
+        const ids = _ids.map((id) => bnToBn(id));
+        return ids.length
+            ? query.listBags.multi(ids).pipe(map((bags) => orderBags(ids, bags)))
+            : of([]);
+    });
+}
+export function all(instanceId, api) {
+    const query = getQueryInterface(api);
+    return memo(instanceId, () => query.listBags.keys().pipe(switchMap((keys) => api.derive.bagsList._getIds(keys.map(({ args: [id] }) => id))), map((list) => list.filter(({ bag }) => bag))));
+}
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+export function get(instanceId, api) {
+    return memo(instanceId, (id) => api.derive.bagsList._getIds([bnToBn(id)]).pipe(map((bags) => bags[0])));
+}

package/bagsList/getExpanded.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag, BagExpanded } from './types.js';
+/**
+ * @name expand
+ * @description Expands a given bag by retrieving all its nodes (accounts contained within the bag).
+ * @param {Bag} bag The bag to be expanded.
+ */
+export declare function expand(instanceId: string, api: DeriveApi): (bag: Bag) => Observable<BagExpanded>;
+/**
+ * @name getExpanded
+ * @description Retrieves and expands a specific bag from the BagsList pallet.
+ * @param {BN | number} id The id of the bag to expand.
+ */
+export declare function getExpanded(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<BagExpanded>;

package/bagsList/getExpanded.js

@@ -0,0 +1,19 @@
+import { map, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+/**
+ * @name expand
+ * @description Expands a given bag by retrieving all its nodes (accounts contained within the bag).
+ * @param {Bag} bag The bag to be expanded.
+ */
+export function expand(instanceId, api) {
+    return memo(instanceId, (bag) => api.derive.bagsList.listNodes(bag.bag).pipe(map((nodes) => objectSpread({ nodes }, bag))));
+}
+/**
+ * @name getExpanded
+ * @description Retrieves and expands a specific bag from the BagsList pallet.
+ * @param {BN | number} id The id of the bag to expand.
+ */
+export function getExpanded(instanceId, api) {
+    return memo(instanceId, (id) => api.derive.bagsList.get(id).pipe(switchMap((bag) => api.derive.bagsList.expand(bag))));
+}

package/bagsList/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get.js';
+export * from './getExpanded.js';
+export * from './listNodes.js';

package/bagsList/index.js

@@ -0,0 +1,3 @@
+export * from './get.js';
+export * from './getExpanded.js';
+export * from './listNodes.js';

package/bagsList/listNodes.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { PezpalletBagsListListBag, PezpalletBagsListListNode } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name listNodes
+ * @param {(PezpalletBagsListListBag | null)} bag A reference to a specific bag in the BagsList pallet.
+ * @description Retrieves the list of nodes (accounts) contained in a specific bag within the BagsList pallet.
+ */
+export declare function listNodes(instanceId: string, api: DeriveApi): (bag: PezpalletBagsListListBag | null) => Observable<PezpalletBagsListListNode[]>;

package/bagsList/listNodes.js

@@ -0,0 +1,26 @@
+import { BehaviorSubject, map, of, switchMap, tap, toArray } from 'rxjs';
+import { nextTick } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { getQueryInterface } from './util.js';
+function traverseLinks(api, head) {
+    const subject = new BehaviorSubject(head);
+    const query = getQueryInterface(api);
+    return subject.pipe(switchMap((account) => query.listNodes(account)), tap((node) => {
+        nextTick(() => {
+            node.isSome && node.value.next.isSome
+                ? subject.next(node.unwrap().next.unwrap())
+                : subject.complete();
+        });
+    }), toArray(), // toArray since we want to startSubject to be completed
+    map((all) => all.map((o) => o.unwrap())));
+}
+/**
+ * @name listNodes
+ * @param {(PezpalletBagsListListBag | null)} bag A reference to a specific bag in the BagsList pallet.
+ * @description Retrieves the list of nodes (accounts) contained in a specific bag within the BagsList pallet.
+ */
+export function listNodes(instanceId, api) {
+    return memo(instanceId, (bag) => bag && bag.head.isSome
+        ? traverseLinks(api, bag.head.unwrap())
+        : of([]));
+}

package/bagsList/types.d.ts

@@ -0,0 +1,13 @@
+import type { PezpalletBagsListListBag, PezpalletBagsListListNode } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+export interface Bag {
+    bag: PezpalletBagsListListBag | null;
+    bagUpper: BN;
+    bagLower: BN;
+    id: BN;
+    index: number;
+    key: string;
+}
+export interface BagExpanded extends Bag {
+    nodes: PezpalletBagsListListNode[];
+}

package/bagsList/types.js

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

package/bagsList/util.d.ts

@@ -0,0 +1,2 @@
+import type { DeriveApi } from '../types.js';
+export declare function getQueryInterface(api: DeriveApi): DeriveApi['query']['voterList'];

package/bagsList/util.js

@@ -0,0 +1,8 @@
+export function getQueryInterface(api) {
+    return (
+    // latest bizinikiwi & pezkuwi
+    api.query.voterList ||
+        // previous bizinikiwi
+        api.query['voterBagsList'] ||
+        api.query['bagsList']);
+}

package/balances/account.d.ts

@@ -0,0 +1,17 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveBalancesAccount } from '../types.js';
+/**
+ * @name account
+ * @description Retrieves the essential balance details for an account, such as free balance and account nonce.
+ * @param {( AccountIndex | AccountId | Address | string )} address An accountsId in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = 'F7Hs';
+ *
+ * api.derive.balances.all(ALICE, ({ accountId, lockedBalance }) => {
+ *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
+ * });
+ * ```
+ */
+export declare function account(instanceId: string, api: DeriveApi): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount>;