@pezkuwi/api-derive 16.5.5 → 16.5.8

package/chain/bestNumber.js

@@ -0,0 +1,12 @@
+import { createBlockNumberDerive } from './util.js';
+/**
+ * @name bestNumber
+ * @descrive Retrieves the latest block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumber((blockNumber) => {
+ *   console.log(`the current best block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export const bestNumber = /*#__PURE__*/ createBlockNumberDerive((api) => api.rpc.chain.subscribeNewHeads());

package/chain/bestNumberFinalized.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @name bestNumberFinalized
+ * @returns A BlockNumber
+ * @description Get the latest finalized block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumberFinalized((blockNumber) => {
+ *   console.log(`the current finalized block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export declare const bestNumberFinalized: import("./util.js").BlockNumberDerive;

package/chain/bestNumberFinalized.js

@@ -0,0 +1,13 @@
+import { createBlockNumberDerive } from './util.js';
+/**
+ * @name bestNumberFinalized
+ * @returns A BlockNumber
+ * @description Get the latest finalized block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumberFinalized((blockNumber) => {
+ *   console.log(`the current finalized block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export const bestNumberFinalized = /*#__PURE__*/ createBlockNumberDerive((api) => api.rpc.chain.subscribeFinalizedHeads());

package/chain/bestNumberLag.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BlockNumber } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name bestNumberLag
+ * @returns A number of blocks
+ * @description Calculates the lag between finalized head and best head
+ * @examplew
+ * ```javascript
+ * api.derive.chain.bestNumberLag((lag) => {
+ *   console.log(`finalized is ${lag} blocks behind head`);
+ * });
+ * ```
+ */
+export declare function bestNumberLag(instanceId: string, api: DeriveApi): () => Observable<BlockNumber>;

package/chain/bestNumberLag.js

@@ -0,0 +1,19 @@
+import { combineLatest, map } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name bestNumberLag
+ * @returns A number of blocks
+ * @description Calculates the lag between finalized head and best head
+ * @examplew
+ * ```javascript
+ * api.derive.chain.bestNumberLag((lag) => {
+ *   console.log(`finalized is ${lag} blocks behind head`);
+ * });
+ * ```
+ */
+export function bestNumberLag(instanceId, api) {
+    return memo(instanceId, () => combineLatest([
+        api.derive.chain.bestNumber(),
+        api.derive.chain.bestNumberFinalized()
+    ]).pipe(map(([bestNumber, bestNumberFinalized]) => api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized)))));
+}

package/chain/getBlock.d.ts

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

package/chain/getBlock.js

