@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-deno/type/util.ts

@@ -0,0 +1,43 @@
+
+import type { AccountId, Digest } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+export function extractAuthor (digest: Digest, sessionValidators: AccountId[]): AccountId | undefined {
+  const [citem] = digest.logs.filter((e) => e.isConsensus);
+  const preRuntimeItems = digest.logs.filter((e) => e.isPreRuntime);
+  const [sitem] = digest.logs.filter((e) => e.isSeal);
+  let accountId: AccountId | undefined;
+
+  try {
+    // This is critical to be first for BABE (before Consensus)
+    // If not first, we end up dropping the author at session-end
+    // Iterate through ALL preRuntime logs to find a recognized engine
+    // (teyrchains may have multiple preRuntime logs, e.g., CMLS + aura)
+    for (const pitem of preRuntimeItems) {
+      const [engine, data] = pitem.asPreRuntime;
+
+      accountId = engine.extractAuthor(data, sessionValidators);
+
+      // Stop at first recognized engine that returns an author
+      if (accountId) {
+        return accountId;
+      }
+    }
+
+    if (!accountId && citem) {
+      const [engine, data] = citem.asConsensus;
+
+      accountId = engine.extractAuthor(data, sessionValidators);
+    }
+
+    // SEAL, still used in e.g. Kulupu for pow
+    if (!accountId && sitem) {
+      const [engine, data] = sitem.asSeal;
+
+      accountId = engine.extractAuthor(data, sessionValidators);
+    }
+  } catch {
+    // ignore
+  }
+
+  return accountId;
+}

package/build-deno/types.ts

@@ -0,0 +1,95 @@
+
+import type { ApiInterfaceRx } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { u32 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { Balance, BlockNumber, BountyIndex, Hash, Proposal, ProposalIndex, SetIndex, Votes } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletBountiesBounty, PezpalletTreasuryProposal } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { ExactDerive } from './derive.ts';
+
+export * from './accounts/types.ts';
+export * from './bagsList/types.ts';
+export * from './balances/types.ts';
+export * from './council/types.ts';
+export * from './crowdloan/types.ts';
+export * from './democracy/types.ts';
+export * from './elections/types.ts';
+export * from './session/types.ts';
+export * from './society/types.ts';
+export * from './staking/types.ts';
+export * from './teyrchains/types.ts';
+export * from './type/types.ts';
+
+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-deno/util/approvalFlagsToBools.ts

