@pezkuwi/api-derive 16.5.5 → 16.5.8

package/build-tsc/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/build-tsc/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/build-tsc/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-tsc/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-tsc/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-tsc/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-tsc/balances/types.d.ts

@@ -0,0 +1,69 @@
+import type { AccountId, Balance, BalanceLockTo212, Index } from '@pezkuwi/types/interfaces';
+import type { PezpalletBalancesBalanceLock, PezpalletBalancesReserveData } 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 `PezframeSystemAccountInfo`.
+     * See `transferable` for the correct balance calculation.
+     *
+     * ref: https://github.com/pezkuwichain/bizinikiwi/pull/12951
+     */
+    availableBalance: Balance;
+    /**
+     * The amount of balance locked away.
+     */
+    lockedBalance: Balance;
+    /**
+     * The breakdown of locked balances.
+     */
+    lockedBreakdown: (PezpalletBalancesBalanceLock | 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 `PezframeSystemAccountInfo`.
+     * Which is the most up to date calulcation for transferrable balances.
+     *
+     * ref: https://github.com/pezkuwichain/pezkuwi-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: PezpalletBalancesReserveData[][];
+}
+export type DeriveBalancesMap = Record<string, DeriveBalancesAll>;

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

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

package/build-tsc/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-tsc/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-tsc/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-tsc/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-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/collective/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { Collective } from './types.js';
+export declare function getInstance(api: DeriveApi, section: string): DeriveApi['query']['council'];
+export declare function withSection<T, F extends (...args: any[]) => Observable<T>>(section: Collective, fn: (query: DeriveApi['query']['council'], api: DeriveApi, instanceId: string) => F): (instanceId: string, api: DeriveApi) => F;
+export declare function callMethod<T>(method: 'members' | 'proposals' | 'proposalCount', empty: T): (section: Collective) => (instanceId: string, api: DeriveApi) => () => Observable<T>;

package/build-tsc/collective/index.d.ts

@@ -0,0 +1,3 @@
+export * from './members.js';
+export * from './prime.js';
+export * from './proposals.js';

package/build-tsc/collective/members.d.ts

@@ -0,0 +1,2 @@
+import type { MembersFn } from './types.js';
+export declare const members: MembersFn;

package/build-tsc/collective/prime.d.ts

@@ -0,0 +1,2 @@
+import type { Collective, PrimeFnRet } from './types.js';
+export declare function prime(section: Collective): PrimeFnRet;

package/build-tsc/collective/proposals.d.ts

@@ -0,0 +1,6 @@
+import type { Collective, HasProposalsFnRet, ProposalCountFn, ProposalFnRet, ProposalHashesFn, ProposalsFnRet } from './types.js';
+export declare function hasProposals(section: Collective): HasProposalsFnRet;
+export declare function proposals(section: Collective): ProposalsFnRet;
+export declare function proposal(section: Collective): ProposalFnRet;
+export declare const proposalCount: ProposalCountFn;
+export declare const proposalHashes: ProposalHashesFn;

package/build-tsc/collective/types.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
+export type Collective = 'allianceMotion' | 'council' | 'membership' | 'technicalCommittee';
+export type HasProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<boolean>;
+export type HasProposalsFn = (section: Collective) => HasProposalsFnRet;
+export type MembersFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId[]>;
+export type MembersFn = (section: Collective) => MembersFnRet;
+export type PrimeFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId | null>;
+export type PrimeFn = (section: Collective) => PrimeFnRet;
+export type ProposalFnRet = (instanceId: string, api: DeriveApi) => (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null>;
+export type ProposalFn = (section: Collective) => ProposalFnRet;
+export type ProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<DeriveCollectiveProposal[]>;
+export type ProposalsFn = (section: Collective) => ProposalsFnRet;
+export type ProposalCountFnRet = (instanceId: string, api: DeriveApi) => () => Observable<u32 | null>;
+export type ProposalCountFn = (section: Collective) => ProposalCountFnRet;
+export type ProposalHashesFnRet = (instanceId: string, api: DeriveApi) => () => Observable<Hash[]>;
+export type ProposalHashesFn = (section: Collective) => ProposalHashesFnRet;

package/build-tsc/contracts/fees.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveContractFees } from '../types.js';
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export declare function fees(instanceId: string, api: DeriveApi): () => Observable<DeriveContractFees>;

package/build-tsc/contracts/index.d.ts

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

package/build-tsc/council/index.d.ts

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

package/build-tsc/council/types.d.ts

@@ -0,0 +1,6 @@
+import type { AccountId, Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveCouncilVote {
+    stake: Balance;
+    votes: AccountId[];
+}
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

package/build-tsc/council/votes.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveCouncilVotes } from '../types.js';
+/**
+ * @name votes
+ * @description Retrieves the council election votes for all participants.
+ * @example
+ * ```javascript
+ * const votes = await api.derive.council.votes();
+ * ```
+ */
+export declare function votes(instanceId: string, api: DeriveApi): () => Observable<DeriveCouncilVotes>;

package/build-tsc/council/votesOf.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCouncilVote } from '../types.js';
+/**
+ * @name votesOf
+ * @description Retrieves the council votes associated with a given account.
+ * @returns The stake and the list of candidates the account has voted for.
+ * @param {string | Uint8Array | AccountId} accountId The accountId to retrieve votes for.
+ * @example
+ * ```javascript
+ * const accountId = "5Gw3s7qQ9Z..."; // Replace with a valid account ID
+ * const votes = await api.derive.council.votesOf(accountId);
+ * console.log("Account votes:", votes);
+ * ```
+ */
+export declare function votesOf(instanceId: string, api: DeriveApi): (accountId: string | Uint8Array | AccountId) => Observable<DeriveCouncilVote>;

package/build-tsc/crowdloan/childKey.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name childKey
+ * @description Retrieves the child storage key for a given teyrchain’s crowdloan contributions.
+ * This key is used to access contribution data stored in a separate child trie of the blockchain’s state.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const childKey = await api.derive.crowdloan.childKey(3369);
+ * console.log("Child Key:", childKey);
+ * ```
+ */
+export declare function childKey(instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<string | null>;

package/build-tsc/crowdloan/contributions.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveContributions } from '../types.js';
+/**
+ * @name contributions
+ * @description Retrieves all contributions for a given teyrchain crowdloan.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.contributions(3369);
+ * console.log("Contributions:", contributions);
+ * ```
+ */
+export declare function contributions(instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<DeriveContributions>;

package/build-tsc/crowdloan/index.d.ts

@@ -0,0 +1,3 @@
+export * from './childKey.js';
+export * from './contributions.js';
+export * from './ownContributions.js';

package/build-tsc/crowdloan/ownContributions.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveOwnContributions } from '../types.js';
+/**
+ * @name ownContributions
+ * @description Retrieves the contribution amounts made by specific accounts (`keys`) to a given teyrchain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @param {string[]} keys An array of account addresses whose contributions are to be fetched.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.ownContributions(2000, ['5Ff...PqV', '5Gg...XyZ']);
+ * console.log("Own Contributions:", contributions);
+ * ```
+ */
+export declare function ownContributions(instanceId: string, api: DeriveApi): (paraId: string | number | BN, keys: string[]) => Observable<DeriveOwnContributions>;

package/build-tsc/crowdloan/types.d.ts

@@ -0,0 +1,6 @@
+import type { Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveContributions {
+    blockHash: string;
+    contributorsHex: string[];
+}
+export type DeriveOwnContributions = Record<string, Balance>;