@@ -0,0 +1,25 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { createSignedBlockExtended } from '../type/index.js';
+import { memo } from '../util/index.js';
+import { getAuthorDetails } from './util.js';
+/**
+ * @name getBlock
+ * @param {( Uint8Array | string )} hash A block hash as U8 array or string.
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlock('0x123...456');
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export function getBlock(instanceId, api) {
+    return memo(instanceId, (blockHash) => combineLatest([
+        api.rpc.chain.getBlock(blockHash),
+        api.queryAt(blockHash)
+    ]).pipe(switchMap(([signedBlock, queryAt]) => combineLatest([
+        of(signedBlock),
+        queryAt.system.events(),
+        getAuthorDetails(api, signedBlock.block.header, blockHash)
+    ])), map(([signedBlock, events, [, validators, author]]) => createSignedBlockExtended(events.registry, signedBlock, events, validators, author))));
+}

package/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/chain/getBlockByNumber.js

@@ -0,0 +1,16 @@
+import { switchMap } from 'rxjs';
+import { memo } from '../util/index.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 function getBlockByNumber(instanceId, api) {
+    return memo(instanceId, (blockNumber) => api.rpc.chain.getBlockHash(blockNumber).pipe(switchMap((h) => api.derive.chain.getBlock(h))));
+}

package/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/chain/getHeader.js

@@ -0,0 +1,19 @@
+import { map, switchMap } from 'rxjs';
+import { createHeaderExtended } from '../type/index.js';
+import { memo } from '../util/index.js';
+import { getAuthorDetails } from './util.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 function getHeader(instanceId, api) {
+    return memo(instanceId, (blockHash) => api.rpc.chain.getHeader(blockHash).pipe(switchMap((header) => getAuthorDetails(api, header, blockHash)), map(([header, validators, author]) => createHeaderExtended((validators || header).registry, header, validators, author))));
+}

package/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/chain/index.js

@@ -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/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/chain/subscribeFinalizedBlocks.js

@@ -0,0 +1,15 @@
+import { switchMap } from 'rxjs';
+import { memo } from '../util/index.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 function subscribeFinalizedBlocks(instanceId, api) {
+    return memo(instanceId, () => api.derive.chain.subscribeFinalizedHeads().pipe(switchMap((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
+}

package/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/chain/subscribeFinalizedHeads.js

@@ -0,0 +1,37 @@
+import { from, of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+export function _getHeaderRange(instanceId, api) {
+    return memo(instanceId, (startHash, endHash, prev = []) => api.rpc.chain.getHeader(startHash).pipe(switchMap((header) => header.parentHash.eq(endHash)
+        ? of([header, ...prev])
+        : api.derive.chain._getHeaderRange(header.parentHash, endHash, [header, ...prev]))));
+}
+/**
+ * @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 function subscribeFinalizedHeads(instanceId, api) {
+    return memo(instanceId, () => {
+        let prevHash = null;
+        return api.rpc.chain.subscribeFinalizedHeads().pipe(switchMap((header) => {
+            const endHash = prevHash;
+            const startHash = header.parentHash;
+            prevHash = header.createdAtHash = header.hash;
+            return endHash === null || startHash.eq(endHash)
+                ? of(header)
+                : api.derive.chain._getHeaderRange(startHash, endHash, [header]).pipe(switchMap((headers) => from(headers)));
+        }));
+    });
+}

package/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/chain/subscribeNewBlocks.js

@@ -0,0 +1,15 @@
+import { switchMap } from 'rxjs';
+import { memo } from '../util/index.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 function subscribeNewBlocks(instanceId, api) {
+    return memo(instanceId, () => api.derive.chain.subscribeNewHeads().pipe(switchMap((header) => api.derive.chain.getBlock(header.createdAtHash || header.hash))));
+}

package/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/chain/subscribeNewHeads.js

@@ -0,0 +1,21 @@
+import { map, switchMap } from 'rxjs';
+import { createHeaderExtended } from '../type/index.js';
+import { memo } from '../util/index.js';
+import { getAuthorDetails } from './util.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 function subscribeNewHeads(instanceId, api) {
+    return memo(instanceId, () => api.rpc.chain.subscribeNewHeads().pipe(switchMap((header) => getAuthorDetails(api, header)), map(([header, validators, author]) => {
+        header.createdAtHash = header.hash;
+        return createHeaderExtended(header.registry, header, validators, author);
+    })));
+}

package/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/chain/util.js

@@ -0,0 +1,57 @@
+import { combineLatest, map, mergeMap, of, switchMap } from 'rxjs';
+import { memo, unwrapBlockNumber } from '../util/index.js';
+export function createBlockNumberDerive(fn) {
+    return (instanceId, api) => memo(instanceId, () => fn(api).pipe(map(unwrapBlockNumber)));
+}
+/** @internal */
+function getAuthorDetailsWithAt(header, queryAt) {
+    const validators = queryAt.session?.validators
+        ? queryAt.session.validators()
+        : of(null);
+    // nimbus consensus stores the session key of the block author in header logs
+    const { logs: [log] } = header.digest;
+    const loggedAuthor = (log && ((log.isConsensus && log.asConsensus[0].isNimbus && log.asConsensus[1]) ||
+        (log.isPreRuntime && log.asPreRuntime[0].isNimbus && log.asPreRuntime[1])));
+    if (loggedAuthor) {
+        // use the author mapping pallet, if available (ie: moonbeam, moonriver), to map session (nimbus) key to author (collator/validator) key
+        if (queryAt['authorMapping']?.['mappingWithDeposit']) {
+            return combineLatest([
+                of(header),
+                validators,
+                queryAt['authorMapping']['mappingWithDeposit'](loggedAuthor).pipe(map((o) => o.unwrapOr({ account: null }).account))
+            ]);
+        }
+        // fall back to session and teyrchain staking pallets, if available (ie: manta, calamari), to map session (nimbus) key to author (collator) key
+        if (queryAt['teyrchainStaking']?.['selectedCandidates'] && queryAt.session?.nextKeys) {
+            const loggedHex = loggedAuthor.toHex();
+            return combineLatest([
+                of(header),
+                validators,
+                queryAt['teyrchainStaking']['selectedCandidates']().pipe(mergeMap((selectedCandidates) => combineLatest([
+                    of(selectedCandidates),
+                    queryAt.session.nextKeys.multi(selectedCandidates).pipe(map((nextKeys) => nextKeys.findIndex((o) => o.unwrapOrDefault().nimbus.toHex() === loggedHex)))
+                ])), map(([selectedCandidates, index]) => index === -1
+                    ? null
+                    : selectedCandidates[index]))
+            ]);
+        }
+    }
+    // normal operation, non-mapping
+    return combineLatest([
+        of(header),
+        validators,
+        of(null)
+    ]);
+}
+export function getAuthorDetails(api, header, blockHash) {
+    // For on-chain state, we need to retrieve it as per the start
+    // of the block being constructed, i.e. session validators would
+    // be at the point of the block construction, not when all operations
+    // has been supplied.
+    //
+    // However for the first block (no parentHash available), we would
+    // just use the as-is
+    return api.queryAt(header.parentHash.isEmpty
+        ? blockHash || header.hash
+        : header.parentHash).pipe(switchMap((queryAt) => getAuthorDetailsWithAt(header, queryAt)));
+}