@@ -0,0 +1,24 @@
+
+import type { Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { ApprovalFlag } from 'https://deno.land/x/pezkuwi/types/interfaces/elections/index.ts';
+
+/** @internal */
+export function approvalFlagsToBools (flags: Vec<ApprovalFlag> | ApprovalFlag[]): boolean[] {
+  const bools: boolean[] = [];
+
+  for (let i = 0, count = flags.length; i < count; i++) {
+    const str = flags[i].toString(2);
+
+    // read from lowest bit to highest
+    for (const bit of str.split('').reverse()) {
+      bools.push(!!parseInt(bit, 10));
+    }
+  }
+
+  // slice off trailing "false" values, as in bizinikiwi
+  const lastApproval = bools.lastIndexOf(true);
+
+  return lastApproval >= 0
+    ? bools.slice(0, lastApproval + 1)
+    : [];
+}

package/build-deno/util/blockNumber.ts

@@ -0,0 +1,13 @@
+
+import type { Compact } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { BlockNumber } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+import { isCompact } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+interface CompatHeader { number: Compact<BlockNumber> | BlockNumber }
+
+export function unwrapBlockNumber (hdr: CompatHeader): BlockNumber {
+  return isCompact<BlockNumber>(hdr.number)
+    ? hdr.number.unwrap()
+    : hdr.number;
+}

package/build-deno/util/cache.ts

@@ -0,0 +1,63 @@
+
+import type { DeriveCache } from './types.ts';
+
+import { deriveNoopCache } from './cacheImpl.ts';
+
+interface CacheValue<T> {
+  v: T;
+  x: number;
+}
+
+const CACHE_EXPIRY = 7 * (24 * 60) * (60 * 1000);
+
+let deriveCache: DeriveCache;
+
+function wrapCache (keyStart: string, cache: DeriveCache): DeriveCache {
+  return {
+    del: (partial: string): void => cache.del(`${keyStart}${partial}`),
+    forEach: cache.forEach,
+    get: <T> (partial: string): T | undefined => {
+      const key = `${keyStart}${partial}`;
+      const cached = cache.get<CacheValue<T>>(key);
+
+      if (cached) {
+        cached.x = Date.now();
+        cache.set(key, cached);
+
+        return cached.v;
+      }
+
+      return undefined;
+    },
+    set: (partial: string, v: unknown): void => {
+      cache.set(`${keyStart}${partial}`, { v, x: Date.now() });
+    }
+  };
+}
+
+function clearCache (cache: DeriveCache): void {
+  // clear all expired values
+  const now = Date.now();
+  const all: string[] = [];
+
+  cache.forEach((key: string, { x }: CacheValue<any>): void => {
+    ((now - x) > CACHE_EXPIRY) && all.push(key);
+  });
+
+  // don't do delete inside loop, just in-case
+  all.forEach((key) => cache.del(key));
+}
+
+export function setDeriveCache (prefix = '', cache?: DeriveCache): void {
+  deriveCache = cache
+    ? wrapCache(`derive:${prefix}:`, cache)
+    : deriveNoopCache;
+
+  if (cache) {
+    clearCache(cache);
+  }
+}
+
+setDeriveCache();
+
+export { deriveCache };

package/build-deno/util/cacheImpl.ts

@@ -0,0 +1,28 @@
+
+import type { DeriveCache } from './types.ts';
+
+const mapCache = new Map<string, any>();
+
+export const deriveMapCache: DeriveCache = {
+  del: (key: string): void => {
+    mapCache.delete(key);
+  },
+  forEach: (cb: (key: string, value: any) => void): void => {
+    for (const [k, v] of mapCache.entries()) {
+      cb(k, v);
+    }
+  },
+  get: <T = any> (key: string): T | undefined => {
+    return mapCache.get(key) as T;
+  },
+  set: (key: string, value: any): void => {
+    mapCache.set(key, value);
+  }
+};
+
+export const deriveNoopCache: DeriveCache = {
+  del: (): void => undefined,
+  forEach: () => undefined,
+  get: (): undefined => undefined,
+  set: (_: string, value: unknown): unknown => value
+};

package/build-deno/util/first.ts

@@ -0,0 +1,18 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { DeriveApi } from '../types.ts';
+
+import { map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from 'https://deno.land/x/pezkuwi/rpc-core/mod.ts';
+
+export function firstObservable <T> (obs: Observable<T[]>): Observable<T> {
+  return obs.pipe(map(([a]) => a));
+}
+
+export function firstMemo <T, A extends any[]> (fn: (api: DeriveApi, ...args: A) => Observable<T[]>): (instanceId: string, api: DeriveApi) => (...args: A) => Observable<T> {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, (...args: A) =>
+      firstObservable<T>(fn(api, ...args))
+    );
+}

package/build-deno/util/index.ts

@@ -0,0 +1,9 @@
+
+export { drr, memo } from 'https://deno.land/x/pezkuwi/rpc-core/mod.ts';
+
+export * from './approvalFlagsToBools.ts';
+export * from './blockNumber.ts';
+export * from './cache.ts';
+export * from './cacheImpl.ts';
+export * from './first.ts';
+export * from './lazy.ts';

package/build-deno/util/lazy.ts

@@ -0,0 +1,14 @@
+
+import { lazyMethod, lazyMethods } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+type LazySection <T> = Record<string, T>;
+
+type LazyRecord <T> = Record<string, LazySection<T>>;
+
+export function lazyDeriveSection <T> (result: LazyRecord<T>, section: string, getKeys: (s: string) => string[], creator: (s: string, m: string) => T): void {
+  lazyMethod(result, section, () =>
+    lazyMethods({}, getKeys(section), (method: string) =>
+      creator(section, method)
+    )
+  );
+}

package/build-deno/util/types.ts

@@ -0,0 +1,7 @@
+
+export interface DeriveCache {
+  del: (key: string) => void;
+  forEach: (cb: (key: string, value: any) => void) => void;
+  get: <T = any> (key: string) => T | undefined;
+  set: (key: string, value: any) => void;
+}

package/build-tsc/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-tsc/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/build-tsc/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-tsc/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-tsc/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 { PezpalletIdentityRegistration } 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<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | 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) => 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-tsc/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-tsc/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-tsc/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-tsc/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-tsc/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-tsc/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-tsc/augment.d.ts

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

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

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