@pezkuwi/api-derive 16.5.6 → 16.5.8

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

@@ -0,0 +1,139 @@
+import type { Option, u32, Vec } from '@pezkuwi/types';
+import type { AccountId, Balance, EraIndex, RewardPoint } from '@pezkuwi/types/interfaces';
+import type { PezpalletStakingRewardDestination, PezpalletStakingStakingLedger, PezpalletStakingValidatorPrefs, PezspStakingExposure, PezspStakingExposurePage, PezspStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveSessionIndexes } from '../session/types.js';
+export type DeriveEraValPoints = Record<string, RewardPoint>;
+export type DeriveEraValPrefs = Record<string, PezpalletStakingValidatorPrefs>;
+export type DeriveEraValSlash = Record<string, Balance>;
+export interface DeriveEraPoints {
+    era: EraIndex;
+    eraPoints: RewardPoint;
+    validators: DeriveEraValPoints;
+}
+export interface DeriveEraPrefs {
+    era: EraIndex;
+    validators: DeriveEraValPrefs;
+}
+export interface DeriveEraRewards {
+    era: EraIndex;
+    eraReward: Balance;
+}
+export interface DeriveEraSlashes {
+    era: EraIndex;
+    nominators: DeriveEraValSlash;
+    validators: DeriveEraValSlash;
+}
+export interface DeriveStakerPoints {
+    era: EraIndex;
+    eraPoints: RewardPoint;
+    points: RewardPoint;
+}
+export interface DeriveOwnExposure {
+    clipped: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
+    era: EraIndex;
+    exposure: PezspStakingExposure;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
+}
+export interface DeriveEraExposureNominating {
+    validatorId: string;
+    validatorIndex: number;
+}
+export type DeriveEraNominatorExposure = Record<string, DeriveEraExposureNominating[]>;
+export type DeriveEraValidatorExposure = Record<string, PezspStakingExposure>;
+export type DeriveEraValidatorExposurePaged = Record<string, PezspStakingExposurePage | PezspStakingExposure>;
+export interface DeriveEraExposure {
+    era: EraIndex;
+    nominators: DeriveEraNominatorExposure;
+    validators: DeriveEraValidatorExposure;
+}
+export interface DeriveEraExposurePaged {
+    era: EraIndex;
+    nominators: DeriveEraNominatorExposure;
+    validators: DeriveEraValidatorExposurePaged;
+}
+export interface DeriveStakerExposure {
+    era: EraIndex;
+    isEmpty: boolean;
+    isValidator: boolean;
+    nominating: DeriveEraExposureNominating[];
+    validators: DeriveEraValidatorExposurePaged;
+}
+export interface DeriveStakerPrefs {
+    era: EraIndex;
+    validatorPrefs: PezpalletStakingValidatorPrefs;
+}
+export interface DeriveStakerRewardValidator {
+    total: Balance;
+    value: Balance;
+}
+export interface DeriveStakerReward {
+    era: EraIndex;
+    eraReward: Balance;
+    isClaimed: boolean;
+    isEmpty: boolean;
+    isValidator: boolean;
+    nominating: DeriveEraExposureNominating[];
+    validators: Record<string, DeriveStakerRewardValidator>;
+}
+export interface DeriveStakerSlashes {
+    era: EraIndex;
+    total: Balance;
+}
+export type DeriveOwnSlashes = DeriveStakerSlashes;
+export interface DeriveStakingKeys {
+    nextSessionIds: AccountId[];
+    sessionIds: AccountId[];
+}
+export interface DeriveStakingValidators {
+    nextElected: AccountId[];
+    validators: AccountId[];
+}
+export interface DeriveStakingStash {
+    controllerId: AccountId | null;
+    exposureEraStakers: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
+    nominators: AccountId[];
+    rewardDestination: PezpalletStakingRewardDestination | null;
+    stashId: AccountId;
+    validatorPrefs: PezpalletStakingValidatorPrefs;
+    claimedRewardsEras: Vec<u32>;
+}
+export interface DeriveStakingQuery extends DeriveStakingStash {
+    accountId: AccountId;
+    stakingLedger: PezpalletStakingStakingLedger;
+}
+export interface DeriveStakingElected {
+    info: DeriveStakingQuery[];
+    nextElected: AccountId[];
+    validators: AccountId[];
+}
+export interface DeriveStakingWaiting {
+    info: DeriveStakingQuery[];
+    waiting: AccountId[];
+}
+export interface DeriveUnlocking {
+    remainingEras: BN;
+    value: Balance;
+}
+export interface DeriveStakingAccount extends DeriveStakingQuery, DeriveStakingKeys {
+    redeemable?: Balance;
+    unlocking?: DeriveUnlocking[];
+}
+export interface DeriveStakingOverview extends DeriveSessionIndexes {
+    nextElected: AccountId[];
+    validators: AccountId[];
+}
+export interface StakingQueryFlags {
+    withController?: boolean;
+    withDestination?: boolean;
+    withExposure?: boolean;
+    withExposureErasStakersLegacy?: boolean;
+    withLedger?: boolean;
+    withNominations?: boolean;
+    withPrefs?: boolean;
+    withExposureMeta?: boolean;
+    withClaimedRewardsEras?: boolean;
+}