package/cjs/accounts/accountId.d.ts

@@ -0,0 +1,17 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name accountId
+ * @param {(Address | AccountId | AccountIndex | string | null)} address An accounts address in various formats.
+ * @description Resolves an address (in different formats) to its corresponding `AccountId`.
+ * @example
+ * ```javascript
+ * const ALICE = "F7Hs";
+ *
+ * api.derive.accounts.accountId(ALICE, (accountId) => {
+ *   console.log(`Resolved AccountId: ${accountId}`);
+ * });
+ * ```
+ */
+export declare function accountId(instanceId: string, api: DeriveApi): (address?: Address | AccountId | AccountIndex | string | null) => Observable<AccountId>;

package/cjs/accounts/accountId.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountId = accountId;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name accountId
+ * @param {(Address | AccountId | AccountIndex | string | null)} address An accounts address in various formats.
+ * @description Resolves an address (in different formats) to its corresponding `AccountId`.
+ * @example
+ * ```javascript
+ * const ALICE = "F7Hs";
+ *
+ * api.derive.accounts.accountId(ALICE, (accountId) => {
+ *   console.log(`Resolved AccountId: ${accountId}`);
+ * });
+ * ```
+ */
+function accountId(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (address) => {
+        const decoded = (0, util_1.isU8a)(address)
+            ? address
+            : (0, util_crypto_1.decodeAddress)((address || '').toString());
+        if (decoded.length > 8) {
+            return (0, rxjs_1.of)(api.registry.createType(decoded.length === 20 ? 'AccountId20' : 'AccountId', decoded));
+        }
+        const accountIndex = api.registry.createType('AccountIndex', decoded);
+        return api.derive.accounts.indexToId(accountIndex.toString()).pipe((0, rxjs_1.map)((a) => (0, util_1.assertReturn)(a, 'Unable to retrieve accountId')));
+    });
+}

package/cjs/accounts/flags.d.ts

@@ -0,0 +1,29 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, Address, Balance } from '@pezkuwi/types/interfaces';
+import type { PezpalletElectionsPhragmenSeatHolder } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { DeriveAccountFlags, DeriveApi } from '../types.js';
+type FlagsIntermediate = [
+    PezpalletElectionsPhragmenSeatHolder[] | [AccountId, Balance][] | undefined,
+    AccountId[],
+    AccountId[],
+    AccountId[],
+    Option<AccountId> | AccountId | undefined
+];
+export declare function _flags(instanceId: string, api: DeriveApi): () => Observable<FlagsIntermediate>;
+/**
+ * @name flags
+ * @param {(AccountId | Address | string | null)} address The account identifier.
+ * @description Retrieves the membership flags for a given account.
+ * @example
+ * const ALICE = "F7Hs";
+ *
+ * api.derive.accounts.flags(ALICE, (flags) => {
+ *   console.log(
+ *     `Account Flags:`,
+ *     Object.keys(flags).map((flag) => `${flag}: ${flags[flag]}`)
+ *   );
+ * });
+ */
+export declare function flags(instanceId: string, api: DeriveApi): (address?: AccountId | Address | string | null) => Observable<DeriveAccountFlags>;
+export {};

