@pezkuwi/api-derive 16.5.5

package/README.md

@@ -0,0 +1,30 @@
+# @pezkuwi/api-derive
+
+Collection of high-level utility functions built on top of the @pezkuwi/api library. Designed to simplify the process of querying complex on-chain data by combining multiple RPC calls, storage queries, and runtime logic into a single, callable function.
+
+Instead of manually fetching and processing blockchain data, developers can use `api.derive` methods to retrieve information.
+
+## Available Derive Namespaces
+
+The derive functions are categorized into namespaces based on different common Substrate modules. Accesible by calling `api.derive.NAMESPACE` (e.g. `api.derive.balances`). The available modules are as follows:
+
+- [accounts](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/accounts)
+- [alliance](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/alliance)
+- [bagsList](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/bagsList)
+- [balances](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/balances)
+- [bounties](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/bounties)
+- [chain](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/chain)
+- [contracts](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/contracts)
+- [council](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/council)
+- [crowdloan](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/crowdloan)
+- [democracy](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/democracy)
+- [elections](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/elections)
+- [imOnline](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/imOnline)
+- [membership](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/membership)
+- [parachains](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/parachains)
+- [session](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/session)
+- [society](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/society)
+- [staking](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/staking)
+- [technicalCommittee](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/technicalCommittee)
+- [treasury](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/treasury)
+- [tx](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/tx)

package/build/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/build/accounts/flags.d.ts