package/build-tsc/staking/util.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { ObsInnerType } from '@pezkuwi/api-base/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { ExactDerive } from '../derive.js';
+import type { DeriveApi } from '../types.js';
+type ApplyReturn<T extends keyof ExactDerive['staking']> = ReturnType<ExactDerive['staking'][T]>;
+export declare function filterEras<T extends {
+    era: EraIndex;
+}>(eras: EraIndex[], list: T[]): EraIndex[];
+export declare function erasHistoricApply<F extends '_erasExposure' | '_erasPoints' | '_erasPrefs' | '_erasRewards' | '_erasSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (withActive?: boolean) => ApplyReturn<F>;
+export declare function erasHistoricApplyAccount<F extends '_ownExposures' | '_ownSlashes' | '_stakerPoints' | '_stakerPrefs' | '_stakerSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean) => ApplyReturn<F>;
+export declare function singleEra<F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (era: EraIndex) => ApplyReturn<F>;
+export declare function combineEras<F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<ObsInnerType<ApplyReturn<F>>[]>;
+export {};

package/build-tsc/staking/validators.d.ts

@@ -0,0 +1,33 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveStakingValidators } from '../types.js';
+/**
+ * @name nextElected
+ * @description Retrieves the list of accounts that are set to be the next elected validators in the staking system. It provides a preview of who will be validators in the next staking era.
+ * @example
+ * ```javascript
+ * const nextElected = await api.derive.staking.nextElected();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export declare function nextElected(instanceId: string, api: DeriveApi): () => Observable<AccountId[]>;
+/**
+ * @name validators
+ * @description Retrieve latest list of validators.
+ * @example
+ * ```javascript
+ * const { validators, nextElected } = await api.derive.staking.validators();
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((v) => v.toString())
+ * );
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((v) => v.toString())
+ * );
+ * ```
+ */
+export declare function validators(instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators>;

package/build-tsc/staking/waitingInfo.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingWaiting, StakingQueryFlags } from '../types.js';
+/**
+ * @name waitingInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @description Staking candidates who are waiting to become validators.
+ * @example
+ * ```javascript
+ * const { waiting, info } = await api.derive.staking.waitingInfo();
+ * console.log(
+ *   "Waiting Candidates:",
+ *   waiting.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export declare function waitingInfo(instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags) => Observable<DeriveStakingWaiting>;

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

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

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

@@ -0,0 +1,2 @@
+export * from './info.js';
+export * from './overview.js';

package/build-tsc/teyrchains/info.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveTeyrchainFull } from '../types.js';
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Teyrchain information not available.");
+ *   }
+ * });
+ * ```
+*/
+export declare function info(instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveTeyrchainFull | null>;

package/build-tsc/teyrchains/overview.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveTeyrchain } from '../types.js';
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveTeyrchain[]>;

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