package/cjs/accounts/flags.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._flags = _flags;
+exports.flags = flags;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+function parseFlags(address, [electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]) {
+    const addrStr = address?.toString();
+    const isIncluded = (id) => id.toString() === addrStr;
+    return {
+        isCouncil: (electionsMembers?.map((r) => Array.isArray(r) ? r[0] : r.who) || councilMembers || []).some(isIncluded),
+        isSociety: (societyMembers || []).some(isIncluded),
+        isSudo: sudoKey?.toString() === addrStr,
+        isTechCommittee: (technicalCommitteeMembers || []).some(isIncluded)
+    };
+}
+function _flags(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => {
+        const results = [undefined, [], [], [], undefined];
+        const calls = [
+            (api.query.elections || api.query['phragmenElection'] || api.query['electionsPhragmen'])?.members,
+            api.query.council?.members,
+            api.query.technicalCommittee?.members,
+            api.query.society?.members,
+            api.query.sudo?.key
+        ];
+        const filtered = calls.filter((c) => c);
+        if (!filtered.length) {
+            return (0, rxjs_1.of)(results);
+        }
+        return api.queryMulti(filtered).pipe((0, rxjs_1.map)((values) => {
+            let resultIndex = -1;
+            for (let i = 0, count = calls.length; i < count; i++) {
+                if ((0, util_1.isFunction)(calls[i])) {
+                    results[i] = values[++resultIndex];
+                }
+            }
+            return results;
+        }));
+    });
+}
+/**
+ * @name flags
+ * @param {(AccountId | Address | string | null)} address The account identifier.
+ * @description Retrieves the membership flags for a given account.
+ * @example
+ * const ALICE = "F7Hs";
+ *
+ * api.derive.accounts.flags(ALICE, (flags) => {
+ *   console.log(
+ *     `Account Flags:`,
+ *     Object.keys(flags).map((flag) => `${flag}: ${flags[flag]}`)
+ *   );
+ * });
+ */
+function flags(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (address) => api.derive.accounts._flags().pipe((0, rxjs_1.map)((r) => parseFlags(address, r))));
+}

package/cjs/accounts/idAndIndex.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { AccountIdAndIndex, DeriveApi } from '../types.js';
+/**
+ * @name idAndIndex
+ * @param {(Address | AccountId | AccountIndex | Uint8Array | string | null)} address An accounts address in various formats.
+ * @description An array containing the [[AccountId]] and [[AccountIndex]] as optional values.
+ * @example
+ * ```javascript
+ * api.derive.accounts.idAndIndex('F7Hs', ([id, ix]) => {
+ *   console.log(`AccountId #${id} with corresponding AccountIndex ${ix}`);
+ * });
+ * ```
+ */
+export declare function idAndIndex(instanceId: string, api: DeriveApi): (address?: Address | AccountId | AccountIndex | Uint8Array | string | null) => Observable<AccountIdAndIndex>;

package/cjs/accounts/idAndIndex.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idAndIndex = idAndIndex;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name idAndIndex
+ * @param {(Address | AccountId | AccountIndex | Uint8Array | string | null)} address An accounts address in various formats.
+ * @description An array containing the [[AccountId]] and [[AccountIndex]] as optional values.
+ * @example
+ * ```javascript
+ * api.derive.accounts.idAndIndex('F7Hs', ([id, ix]) => {
+ *   console.log(`AccountId #${id} with corresponding AccountIndex ${ix}`);
+ * });
+ * ```
+ */
+function idAndIndex(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (address) => {
+        try {
+            // yes, this can fail, don't care too much, catch will catch it
+            const decoded = (0, util_1.isU8a)(address)
+                ? address
+                : (0, util_crypto_1.decodeAddress)((address || '').toString());
+            if (decoded.length > 8) {
+                const accountId = api.registry.createType(decoded.length === 20 ? 'AccountId20' : 'AccountId', decoded);
+                return api.derive.accounts.idToIndex(accountId).pipe((0, rxjs_1.map)((accountIndex) => [accountId, accountIndex]));
+            }
+            const accountIndex = api.registry.createType('AccountIndex', decoded);
+            return api.derive.accounts.indexToId(accountIndex.toString()).pipe((0, rxjs_1.map)((accountId) => [accountId, accountIndex]));
+        }
+        catch {
+            return (0, rxjs_1.of)([undefined, undefined]);
+        }
+    });
+}