@@ -0,0 +1,29 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, Address, Balance } from '@pezkuwi/types/interfaces';
+import type { PalletElectionsPhragmenSeatHolder } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { DeriveAccountFlags, DeriveApi } from '../types.js';
+type FlagsIntermediate = [
+    PalletElectionsPhragmenSeatHolder[] | [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/build/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/build/accounts/idToIndex.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name idToIndex
+ * @description Retrieves the corresponding AccountIndex.
+ * @param {( AccountId | string )} accountId An accounts Id in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+ * api.derive.accounts.idToIndex(ALICE, (accountIndex) => {
+ *   console.log(`The AccountIndex of ${ALICE} is ${accountIndex}`);
+ * });
+ * ```
+ */
+export declare function idToIndex(instanceId: string, api: DeriveApi): (accountId: AccountId | string) => Observable<AccountIndex | undefined>;

package/build/accounts/identity.d.ts

@@ -0,0 +1,48 @@
+import type { Observable } from 'rxjs';
+import type { Bytes, Data } from '@pezkuwi/types';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { PalletIdentityRegistration } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { DeriveAccountRegistration, DeriveApi, DeriveHasIdentity } from '../types.js';
+export declare function _identity(instanceId: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<[Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]>;
+/**
+ * @name identity
+ * @description Retrieves the on chain identity information for a given account.
+ * @param {(AccountId | Uint8Array | string)} accoutId The account identifier to query the identity for.
+ * @example
+ * ```javascript
+ * const ALICE = "13xAUH";
+ *
+ * api.derive.accounts.identity(ALICE, (identity) => {
+ *   console.log(
+ *     "Account Identity:",
+ *     Object.keys(identity).map((key) => `${key}: ${identity[key]}`)
+ *   );
+ * });
+ * ```
+ */
+export declare function identity(instanceId: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<DeriveAccountRegistration>;
+/**
+ * @name hasIdentity
+ * @description Checks if a specific account has an identity registered on chain.
+ * @param {(AccountId | Uint8Array | string)} accoutId The account identifier to query.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * console.log(await api.derive.accounts.hasIdentity(ALICE));
+ * ```
+ */
+export declare const hasIdentity: (instanceId: string, api: DeriveApi) => (accountId: string | AccountId | Uint8Array<ArrayBufferLike>) => Observable<DeriveHasIdentity>;
+/**
+ * @name hasIdentityMulti
+ * @description Checks whether multiple accounts have on chain identities registered.
+ * @param {(AccountId | Uint8Array | string)[]} accountIds Array of account identifiers to query.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const BOB = "16WW";
+ * console.log(await api.derive.accounts.hasIdentityMulti([ALICE, BOB]));
+ * ```
+ */
+export declare function hasIdentityMulti(instanceId: string, api: DeriveApi): (accountIds: (AccountId | Uint8Array | string)[]) => Observable<DeriveHasIdentity[]>;

package/build/accounts/index.d.ts

@@ -0,0 +1,8 @@
+export * from './accountId.js';
+export * from './flags.js';
+export * from './idAndIndex.js';
+export * from './identity.js';
+export * from './idToIndex.js';
+export * from './indexes.js';
+export * from './indexToId.js';
+export * from './info.js';

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

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

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

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

package/build/bagsList/listNodes.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { PalletBagsListListBag, PalletBagsListListNode } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name listNodes
+ * @param {(PalletBagsListListBag | 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: PalletBagsListListBag | null) => Observable<PalletBagsListListNode[]>;

package/build/bagsList/types.d.ts

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

package/build/bagsList/util.d.ts

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

package/build/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>;

package/build/balances/all.d.ts

@@ -0,0 +1,20 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveBalancesAll } from '../types.js';
+/**
+ * @name all
+ * @description Retrieves the complete balance information for an account, including free balance, locked balance, reserved balance, and more.
+ * @param {( AccountId | string )} address An accountsId in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = 'F7Hs';
+ *
+ * api.derive.balances.account(ALICE, (accountInfo) => {
+ *   console.log(
+ *     `${accountInfo.accountId} info:`,
+ *     Object.keys(accountInfo).map((key) => `${key}: ${accountInfo[key]}`)
+ *   );
+ * });
+ * ```
+ */
+export declare function all(instanceId: string, api: DeriveApi): (address: AccountId | string) => Observable<DeriveBalancesAll>;

package/build/balances/index.d.ts

@@ -0,0 +1,20 @@
+import { all } from './all.js';
+export * from './account.js';
+export * from './votingBalances.js';
+/**
+ * @name votingBalance
+ * @param {( AccountId | string )} address An accounts Id in different formats.
+ * @returns An object containing the results of various balance queries
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * const ALICE = 'F7Hs';
+ *
+ * api.derive.balances.votingBalance(ALICE, ({ accountId, lockedBalance }) => {
+ *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
+ * });
+ * ```
+ */
+declare const votingBalance: typeof all;
+export { all, votingBalance };

package/build/balances/types.d.ts

@@ -0,0 +1,69 @@
+import type { AccountId, Balance, BalanceLockTo212, Index } from '@pezkuwi/types/interfaces';
+import type { PalletBalancesBalanceLock, PalletBalancesReserveData } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+export interface DeriveBalancesAccountData {
+    frameSystemAccountInfo?: {
+        frozen: Balance;
+        flags: Balance;
+    };
+    freeBalance: Balance;
+    frozenFee: Balance;
+    frozenMisc: Balance;
+    reservedBalance: Balance;
+    votingBalance: Balance;
+}
+export interface DeriveBalancesAccount extends DeriveBalancesAccountData {
+    accountId: AccountId;
+    accountNonce: Index;
+    additional: DeriveBalancesAccountData[];
+}
+export interface DeriveBalancesAllAccountData extends DeriveBalancesAccountData {
+    /**
+     * Calculated available balance. This uses the formula: max(0, free - locked)
+     * This is only correct when the return type of `api.query.system.account` is `AccountInfo` which was replaced by `FrameSystemAccountInfo`.
+     * See `transferable` for the correct balance calculation.
+     *
+     * ref: https://github.com/paritytech/substrate/pull/12951
+     */
+    availableBalance: Balance;
+    /**
+     * The amount of balance locked away.
+     */
+    lockedBalance: Balance;
+    /**
+     * The breakdown of locked balances.
+     */
+    lockedBreakdown: (PalletBalancesBalanceLock | BalanceLockTo212)[];
+    /**
+     * Calculated transferable balance. This uses the formula: free - max(maybeEd, frozen - reserve)
+     * Where `maybeEd` means if there is no frozen and reserves it will be zero, else it will be the existential deposit.
+     * This is only correct when the return type of `api.query.system.account` is `FrameSystemAccountInfo`.
+     * Which is the most up to date calulcation for transferrable balances.
+     *
+     * ref: https://github.com/paritytech/polkadot-sdk/issues/1833
+     */
+    transferable: Balance | null;
+    /**
+     * Amount locked in vesting.
+     */
+    vestingLocked: Balance;
+}
+export interface DeriveBalancesVesting {
+    startingBlock: BN;
+    endBlock: BN;
+    perBlock: BN;
+    locked: BN;
+    vested: BN;
+}
+export interface DeriveBalancesAllVesting {
+    isVesting: boolean;
+    vestedBalance: BN;
+    vestedClaimable: BN;
+    vesting: DeriveBalancesVesting[];
+    vestingTotal: BN;
+}
+export interface DeriveBalancesAll extends DeriveBalancesAccount, DeriveBalancesAllAccountData, DeriveBalancesAllVesting {
+    additional: DeriveBalancesAllAccountData[];
+    namedReserves: PalletBalancesReserveData[][];
+}
+export type DeriveBalancesMap = Record<string, DeriveBalancesAll>;

package/build/balances/votingBalances.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveBalancesAccount } from '../types.js';
+/**
+ * @name votingBalances
+ * @description Retrieves the balance information for multiple accounts, typically used in governance-related contexts to check voting power.
+ * @param {(AccountId | AccountIndex | Address | string)[]} addresses An array of account identifiers.
+ * @example
+ * ```javascript
+ * const addresses = ["5D4b...Zf1", "5HGj...yrV"];
+ * const balances = await api.derive.balances.votingBalances(addresses);
+ * console.log("Voting Balances:", balances);
+ * ```
+ */
+export declare function votingBalances(instanceId: string, api: DeriveApi): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DeriveBalancesAccount[]>;

package/build/bounties/bounties.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveBounties } from '../types.js';
+/**
+ * @name bounties
+ * @descrive Retrieves all active bounties, their descriptions, and associated proposals.
+ * @example
+ * ```javascript
+ * const bounties = await api.derive.bounties();
+ * console.log("Active bounties:", bounties);
+ * ```
+ */
+export declare function bounties(instanceId: string, api: DeriveApi): () => Observable<DeriveBounties>;

package/build/bounties/helpers/filterBountyProposals.d.ts

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

package/build/bounties/index.d.ts

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

package/build/bundle.d.ts

@@ -0,0 +1,9 @@
+import type { DeriveCustom } from '@pezkuwi/api-base/types';
+import type { ExactDerive } from './derive.js';
+import type { DeriveApi } from './types.js';
+import { lazyDeriveSection } from './util/index.js';
+export * from './derive.js';
+export * from './type/index.js';
+export { lazyDeriveSection };
+/** @internal */
+export declare function getAvailableDerives(instanceId: string, api: DeriveApi, custom?: DeriveCustom): ExactDerive;

package/build/chain/bestNumber.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @name bestNumber
+ * @descrive Retrieves the latest block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumber((blockNumber) => {
+ *   console.log(`the current best block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export declare const bestNumber: import("./util.js").BlockNumberDerive;

package/build/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/build/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/build/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>;