@@ -0,0 +1,38 @@
+import type { Bytes, Option, u32, Vec } from '@pezkuwi/types';
+import type { CollatorId, ParaId, ParaInfo, Retriable, UpwardMessage } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+export type ParaInfoResult = Option<ParaInfo>;
+export type PendingSwap = Option<ParaId>;
+export type Active = Vec<ITuple<[ParaId, Option<ITuple<[CollatorId, Retriable]>>]>>;
+export type RetryQueue = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type SelectedThreads = Vec<Vec<ITuple<[ParaId, CollatorId]>>>;
+export type Code = Bytes;
+export type Heads = Bytes;
+export type RelayDispatchQueue = Vec<UpwardMessage>;
+export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
+export type DidUpdate = Option<Vec<ParaId>>;
+export interface DeriveTeyrchainActive {
+    collatorId: CollatorId;
+    isRetriable: boolean;
+    retries: number;
+}
+export interface DeriveTeyrchainInfo extends ParaInfo {
+    id: ParaId;
+    icon?: string;
+    name?: string;
+    owner?: string;
+}
+export interface DeriveTeyrchain {
+    didUpdate: boolean;
+    pendingSwapId: ParaId | null;
+    id: ParaId;
+    info: DeriveTeyrchainInfo | null;
+    relayDispatchQueueSize?: number;
+}
+export interface DeriveTeyrchainFull extends DeriveTeyrchain {
+    active: DeriveTeyrchainActive | null;
+    heads: Bytes | null;
+    relayDispatchQueue: UpwardMessage[];
+    retryCollators: (CollatorId | null)[];
+    selectedCollators: (CollatorId | null)[];
+}

package/build-tsc/teyrchains/util.d.ts

@@ -0,0 +1,3 @@
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DidUpdate } from './types.js';
+export declare function didUpdateToBool(didUpdate: DidUpdate, id: ParaId): boolean;

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

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

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

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveTreasuryProposals } from '../types.js';
+/**
+ * @name proposals
+ * @description Retrieve all active and approved treasury proposals, along with their info.
+ * @example
+ * ```javascript
+ * const treasuryProposals = await api.derive.treasury.proposals();
+ * console.log(treasuryProposals);
+ * ```
+ */
+export declare function proposals(instanceId: string, api: DeriveApi): () => Observable<DeriveTreasuryProposals>;

package/build-tsc/tx/constants.d.ts

@@ -0,0 +1,5 @@
+import { BN } from '@pezkuwi/util';
+export declare const FALLBACK_MAX_HASH_COUNT = 250;
+export declare const FALLBACK_PERIOD: BN;
+export declare const MAX_FINALITY_LAG: BN;
+export declare const MORTAL_PERIOD: BN;

package/build-tsc/tx/events.d.ts

@@ -0,0 +1,22 @@
+import type { Observable } from 'rxjs';
+import type { EventRecord, Hash, SignedBlock } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+interface Result {
+    block: SignedBlock;
+    events: EventRecord[];
+}
+/**
+ * @name events
+ * @param {Hash} at Block hash to query at.
+ * @description Retrieves the block information alongside its events at a given block hash
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   "Hash",
+ *   "0xf1dc2efe8265be67deea5e91b05a98a7f9f81f66854e92825cf36f541beb7af6"
+ * );
+ * const { events, block } = await api.derive.tx.events(blockHash);
+ * ```
+ */
+export declare function events(instanceId: string, api: DeriveApi): (at: Hash) => Observable<Result>;
+export {};

package/build-tsc/tx/extrinsicInfo.d.ts

@@ -0,0 +1,61 @@
+import type { Observable } from 'rxjs';
+import type { GenericExtrinsic } from '@pezkuwi/types';
+import type { EventRecord, Hash } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+interface ExtrinsicInfo {
+    blockHash: Hash | string;
+    blockNumber: number;
+    extrinsic: GenericExtrinsic;
+    events: EventRecord[];
+    success: boolean;
+}
+interface ExtrinsicsInfo {
+    blockHash: Hash | string;
+    blockNumber: number;
+    extrinsics: {
+        events: EventRecord[];
+        extrinsic: GenericExtrinsic;
+        success: boolean;
+    }[];
+}
+/**
+ * @name extrinsicInfo
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | string } transactionHash A transaction hash as U8 array or string.
+ * @description Retrieves the extrinsic information and its events.
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   'Hash',
+ *   '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+ * );
+ * const extrinsicInfo = await api.derive.tx.extrinsicInfo(
+ *   blockHash,
+ *   '0xcd96520b05e0c4648ea365f3f063f27c5cdd8be10d41a1c44566428c91f37dcb'
+ * );
+ *
+ * console.log(extrinsicInfo.extrinsic.toHuman());
+ * ```
+ */
+export declare function extrinsicInfo(instanceId: string, api: DeriveApi): (at: Hash, transactionHash: Uint8Array | string) => Observable<ExtrinsicInfo | null>;
+/**
+ * @name accountExtrinsics
+ * @description Retrieves information about every extrinsic submitted by an account at a given block.
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | strings } accountId The account identifier to query.
+ * @example
+ * ```javascript
+   const blockHash = api.registry.createType(
+    'Hash',
+    '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+  );
+  const extrinsicsInfo = await api.derive.tx.accountExtrinsics(
+    blockHash,
+    '0x21895DdfD4640b4e0aDCa2865b907f2CE6e6B777'
+  );
+
+  console.log(extrinsicsInfo.extrinsics[0]).extrinsic.toHuman();
+ * ```
+ */
+export declare function accountExtrinsics(instanceId: string, api: DeriveApi): (at: Hash, accountId: Uint8Array | string) => Observable<ExtrinsicsInfo>;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './events.js';
+export * from './extrinsicInfo.js';
+export * from './signingInfo.js';

package/build-tsc/tx/signingInfo.d.ts

@@ -0,0 +1,25 @@
+import type { Observable } from 'rxjs';
+import type { Header, Index } from '@pezkuwi/types/interfaces';
+import type { AnyNumber, Codec, IExtrinsicEra } from '@pezkuwi/types/types';
+import type { DeriveApi } from '../types.js';
+interface Result {
+    header: Header | null;
+    mortalLength: number;
+    nonce: Index;
+}
+/**
+ * @name signingInfo
+ * @description Retrieves signing-related information for an account, including the nonce, block header, and mortal length.
+ * @param {string} address The account address for which signing information is needed.
+ * @param { BN | bigint | Uint8Array | number | string } nonce? (Optional) The nonce to use. If `undefined`, the latest nonce is retrieved.
+ * @param { IExtrinsicEra | number } era? (Optional) The transaction era.
+ * @example
+ * ```javascript
+ * const info = await api.derive.tx.signingInfo(
+ *   "14mM9FRDDtwSYicjNxSvMfQkap8o4m9zHq7hNW4JpbSL4PPU"
+ * );
+ * console.log(info);
+ * ```
+ */
+export declare function signingInfo(_instanceId: string, api: DeriveApi): (address: string, nonce?: AnyNumber | Codec, era?: IExtrinsicEra | number) => Observable<Result>;
+export {};

package/build-tsc/type/HeaderExtended.d.ts

@@ -0,0 +1,4 @@
+import type { AccountId, Header } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+import type { HeaderExtended } from './types.js';
+export declare function createHeaderExtended(registry: Registry, header?: Header, validators?: AccountId[] | null, author?: AccountId | null): HeaderExtended;

package/build-tsc/type/SignedBlockExtended.d.ts

@@ -0,0 +1,4 @@
+import type { AccountId, EventRecord, SignedBlock } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+import type { SignedBlockExtended } from './types.js';
+export declare function createSignedBlockExtended(registry: Registry, block?: SignedBlock, events?: EventRecord[], validators?: AccountId[] | null, author?: AccountId | null): SignedBlockExtended;

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

@@ -0,0 +1,2 @@
+export { createHeaderExtended } from './HeaderExtended.js';
+export { createSignedBlockExtended } from './SignedBlockExtended.js';

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

@@ -0,0 +1,15 @@
+import type { AccountId, DispatchError, DispatchInfo, Event, EventRecord, Extrinsic, Header, SignedBlock } from '@pezkuwi/types/interfaces';
+export interface HeaderExtended extends Header {
+    readonly author: AccountId | undefined;
+}
+export interface SignedBlockExtended extends SignedBlock {
+    readonly author: AccountId | undefined;
+    readonly events: EventRecord[];
+    readonly extrinsics: TxWithEvent[];
+}
+export interface TxWithEvent {
+    dispatchError?: DispatchError | undefined;
+    dispatchInfo?: DispatchInfo | undefined;
+    events: Event[];
+    extrinsic: Extrinsic;
+}

package/build-tsc/type/util.d.ts

@@ -0,0 +1,2 @@
+import type { AccountId, Digest } from '@pezkuwi/types/interfaces';
+export declare function extractAuthor(digest: Digest, sessionValidators: AccountId[]): AccountId | undefined;

package/build-tsc/types.d.ts

@@ -0,0 +1,79 @@
+import type { ApiInterfaceRx } from '@pezkuwi/api-base/types';
+import type { u32 } from '@pezkuwi/types';
+import type { Balance, BlockNumber, BountyIndex, Hash, Proposal, ProposalIndex, SetIndex, Votes } from '@pezkuwi/types/interfaces';
+import type { PezpalletBountiesBounty, PezpalletTreasuryProposal } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+import type { ExactDerive } from './derive.js';
+export * from './accounts/types.js';
+export * from './bagsList/types.js';
+export * from './balances/types.js';
+export * from './council/types.js';
+export * from './crowdloan/types.js';
+export * from './democracy/types.js';
+export * from './elections/types.js';
+export * from './session/types.js';
+export * from './society/types.js';
+export * from './staking/types.js';
+export * from './teyrchains/types.js';
+export * from './type/types.js';
+export interface DeriveApi extends ApiInterfaceRx {
+    derive: ExactDerive;
+}
+export interface DeriveContractFees {
+    callBaseFee: BN;
+    contractFee: BN;
+    creationFee: BN;
+    rentByteFee: BN;
+    rentDepositOffset: BN;
+    surchargeReward: BN;
+    tombstoneDeposit: BN;
+    transactionBaseFee: BN;
+    transactionByteFee: BN;
+    transferFee: BN;
+}
+export interface DeriveCollectiveProposal {
+    hash: Hash;
+    proposal: Proposal | null;
+    votes: Votes | null;
+}
+export interface DeriveFees {
+    creationFee: Balance;
+    existentialDeposit: Balance;
+    transactionBaseFee: Balance;
+    transactionByteFee: Balance;
+    transferFee: Balance;
+}
+export interface DeriveHeartbeatAuthor {
+    blockCount: u32;
+    hasMessage: boolean;
+    isOnline: boolean;
+}
+export type DeriveHeartbeats = Record<string, DeriveHeartbeatAuthor>;
+export interface RecentlyOffline {
+    blockNumber: BlockNumber;
+    count: BN;
+}
+export type DeriveRecentlyOffline = Record<string, RecentlyOffline[]>;
+export interface DeriveTreasuryProposal {
+    council: DeriveCollectiveProposal[];
+    id: ProposalIndex;
+    proposal: PezpalletTreasuryProposal;
+}
+export interface DeriveTreasuryProposals {
+    approvals: DeriveTreasuryProposal[];
+    proposalCount: ProposalIndex;
+    proposals: DeriveTreasuryProposal[];
+}
+export interface VoterPosition {
+    globalIndex: BN;
+    index: BN;
+    setIndex: SetIndex;
+}
+export type DeriveVoterPositions = Record<string, VoterPosition>;
+export interface DeriveBounty {
+    bounty: PezpalletBountiesBounty;
+    description: string;
+    index: BountyIndex;
+    proposals: DeriveCollectiveProposal[];
+}
+export type DeriveBounties = DeriveBounty[];

package/build-tsc/util/approvalFlagsToBools.d.ts

@@ -0,0 +1,4 @@
+import type { Vec } from '@pezkuwi/types';
+import type { ApprovalFlag } from '@pezkuwi/types/interfaces/elections';
+/** @internal */
+export declare function approvalFlagsToBools(flags: Vec<ApprovalFlag> | ApprovalFlag[]): boolean[];

package/build-tsc/util/blockNumber.d.ts

@@ -0,0 +1,7 @@
+import type { Compact } from '@pezkuwi/types';
+import type { BlockNumber } from '@pezkuwi/types/interfaces';
+interface CompatHeader {
+    number: Compact<BlockNumber> | BlockNumber;
+}
+export declare function unwrapBlockNumber(hdr: CompatHeader): BlockNumber;
+export {};

package/build-tsc/util/cache.d.ts

@@ -0,0 +1,4 @@
+import type { DeriveCache } from './types.js';
+declare let deriveCache: DeriveCache;
+export declare function setDeriveCache(prefix?: string, cache?: DeriveCache): void;
+export { deriveCache };

package/build-tsc/util/cacheImpl.d.ts

@@ -0,0 +1,3 @@
+import type { DeriveCache } from './types.js';
+export declare const deriveMapCache: DeriveCache;
+export declare const deriveNoopCache: DeriveCache;

package/build-tsc/util/first.d.ts

@@ -0,0 +1,4 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+export declare function firstObservable<T>(obs: Observable<T[]>): Observable<T>;
+export declare function firstMemo<T, A extends any[]>(fn: (api: DeriveApi, ...args: A) => Observable<T[]>): (instanceId: string, api: DeriveApi) => (...args: A) => Observable<T>;

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

@@ -0,0 +1,7 @@
+export { drr, memo } from '@pezkuwi/rpc-core';
+export * from './approvalFlagsToBools.js';
+export * from './blockNumber.js';
+export * from './cache.js';
+export * from './cacheImpl.js';
+export * from './first.js';
+export * from './lazy.js';